implement ignored attribute values as a config option

7 files changed, 226 insertions, 131 deletions

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
index d718bb91..3563163e 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
@@ -17,11 +17,13 @@ import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration

 import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser

 import hu.bme.mit.inf.dslreasoner.workspace.URIBasedWorkspace

 import java.io.File

 import java.util.LinkedHashMap

 import java.util.LinkedList

+import java.util.Map

 import java.util.Optional

 import org.eclipse.core.runtime.IProgressMonitor

 import org.eclipse.emf.common.util.URI

@@ -101,6 +103,13 @@ class GenerationTaskExecutor {
                         }

                         monitor.worked(50)

                         

+                        // 5. create a solver and a configuration

+                        // 5.1 initialize

+                        val solver = solverLoader.loadSolver(task.solver,configurationMap)

+                        val objectiveSpecification = scriptExecutor.getObjectiveSpecification(task.objectives)

+                        val objectiveEntries = objectiveSpecification?.entries ?: emptyList

+                        val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,objectiveEntries,console)

+                                        

                         // 4. translate all description to a logic problem

                         monitor.subTask('''Translating all resources to logic''')

                         var domain2LogicTransformationTime = System.nanoTime

@@ -112,9 +121,15 @@ class GenerationTaskExecutor {
                         var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())

                         var problem = modelGeneration.output

                         if(partialModelDescriptor !== null) {

+                                //get ignored attributes

+                                var Map<String, Map<String, String>>ignoredAttributes = null

+                                if (solverConfig instanceof ViatraReasonerConfiguration)

+                                        ignoredAttributes = (solverConfig as ViatraReasonerConfiguration).ignoredAttributesMap

+

                                 problem = instanceModel2Logic.transform(

                                         modelGeneration,

-                                        partialModelDescriptor

+                                        partialModelDescriptor,

+                                        ignoredAttributes

                                 ).output

                         }

                         if(queryDescriptor !== null){

@@ -128,13 +143,8 @@ class GenerationTaskExecutor {
                         if(documentationLevel.atLeastNormal) {

                                 reasonerWorkspace.writeModel(problem,"generation.logicproblem")

                         }

+                        // END 4

                         

-                        // 5. create a solver and a configuration

-                        // 5.1 initialize

-                        val solver = solverLoader.loadSolver(task.solver,configurationMap)

-                        val objectiveSpecification = scriptExecutor.getObjectiveSpecification(task.objectives)

-                        val objectiveEntries = objectiveSpecification?.entries ?: emptyList

-                        val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,objectiveEntries,console)

                         // 5.2 set values that defined directly 

                         solverConfig.solutionScope = new SolutionScope => [

                                 it.numberOfRequiredSolutions = if(task.numberSpecified) {

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend
index 94b84bc3..da8ca0eb 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/SolverLoader.xtend
@@ -30,6 +30,7 @@ import org.eclipse.xtext.EcoreUtil2
 import org.eclipse.xtext.xbase.lib.Functions.Function1

 import hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloyBackendSolver

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.NumericSolverSelection

+import java.util.HashMap

 

 class SolverLoader {

         def loadSolver(Solver solver, Map<String, String> config) {

@@ -166,6 +167,10 @@ class SolverLoader {
                                                 default: throw new IllegalArgumentException("Unknown scope propagator: " + stringValue)

                                         }

                                 }

+                                if (config.containsKey("ignored-attributes")) {

+                                        val stringValue = config.get("ignored-attributes")

+                                        c.ignoredAttributesMap = parseIgnoredAttributes(stringValue) 

+                                }

                                 for (objectiveEntry : objectiveEntries) {

                                         val costObjectiveConfig = new CostObjectiveConfiguration

                                         switch (objectiveEntry) {

@@ -232,6 +237,34 @@ class SolverLoader {
                                 throw new UnsupportedOperationException('''Unknown solver: «solver»''')

                 }

         }

+        

+        def Map<String, Map<String, String>> parseIgnoredAttributes(String input) {

+                val Map<String, Map<String, String>>  clAttVal = newHashMap

+                val List<String> entries = input.split(",")

+                //TODO add some validation here

+                for (entry : entries) {

+                        val List<String> components = entry.split("=")

+                        if (components.size != 2)

+                                throw new IllegalArgumentException("Invalid ignoredAttributes Specification: \"" + entry + "\"")

+

+                        val clAtt = components.get(0)

+                        val List<String> clAttArray = clAtt.split("\\.")

+                        if (clAttArray.size != 2)

+                                throw new IllegalArgumentException("Invalid attribute specification : \"" + clAtt + "\"")

+                        

+                        val c = clAttArray.get(0).strip

+                        val a = clAttArray.get(1).strip 

+                        val v = components.get(1).strip

+                        

+                        val clInMap = clAttVal.get(c)

+                        if (clInMap === null) {

+                                clAttVal.put(c, newHashMap(a -> v))

+                        } else {

+                                clInMap.put(a, v)

+                        }

+                }

+                return clAttVal

+        }

 

         def dispatch void setRunIndex(AlloySolverConfiguration config, Map<String, String> parameters, int runIndex,

                 ScriptConsole console) {

diff --git a/Domains/crossingScenario/inputs/crossingScenarioGen.vsconfig b/Domains/crossingScenario/inputs/crossingScenarioGen.vsconfig
index 1db557a9..bee56db6 100644
--- a/Domains/crossingScenario/inputs/crossingScenarioGen.vsconfig
+++ b/Domains/crossingScenario/inputs/crossingScenarioGen.vsconfig
@@ -23,6 +23,7 @@ generate {
                 log-level = none,

                 "numeric-solver" = "dreal-local",

                 "dreal-local-path" = "/home/models/dreal4/bazel-bin/dreal/dreal",

+                "ignored-attributes" = "CrossingScenario.maxTime=60",

                 "scopePropagator" = "polyhedral"}

         

         runs = 1

diff --git a/Domains/crossingScenario/queries/crossingScenarioQueries.vql b/Domains/crossingScenario/queries/crossingScenarioQueries.vql
index 179da874..2b67e14c 100644
--- a/Domains/crossingScenario/queries/crossingScenarioQueries.vql
+++ b/Domains/crossingScenario/queries/crossingScenarioQueries.vql
@@ -429,97 +429,97 @@ pattern define_relation_noSelfRelation(a1:Actor, a2:Actor) {
 //CollisionExists

 ///////*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*//////

         

-//@Constraint(severity="error", key={c}, message="x")

-//pattern collisionExists_timeWithinBound(ss:CrossingScenario, c:CollisionExists) {

-//      CrossingScenario.relations(ss, c);

-//      CrossingScenario.maxTime(ss, maxTime);

-//      CollisionExists.collisionTime(c, cTime);

-//      check(cTime >= maxTime);}

-//
-//@Constraint(severity="error", key={c}, message="x")
-//pattern collisionExists_timeNotNegative(c:CollisionExists) {
-//      CollisionExists. collisionTime(c, cTime);
-//      check(cTime <= 0.0);}

-//

-//private pattern helper_getCollExistsTime(a1:Actor, a2: Actor, cTime:java Double) {

-//      CollisionExists.source(c, a1);

-//      CollisionExists.target(c, a2);

-//      CollisionExists. collisionTime(c, cTime);

-//}

-//

-//private pattern helper_getYCoords(a:Actor, l:java Double, 

-//      yPos:java Double, ySpeed:java Double) {

-//

-//      Actor.length(a, l);

-//      Actor.yPos(a, yPos);

-//      Actor.ySpeed(a, ySpeed);

-//}

-//

-//private pattern helper_getAllYCoords(a1:Actor, a2: Actor, 

-//      l1:java Double, l2:java Double, yPos1:java Double, yPos2:java Double,

-//      ySpeed1:java Double, ySpeed2:java Double) {

-//

-//      find helper_getYCoords(a1, l1, yPos1, ySpeed1);

-//      find helper_getYCoords(a2, l2, yPos2, ySpeed2);

-//}

-//

-//private pattern helper_getXCoords(a:Actor, l:java Double, 

-//      xPos:java Double, xSpeed:java Double) {

-//

-//      Actor.length(a, l);

-//      Actor.xPos(a, xPos);

-//      Actor.xSpeed(a, xSpeed);

-//}

-//

-//private pattern helper_getAllXCoords(a1:Actor, a2: Actor, 

-//      w1:java Double, w2:java Double, xPos1:java Double, xPos2:java Double,

-//      xSpeed1:java Double, xSpeed2:java Double) {

-//

-//      find helper_getYCoords(a1, w1, xPos1, xSpeed1);

-//      find helper_getYCoords(a2, w2, xPos2, xSpeed2);

-//}

-//

-//@Constraint(severity="error", key={a1}, message="x")

-//pattern collisionExists_defineCollision_y1(a1:Actor, a2:Actor) {

-//

-//      find helper_getCollExistsTime(a1, a2, cTime);

-//      find helper_getAllYCoords(a1, a2, l1, l2, yPos1, yPos2, ySpeed1, ySpeed2);

-//      

-//      //check(y_1_bottom > y_2_top

-//      check((yPos1 + (ySpeed1 * cTime)) - (l1/2) > (yPos2 + (ySpeed2 * cTime)) + (l2/2));     

-//}

-//

-//@Constraint(severity="error", key={a1}, message="x")

-//pattern collisionExists_defineCollision_y2(a1:Actor, a2:Actor) {

-//      //This second one is required because we do not want to enforce both a1->c->a2 and a2->c->a1

-//

-//      find helper_getCollExistsTime(a1, a2, cTime);

-//      find helper_getAllYCoords(a1, a2, l1, l2, yPos1, yPos2, ySpeed1, ySpeed2);

-//      

-//      //check(y_1_top < y_2_bottom)

-//      check((yPos1 + (ySpeed1 * cTime)) + (l1/2) < (yPos2 + (ySpeed2 * cTime)) - (l2/2));     

-//}

-//

-//@Constraint(severity="error", key={a1}, message="x")

-//pattern collisionExists_defineCollision_x1(a1:Actor, a2:Actor) {

-//

-//      find helper_getCollExistsTime(a1, a2, cTime);

-//      find helper_getAllYCoords(a1, a2, w1, w2, xPos1, xPos2, xSpeed1, xSpeed2);

-//      

-//      //check(x_1_left > x_2_right)

-//      check((xPos1 + (xSpeed1 * cTime)) - (w1/2) > (xPos2 + (xSpeed2 * cTime)) + (w2/2));     

-//}

-//

-//@Constraint(severity="error", key={a1}, message="x")

-//pattern collisionExists_defineCollision_x2(a1:Actor, a2:Actor) {

-//      //This second one is required because we do not want to enforce both a1->c->a2 and a2->c->a1

-//

-//      find helper_getCollExistsTime(a1, a2, cTime);

-//      find helper_getAllYCoords(a1, a2, w1, w2, xPos1, xPos2, xSpeed1, xSpeed2);

-//      

-//      //check(x_1_right < x_2_left)

-//      check((xPos1 + (xSpeed1 * cTime)) + (w1/2) < (xPos2 + (xSpeed2 * cTime)) - (w2/2));     

-//}

+@Constraint(severity="error", key={c}, message="x")

+pattern collisionExists_timeWithinBound(ss:CrossingScenario, c:CollisionExists) {

+        CrossingScenario.relations(ss, c);

+        CrossingScenario.maxTime(ss, maxTime);

+        CollisionExists.collisionTime(c, cTime);

+        check(cTime >= maxTime);}

+
+@Constraint(severity="error", key={c}, message="x")
+pattern collisionExists_timeNotNegative(c:CollisionExists) {
+        CollisionExists. collisionTime(c, cTime);
+        check(cTime <= 0.0);}

+

+private pattern helper_getCollExistsTime(a1:Actor, a2: Actor, cTime:java Double) {

+        CollisionExists.source(c, a1);

+        CollisionExists.target(c, a2);

+        CollisionExists. collisionTime(c, cTime);

+}

+

+private pattern helper_getYCoords(a:Actor, l:java Double, 

+        yPos:java Double, ySpeed:java Double) {

+

+        Actor.length(a, l);

+        Actor.yPos(a, yPos);

+        Actor.ySpeed(a, ySpeed);

+}

+

+private pattern helper_getAllYCoords(a1:Actor, a2: Actor, 

+        l1:java Double, l2:java Double, yPos1:java Double, yPos2:java Double,

+        ySpeed1:java Double, ySpeed2:java Double) {

+

+        find helper_getYCoords(a1, l1, yPos1, ySpeed1);

+        find helper_getYCoords(a2, l2, yPos2, ySpeed2);

+}

+

+private pattern helper_getXCoords(a:Actor, l:java Double, 

+        xPos:java Double, xSpeed:java Double) {

+

+        Actor.length(a, l);

+        Actor.xPos(a, xPos);

+        Actor.xSpeed(a, xSpeed);

+}

+

+private pattern helper_getAllXCoords(a1:Actor, a2: Actor, 

+        w1:java Double, w2:java Double, xPos1:java Double, xPos2:java Double,

+        xSpeed1:java Double, xSpeed2:java Double) {

+

+        find helper_getYCoords(a1, w1, xPos1, xSpeed1);

+        find helper_getYCoords(a2, w2, xPos2, xSpeed2);

+}

+

+@Constraint(severity="error", key={a1}, message="x")

+pattern collisionExists_defineCollision_y1(a1:Actor, a2:Actor) {

+

+        find helper_getCollExistsTime(a1, a2, cTime);

+        find helper_getAllYCoords(a1, a2, l1, l2, yPos1, yPos2, ySpeed1, ySpeed2);

+        

+        //check(y_1_bottom > y_2_top

+        check((yPos1 + (ySpeed1 * cTime)) - (l1/2) > (yPos2 + (ySpeed2 * cTime)) + (l2/2));     

+}

+

+@Constraint(severity="error", key={a1}, message="x")

+pattern collisionExists_defineCollision_y2(a1:Actor, a2:Actor) {

+        //This second one is required because we do not want to enforce both a1->c->a2 and a2->c->a1

+

+        find helper_getCollExistsTime(a1, a2, cTime);

+        find helper_getAllYCoords(a1, a2, l1, l2, yPos1, yPos2, ySpeed1, ySpeed2);

+        

+        //check(y_1_top < y_2_bottom)

+        check((yPos1 + (ySpeed1 * cTime)) + (l1/2) < (yPos2 + (ySpeed2 * cTime)) - (l2/2));     

+}

+

+@Constraint(severity="error", key={a1}, message="x")

+pattern collisionExists_defineCollision_x1(a1:Actor, a2:Actor) {

+

+        find helper_getCollExistsTime(a1, a2, cTime);

+        find helper_getAllYCoords(a1, a2, w1, w2, xPos1, xPos2, xSpeed1, xSpeed2);

+        

+        //check(x_1_left > x_2_right)

+        check((xPos1 + (xSpeed1 * cTime)) - (w1/2) > (xPos2 + (xSpeed2 * cTime)) + (w2/2));     

+}

+

+@Constraint(severity="error", key={a1}, message="x")

+pattern collisionExists_defineCollision_x2(a1:Actor, a2:Actor) {

+        //This second one is required because we do not want to enforce both a1->c->a2 and a2->c->a1

+

+        find helper_getCollExistsTime(a1, a2, cTime);

+        find helper_getAllYCoords(a1, a2, w1, w2, xPos1, xPos2, xSpeed1, xSpeed2);

+        

+        //check(x_1_right < x_2_left)

+        check((xPos1 + (xSpeed1 * cTime)) + (w1/2) < (xPos2 + (xSpeed2 * cTime)) - (w2/2));     

+}

 

 

 ///////*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*-_-*//////

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend
index d2b59754..7cec6327 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend
@@ -4,8 +4,8 @@ import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import java.util.List

+import java.util.Map

 import org.eclipse.emf.ecore.EObject

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes

 

 class InstanceModel2Logic {

         val InstanceModel2PartialInterpretation instanceModel2PartialInterpretation = new InstanceModel2PartialInterpretation

@@ -13,9 +13,10 @@ class InstanceModel2Logic {
         

         public def transform(

                 TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelTranslationResult,

-                List<EObject> objects) 

+                List<EObject> objects,

+                Map<String, Map<String, String>> ignoredAttribs) 

         {

-                val res1 = instanceModel2PartialInterpretation.transform(metamodelTranslationResult,objects,true)

+                val res1 = instanceModel2PartialInterpretation.transform(metamodelTranslationResult, ignoredAttribs, objects,true)

                 this.partialInterpretation2Logic.transformPartialIntepretation2Logic(metamodelTranslationResult.output,res1)

                 return metamodelTranslationResult//.output

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
index 94959025..f2f43aaa 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
@@ -3,6 +3,7 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic
 import com.google.common.collect.ImmutableList

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

@@ -33,7 +34,8 @@ class InstanceModel2PartialInterpretation {
         

         public def transform(

                 TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelTranslationResult,

-                Resource resource,

+                Map<String, Map<String, String>> ignoredAttribs,

+                Resource resource, 

                 boolean withID) 

         {

                 val objectsBuilder = ImmutableList.builder

@@ -49,11 +51,12 @@ class InstanceModel2PartialInterpretation {
                         }

                 }

                 val objects = objectsBuilder.build

-                return transform(metamodelTranslationResult,objects,withID)

+                return transform(metamodelTranslationResult, ignoredAttribs, objects, withID)

         }

         

         public def transform(

                 TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelTranslationResult,

+                Map<String, Map<String, String>> ignoredAttribs, 

                 List<EObject> objects,

                 boolean withID) 

         {

@@ -63,7 +66,7 @@ class InstanceModel2PartialInterpretation {
                 val referencesUsed = ecore2Logic.allReferencesInScope(ecore2LogicTrace).toSet

                 val attributesUsed = ecore2Logic.allAttributesInScope(ecore2LogicTrace).toSet

                 

-                val typeScope = createTypeScopesFromKnownAttributeValues(objects,attributesUsed)

+                val typeScope = createTypeScopesFromKnownAttributeValues(objects,attributesUsed, ignoredAttribs)

                 val tracedOutput = partialInterpretationInitialiser.initialisePartialInterpretation(problem, typeScope)

                 val partialInterpretation = tracedOutput.output

                 val partialInterpretationTrace = tracedOutput.trace

@@ -119,23 +122,26 @@ class InstanceModel2PartialInterpretation {
                         

                         // Transforming the attributes

                         for(attribute : source.eClass.EAllAttributes.filter[attributesUsed.contains(it) && !it.derived]) {

-                                val type = ecore2Logic.relationOfAttribute(ecore2LogicTrace,attribute)

-                                val interpretation = type.lookup(partialInterpretationTrace.relation2Interpretation)

-                                val sourceElement = source.lookup(object2DefinedElement)

-                                if(attribute.isMany) {

-                                        val listOfTargets = source.eGet(attribute) as List<? extends EObject>

-                                        for(target : listOfTargets) {

-                                                val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace)

-                                                if(value !== null) {

-                                                        translateLink(interpretation,sourceElement,value)

+                                val isIgnored = checkIfIgnored(source, attribute, ignoredAttribs)

+                                if (!isIgnored) {

+                                        val type = ecore2Logic.relationOfAttribute(ecore2LogicTrace,attribute)

+                                        val interpretation = type.lookup(partialInterpretationTrace.relation2Interpretation)

+                                        val sourceElement = source.lookup(object2DefinedElement)

+                                        if(attribute.isMany) {

+                                                val listOfTargets = source.eGet(attribute) as List<? extends EObject>

+                                                for(target : listOfTargets) {

+                                                        val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace)

+                                                        if(value !== null) {

+                                                                translateLink(interpretation,sourceElement,value)

+                                                        }

                                                 }

-                                        }

-                                } else {

-                                        val target = source.eGet(attribute)

-                                        if(target !== null) {

-                                                val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace)

-                                                if(value !== null) {

-                                                        translateLink(interpretation,sourceElement,value)

+                                        } else {

+                                                val target = source.eGet(attribute)

+                                                if(target !== null) {

+                                                        val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace)

+                                                        if(value !== null) {

+                                                                translateLink(interpretation,sourceElement,value)

+                                                        }

                                                 }

                                         }

                                 }

@@ -144,21 +150,29 @@ class InstanceModel2PartialInterpretation {
                 

                 return partialInterpretation

         }

-        

-        private def createTypeScopesFromKnownAttributeValues(List<EObject> objects, Set<EAttribute> attributesUsed) {

+

+        private def createTypeScopesFromKnownAttributeValues(

+                List<EObject> objects,

+                Set<EAttribute> attributesUsed, 

+                Map<String, Map<String, String>> ignoredAttribs)

+        {

                 val Set<Integer> integers = new HashSet

                 val Set<Double> reals = new HashSet

                 val Set<String> strings = new HashSet

-                for(object: objects) {

-                        for(attribute : object.eClass.EAllAttributes.filter[attributesUsed.contains(it)]) {

-                                val value = object.eGet(attribute)

-                                if(value !== null) {

-                                        if(value instanceof List<?>) {

-                                                for(v : value) {

-                                                        shortValue(v,integers,reals,strings)

+                for (object : objects) {

+                        for (attribute : object.eClass.EAllAttributes.filter[attributesUsed.contains(it)]) {

+                                val isIgnored = checkIfIgnored(object, attribute, ignoredAttribs)

+                                

+                                if(!isIgnored) {

+                                        val value = object.eGet(attribute)

+                                        if(value !== null) {

+                                                if(value instanceof List<?>) {

+                                                        for(v : value) {

+                                                                shortValue(v,integers,reals,strings)

+                                                        }

+                                                } else {

+                                                        shortValue(value,integers,reals,strings)

                                                 }

-                                        } else {

-                                                shortValue(value,integers,reals,strings)

                                         }

                                 }

                         }

@@ -169,6 +183,40 @@ class InstanceModel2PartialInterpretation {
                         it.knownStrings += strings

                 ]

         }

+        private def boolean checkIfIgnored(

+                EObject object, 

+                EAttribute attribute,

+                Map<String, Map<String, String>> ignoredAttribs

+        ) {

+                val classInIgnored = ignoredAttribs.get(object.eClass.name)

+                val mayIgnored = (

+                                        classInIgnored !== null && classInIgnored.containsKey(attribute.name))

+

+                var isIgnored = false

+                if (mayIgnored) {

+                        val specificIgnoredValue = classInIgnored.get(attribute.name)

+                        if (specificIgnoredValue.equals("*"))

+                                isIgnored = true

+                        else {

+                                val value = object.eGet(attribute)

+                                if (typeof(Number).isAssignableFrom(value.class)) {

+                                        isIgnored = (Double.valueOf(specificIgnoredValue) == value)

+                                } else {

+                                        isIgnored = specificIgnoredValue.equals(value)

+                                }

+                        }

+                }

+                // DEBUG

+//              println("DEBUG BEGINNING")

+//              println(object)

+//              println(attribute)

+//              println(value)

+//              

+//              println("MAYIGNORE " + mayIgnored)

+//              println("ISIGNORED " + isIgnored)

+                // END DEBUG

+                return isIgnored

+        }

         private def dispatch shortValue(Boolean value, Set<Integer> integers, Set<Double> reals, Set<String> strings) {

                 // Do nothing

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
index 759f434b..fbcd6e1d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
@@ -16,6 +16,7 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKi
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold

 import java.util.LinkedList

 import java.util.List

+import java.util.Map

 import java.util.Set

 import org.eclipse.xtext.xbase.lib.Functions.Function1

 

@@ -78,6 +79,7 @@ class ViatraReasonerConfiguration extends LogicSolverConfiguration {
         public var calculateObjectCreationCosts = false

         public NumericSolverSelection numericSolverSelection = NumericSolverSelection.DREAL_DOCKER //currently defaulted to DREAL

         public var drealLocalPath = "<path-to-dreal>";

+        public var Map<String, Map<String, String>> ignoredAttributesMap = null;

         

         public var ScopePropagatorStrategy scopePropagatorStrategy = new ScopePropagatorStrategy.Polyhedral(

                 PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp)