6 files changed, 139 insertions, 25 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
index be11ed78..ca09ae00 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
@@ -77,7 +77,7 @@ class ModelGenerationMethodProvider {
                        objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(logicProblem, emptySolution, queries,scopePropagator,nameNewElements,statistics)
                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries,statistics)
                
-                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(queries)
+                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem,queries)
                val unfinishedWF = queries.getUnfinishedWFQueries.values
                
                val invalidWF = queries.getInvalidWFQueries.values
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
index e05160d0..e1358fb6 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
@@ -10,23 +10,33 @@ class MultiplicityGoalConstraintCalculator {
        val String targetRelationName;
        val IQuerySpecification<?> querySpecification;
        var ViatraQueryMatcher<?> matcher;
+        val boolean containment
+        val int cost
                
-        public new(String targetRelationName, IQuerySpecification<?> querySpecification) {
+        public new(String targetRelationName, IQuerySpecification<?> querySpecification, boolean containment, int cost) {
                this.targetRelationName = targetRelationName
                this.querySpecification = querySpecification
                this.matcher = null
+                this.containment = containment
+                this.cost = cost
        }
        
        public new(MultiplicityGoalConstraintCalculator other) {
                this.targetRelationName = other.targetRelationName
                this.querySpecification = other.querySpecification
                this.matcher = null
+                this.containment = other.containment
+                this.cost = other.cost
        }
        
        def public getName() {
                targetRelationName
        }
        
+        def isContainment() {
+                return containment
+        }
+        
        def public init(Notifier notifier) {
                val engine = ViatraQueryEngine.on(new EMFScope(notifier))
                matcher = querySpecification.getMatcher(engine)
@@ -36,11 +46,14 @@ class MultiplicityGoalConstraintCalculator {
                var res = 0
                val allMatches = this.matcher.allMatches
                for(match : allMatches) {
-                        //println(targetRelationName+ " missing multiplicity: "+match.get(3))
+                        
                        val missingMultiplicity = match.get(4) as Integer
                        res += missingMultiplicity
+                        if(missingMultiplicity!=0) {
+                                println(targetRelationName+ " missing multiplicity: "+missingMultiplicity)
+                        }
                }
                //println(targetRelationName+ " all missing multiplicities: "+res)
-                return res
+                return res*cost
        }
 }
 \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
index 4a8da38c..a4dcefbf 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
@@ -235,10 +235,10 @@ class PConstraintTransformer {
                                        «ENDFOR»
                                        check(
                                                «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»
-                                                «IF variable2Type.values.filter(RealTypeReference).empty»
+«««                                          «IF variable2Type.values.filter(RealTypeReference).empty»
-                                                ||
+«««                                          ||
-                                                («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»)
+«««                                          («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»)
-                                                «ENDIF»
+«««                                          «ENDIF»
                                        );
                                '''
                        } else { // Must or Current
@@ -246,9 +246,9 @@ class PConstraintTransformer {
                                        «FOR variable: e.affectedVariables»
                                                PrimitiveElement.valueSet(«variable.canonizeName»,true); «hasValueExpression(variableMapping,variable,variable.valueVariable)»
                                        «ENDFOR»
-                                        «IF variable2Type.values.filter(RealTypeReference).empty»
+«««                                  «IF variable2Type.values.filter(RealTypeReference).empty»
-                                                check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»);
+«««                                          check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»);
-                                        «ENDIF»
+«««                                  «ENDIF»
                                '''
                        }
                }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
index 750107f6..cfea499b 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -27,7 +27,8 @@ import java.util.HashMap
 @Data class GeneratedPatterns {
        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries
        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries
-        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedMulticiplicityQueries
+        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedContainmentMulticiplicityQueries
+        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedNonContainmentMulticiplicityQueries
        public Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries
        public Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries
        public Map<Pair<RelationDeclaration, Relation>,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries
@@ -86,8 +87,23 @@ class PatternProvider {
                        invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)]
                val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
                        unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)]
-                val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
+                        
-                        unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)]
+                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem)
+                val unfinishedContainmentMultiplicities = new HashMap
+                val unfinishedNonContainmentMultiplicities = new HashMap
+                for(entry : unfinishedMultiplicities.entrySet) {
+                        val relation = entry.key
+                        val value = entry.value.lookup(queries)
+                        if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) {
+                                unfinishedContainmentMultiplicities.put(relation,value)
+                        } else {
+                                unfinishedNonContainmentMultiplicities.put(relation,value)
+                        }
+                }
+//              val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
+//                      unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)]
+//                      
+                        
                val Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
                        refineObjectsQueries = patternGenerator.typeRefinementGenerator.getRefineObjectQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)]
                val Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
@@ -101,7 +117,8 @@ class PatternProvider {
                return new GeneratedPatterns(
                        invalidWFQueries,
                        unfinishedWFQueries,
-                        unfinishedMultiplicityQueries,
+                        unfinishedContainmentMultiplicities,
+                        unfinishedNonContainmentMultiplicities,
                        refineObjectsQueries,
                        refineTypeQueries,
                        refineRelationQueries,
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
index e1be2742..87f7e339 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
@@ -1,18 +1,97 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
 import java.util.ArrayList
+import java.util.HashMap
+import java.util.LinkedList
+import java.util.List
+import java.util.Map
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class GoalConstraintProvider {
-        def public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) {
+        val calculateObjectCost = true
-                val multiplicityQueries = patterns.unfinishedMulticiplicityQueries
+        
-                val res = new ArrayList(multiplicityQueries.size)
+        def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) {
-                for(multiplicityQuery : multiplicityQueries.entrySet) {
+                val res = new ArrayList()
+                
+                res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)
+                if(calculateObjectCost) {
+                        val middingObjectCost = calculateMissingObjectCost(p)
+                        res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)
+                } else {
+                        res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)
+                }
+                return res
+        }
+        
+        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries, boolean containment) {
+                for(multiplicityQuery : queries.entrySet) {
                        val targetRelationName = multiplicityQuery.key.name
                        val query = multiplicityQuery.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query);
+                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,1);
+                }
+        }
+        def addAll(
+                ArrayList<MultiplicityGoalConstraintCalculator> res,
+                Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries,
+                boolean containment,
+                Map<Relation, Integer> cost
+        ) {
+                for(multiplicityQuery : queries.entrySet) {
+                        val targetRelationName = multiplicityQuery.key.name
+                        val query = multiplicityQuery.value
+                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,multiplicityQuery.key.lookup(cost))
+                }
+        }
+        
+        def calculateMissingObjectCost(LogicProblem p) {
+                val containments = p.containmentHierarchies.head.containmentRelations
+                val containment2Lower = containments.toInvertedMap[containment | 
+                        val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
+                        if(lower !== null) { lower.lower }
+                        else { 0 }
+                ]
+                val types = p.types
+                val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap
+                for(type:types) {
+                        val allSupertypes = (#[type] + type.supertypes).toSet
+                        val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]
+                        val list = new LinkedList
+                        for(outgoingContainment : allOutgoingContainments) {
+                                val value = containment2Lower.get(outgoingContainment)
+                                if(value>0) {
+                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred
+                                                        ->      value)
+                                }
+                        }
+                        type2NewCost.put(type, list)
+                }
+                val res = new HashMap
+                for(containment : containments) {
+                        val key = containment
+                        val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
+                        //println('''«key.name» --> «value» new''')
+                        res.put(key,value)
                }
                return res
        }
+        
+        private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {
+                val list = containments.get(t)
+                var r = 1
+                for(element : list) {
+                        r += element.value * element.key.count(containments)
+                }
+                return r
+        }
 }
 \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
index 9e4792e0..e75cae41 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
@@ -55,17 +55,22 @@ class ModelGenerationCompositeObjective implements IObjective{
                //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]
                val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)
                
-                
+                var containmentMultiplicity = 0.0
-                var multiplicity = 0.0
+                var nonContainmentMultiplicity = 0.0
                for(multiplicityObjective : unfinishedMultiplicityObjectives) {
-                        multiplicity+=multiplicityObjective.getFitness(context)
+                        if(multiplicityObjective.containment) {
+                                containmentMultiplicity+=multiplicityObjective.getFitness(context)
+                        } else {
+                                nonContainmentMultiplicity+=multiplicityObjective.getFitness(context)
+                        }
                }
                var sum = 0.0
                sum += scopeFitnes
-                sum +=multiplicity
+                sum += containmentMultiplicity
+                sum += Math.sqrt(nonContainmentMultiplicity)
                sum += unfinishedWFsFitness//*0.5
                
-                println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''')
+                //println('''Sum=«sum»|Scope=«scopeFitnes»|ContainmentMultiplicity=«containmentMultiplicity»|NonContainmentMultiplicity=«nonContainmentMultiplicity»|WFs=«unfinishedWFsFitness»''')
                
                return sum
        }