1 files changed, 77 insertions, 53 deletions
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 9fc6853c..27208cf4 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
@@ -1,99 +1,123 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IThreeValuedObjective
 import java.util.Comparator
 import java.util.List
 import org.eclipse.viatra.dse.base.ThreadContext
 import org.eclipse.viatra.dse.objectives.Comparators
 import org.eclipse.viatra.dse.objectives.IObjective
-import org.eclipse.viatra.dse.objectives.impl.BaseObjective
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement
-//class ViatraReasonerNumbers {
+class ModelGenerationCompositeObjective implements IThreeValuedObjective {
-//      public static val scopePriority = 2
+        val IObjective scopeObjective
-//      public static val unfinishedMultiplicityPriority = 2
-//      public static val unifinshedWFPriority = 2
-//      //public static val complexityPriority = 4
-//      
-//      public static val scopeWeigth = 1.0
-//      public static val unfinishedMultiplicityWeigth = 1.5
-//      public static val unfinishedWFWeigth = 1.5
-//      //public static val complexityWeigth = 0.1
-//      
-//      public static val useCompositeObjective = true
-//      public static val compositePriority = 2
-//}
-class ModelGenerationCompositeObjective implements IObjective{
-        val ScopeObjective scopeObjective
        val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives
        val UnfinishedWFObjective unfinishedWFObjective
-        var boolean isWFOptional = false;
+        var PartialInterpretation model = null
+        val int scopeWeight
+        val int conaintmentWeight
+        val int nonContainmentWeight
+        val int unfinishedWFWeight
        
-        public new(
+        new(
-                ScopeObjective scopeObjective,
+                IObjective scopeObjective,
+                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
+                UnfinishedWFObjective unfinishedWFObjective,
+                ViatraReasonerConfiguration configuration)
+        {
+                this(
+                        scopeObjective, unfinishedMultiplicityObjectives, unfinishedWFObjective,
+                        configuration.scopeWeight, configuration.conaintmentWeight, configuration.nonContainmentWeight,
+                        configuration.unfinishedWFWeight
+                )
+        }
+        new(
+                IObjective scopeObjective,
                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
                UnfinishedWFObjective unfinishedWFObjective,
-                boolean isWFOptional)
+                int scopeWeight, int conaintmentWeight, int nonContainmentWeight, int unfinishedWFWeight)
        {
                this.scopeObjective = scopeObjective
                this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives
                this.unfinishedWFObjective = unfinishedWFObjective
-                this.isWFOptional = isWFOptional;
+                
-        }
+                this.scopeWeight = scopeWeight
-        
+                this.conaintmentWeight = conaintmentWeight
-        def getIsWFOptional(){
+                this.nonContainmentWeight = nonContainmentWeight
-                return this.isWFOptional;
+                this.unfinishedWFWeight = unfinishedWFWeight
        }
        
        override init(ThreadContext context) {
+                model = context.model as PartialInterpretation
                this.scopeObjective.init(context)
                this.unfinishedMultiplicityObjectives.forEach[it.init(context)]
                this.unfinishedWFObjective.init(context)
        }
-        
        override createNew() {
                return new ModelGenerationCompositeObjective(
-                        this.scopeObjective, this.unfinishedMultiplicityObjectives, this.unfinishedWFObjective, this.isWFOptional)
+                        scopeObjective.createNew,
+                        ImmutableList.copyOf(unfinishedMultiplicityObjectives.map[createNew as UnfinishedMultiplicityObjective]),
+                        unfinishedWFObjective.createNew as UnfinishedWFObjective,
+                        scopeWeight, conaintmentWeight, nonContainmentWeight, unfinishedWFWeight
+                )
        }
-        
        override getComparator() { Comparators.LOWER_IS_BETTER }
        override getFitness(ThreadContext context) {
-                var sum = 0.0
+                
                val scopeFitnes = scopeObjective.getFitness(context)
-                //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]
+                val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)
                
-                sum+=scopeFitnes
+                var containmentMultiplicity = 0.0
-                var multiplicity = 0.0
+                var nonContainmentMultiplicity = 0.0
                for(multiplicityObjective : unfinishedMultiplicityObjectives) {
-                        multiplicity+=multiplicityObjective.getFitness(context)//*0.5
+                        val multiplicity = multiplicityObjective.getFitness(context)
+//                      println(multiplicityObjective.name + "=" + multiplicity)
+                        if(multiplicityObjective.containment) {
+                                containmentMultiplicity+=multiplicity
+                        } else {
+                                nonContainmentMultiplicity+=multiplicity
+                        }
+                        
                }
-                sum+=multiplicity
                
-                // the WF can be optional when generating realistic models
+                var sum = 0.0
-                if(!isWFOptional){
+                sum += scopeFitnes*scopeWeight
-                        val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)
+                sum += containmentMultiplicity*conaintmentWeight
-                        sum += unfinishedWFsFitness//*0.5
+                sum += nonContainmentMultiplicity*nonContainmentWeight
-                }
+                sum += unfinishedWFsFitness*unfinishedWFWeight
                
-                //println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''')
+//              println('''scope=«scopeFitnes», containment=«containmentMultiplicity», nonContainment=«nonContainmentMultiplicity», wf=«unfinishedWFsFitness», sum=«sum»''')
                
                return sum
        }
        
-        override getLevel() { 2 }
+        override getWorstPossibleFitness(ThreadContext threadContext) {
-        override getName() { "CompositeUnfinishednessObjective"}
+                Double.POSITIVE_INFINITY
-        def getObjective(){
-                return this.unfinishedMultiplicityObjectives;
        }
        
+        override getBestPossibleFitness(ThreadContext threadContext) {
+                0.0
+        }
+        override getLevel() { 2 }
+        override getName() { "CompositeUnfinishednessObjective" }
        override isHardObjective() { true }
-        override satisifiesHardObjective(Double fitness) { fitness <= 0.001 }
-        
+        override satisifiesHardObjective(Double fitness) { fitness < 0.01 }
-        
        override setComparator(Comparator<Double> comparator) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException("Model generation objective comparator cannot be set.")
        }
        override setLevel(int level) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException("Model generation objective level cannot be set.")
        }
-        
+}
-}
-\ 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 9fc6853c..27208cf4 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
@@ -1,99 +1,123 @@
1	package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
2		2
		3	import com.google.common.collect.ImmutableList
		4	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
		5	import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
		6	import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IThreeValuedObjective
3	import java.util.Comparator	7	import java.util.Comparator
4	import java.util.List	8	import java.util.List
5	import org.eclipse.viatra.dse.base.ThreadContext	9	import org.eclipse.viatra.dse.base.ThreadContext
6	import org.eclipse.viatra.dse.objectives.Comparators	10	import org.eclipse.viatra.dse.objectives.Comparators
7	import org.eclipse.viatra.dse.objectives.IObjective	11	import org.eclipse.viatra.dse.objectives.IObjective
8	import org.eclipse.viatra.dse.objectives.impl.BaseObjective	12	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement
9		13
10	//class ViatraReasonerNumbers {	14	class ModelGenerationCompositeObjective implements IThreeValuedObjective {
11	// public static val scopePriority = 2	15	val IObjective scopeObjective
12	// public static val unfinishedMultiplicityPriority = 2
13	// public static val unifinshedWFPriority = 2
14	// //public static val complexityPriority = 4
15	//
16	// public static val scopeWeigth = 1.0
17	// public static val unfinishedMultiplicityWeigth = 1.5
18	// public static val unfinishedWFWeigth = 1.5
19	// //public static val complexityWeigth = 0.1
20	//
21	// public static val useCompositeObjective = true
22	// public static val compositePriority = 2
23	//}
24
25	class ModelGenerationCompositeObjective implements IObjective{
26	val ScopeObjective scopeObjective
27	val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives	16	val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives
28	val UnfinishedWFObjective unfinishedWFObjective	17	val UnfinishedWFObjective unfinishedWFObjective
29	var boolean isWFOptional = false;	18	var PartialInterpretation model = null
		19	val int scopeWeight
		20	val int conaintmentWeight
		21	val int nonContainmentWeight
		22	val int unfinishedWFWeight
30		23
31	public new(	24	new(
32	ScopeObjective scopeObjective,	25	IObjective scopeObjective,
		26	List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
		27	UnfinishedWFObjective unfinishedWFObjective,
		28	ViatraReasonerConfiguration configuration)
		29	{
		30	this(
		31	scopeObjective, unfinishedMultiplicityObjectives, unfinishedWFObjective,
		32	configuration.scopeWeight, configuration.conaintmentWeight, configuration.nonContainmentWeight,
		33	configuration.unfinishedWFWeight
		34	)
		35	}
		36
		37	new(
		38	IObjective scopeObjective,
33	List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,	39	List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
34	UnfinishedWFObjective unfinishedWFObjective,	40	UnfinishedWFObjective unfinishedWFObjective,
35	boolean isWFOptional)	41	int scopeWeight, int conaintmentWeight, int nonContainmentWeight, int unfinishedWFWeight)
36	{	42	{
37	this.scopeObjective = scopeObjective	43	this.scopeObjective = scopeObjective
38	this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives	44	this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives
39	this.unfinishedWFObjective = unfinishedWFObjective	45	this.unfinishedWFObjective = unfinishedWFObjective
40	this.isWFOptional = isWFOptional;	46
41	}	47	this.scopeWeight = scopeWeight
42		48	this.conaintmentWeight = conaintmentWeight
43	def getIsWFOptional(){	49	this.nonContainmentWeight = nonContainmentWeight
44	return this.isWFOptional;	50	this.unfinishedWFWeight = unfinishedWFWeight
45	}	51	}
46		52
47	override init(ThreadContext context) {	53	override init(ThreadContext context) {
		54	model = context.model as PartialInterpretation
48	this.scopeObjective.init(context)	55	this.scopeObjective.init(context)
49	this.unfinishedMultiplicityObjectives.forEach[it.init(context)]	56	this.unfinishedMultiplicityObjectives.forEach[it.init(context)]
50	this.unfinishedWFObjective.init(context)	57	this.unfinishedWFObjective.init(context)
51	}	58	}
52		59
53	override createNew() {	60	override createNew() {
54	return new ModelGenerationCompositeObjective(	61	return new ModelGenerationCompositeObjective(
55	this.scopeObjective, this.unfinishedMultiplicityObjectives, this.unfinishedWFObjective, this.isWFOptional)	62	scopeObjective.createNew,
		63	ImmutableList.copyOf(unfinishedMultiplicityObjectives.map[createNew as UnfinishedMultiplicityObjective]),
		64	unfinishedWFObjective.createNew as UnfinishedWFObjective,
		65	scopeWeight, conaintmentWeight, nonContainmentWeight, unfinishedWFWeight
		66	)
56	}	67	}
57		68
58	override getComparator() { Comparators.LOWER_IS_BETTER }	69	override getComparator() { Comparators.LOWER_IS_BETTER }
		70
59	override getFitness(ThreadContext context) {	71	override getFitness(ThreadContext context) {
60	var sum = 0.0	72
61	val scopeFitnes = scopeObjective.getFitness(context)	73	val scopeFitnes = scopeObjective.getFitness(context)
62	//val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x\|x.getFitness(context)]	74	val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)
63		75
64	sum+=scopeFitnes	76	var containmentMultiplicity = 0.0
65	var multiplicity = 0.0	77	var nonContainmentMultiplicity = 0.0
66	for(multiplicityObjective : unfinishedMultiplicityObjectives) {	78	for(multiplicityObjective : unfinishedMultiplicityObjectives) {
67	multiplicity+=multiplicityObjective.getFitness(context)//*0.5	79	val multiplicity = multiplicityObjective.getFitness(context)
		80	// println(multiplicityObjective.name + "=" + multiplicity)
		81	if(multiplicityObjective.containment) {
		82	containmentMultiplicity+=multiplicity
		83	} else {
		84	nonContainmentMultiplicity+=multiplicity
		85	}
		86
68	}	87	}
69	sum+=multiplicity
70		88
71	// the WF can be optional when generating realistic models	89	var sum = 0.0
72	if(!isWFOptional){	90	sum += scopeFitnes*scopeWeight
73	val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)	91	sum += containmentMultiplicity*conaintmentWeight
74	sum += unfinishedWFsFitness//*0.5	92	sum += nonContainmentMultiplicity*nonContainmentWeight
75	}	93	sum += unfinishedWFsFitness*unfinishedWFWeight
76		94
77	//println('''Sum=«sum»\|Scope=«scopeFitnes»\|Multiplicity=«multiplicity»\|WFs=«unfinishedWFsFitness»''')	95	// println('''scope=«scopeFitnes», containment=«containmentMultiplicity», nonContainment=«nonContainmentMultiplicity», wf=«unfinishedWFsFitness», sum=«sum»''')
78		96
79	return sum	97	return sum
80	}	98	}
81		99
82	override getLevel() { 2 }	100	override getWorstPossibleFitness(ThreadContext threadContext) {
83	override getName() { "CompositeUnfinishednessObjective"}	101	Double.POSITIVE_INFINITY
84	def getObjective(){
85	return this.unfinishedMultiplicityObjectives;
86	}	102	}
87		103
		104	override getBestPossibleFitness(ThreadContext threadContext) {
		105	0.0
		106	}
		107
		108	override getLevel() { 2 }
		109
		110	override getName() { "CompositeUnfinishednessObjective" }
		111
88	override isHardObjective() { true }	112	override isHardObjective() { true }
89	override satisifiesHardObjective(Double fitness) { fitness <= 0.001 }	113
90		114	override satisifiesHardObjective(Double fitness) { fitness < 0.01 }
91		115
92	override setComparator(Comparator<Double> comparator) {	116	override setComparator(Comparator<Double> comparator) {
93	throw new UnsupportedOperationException("TODO: auto-generated method stub")	117	throw new UnsupportedOperationException("Model generation objective comparator cannot be set.")
94	}	118	}
		119
95	override setLevel(int level) {	120	override setLevel(int level) {
96	throw new UnsupportedOperationException("TODO: auto-generated method stub")	121	throw new UnsupportedOperationException("Model generation objective level cannot be set.")
97	}	122	}
98		123	}
99	} \ No newline at end of file