Finished Realistic Generator smartgridgenerator

7 files changed, 180 insertions, 35 deletions

diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
index 5bf3fa5a..b2b0474e 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
@@ -9,17 +9,18 @@ Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Export-Package: hu.bme.mit.inf.dlsreasoner.alloy.reasoner,
   hu.bme.mit.inf.dlsreasoner.alloy.reasoner.builder,
-  hu.bme.mit.inf.dlsreasoner.alloy.reasoner.queries
+  hu.bme.mit.inf.dlsreasoner.alloy.reasoner.queries,
+  hu.bme.mit.inf.dlsreasoner.alloy.reasoner.queries.util
 Require-Bundle: com.google.guava,
- org.eclipse.xtend.lib,
- org.eclipse.xtext.xbase.lib,
- org.eclipse.core.runtime,
- org.eclipse.emf.ecore;visibility:=reexport,
- hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0";visibility:=reexport,
- hu.bme.mit.inf.dslreasoner.alloy.language;bundle-version="1.0.0",
- org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.3.0",
- hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
- org.eclipse.viatra.query.runtime;bundle-version="2.0.0"
+  org.eclipse.xtend.lib,
+  org.eclipse.xtext.xbase.lib,
+  org.eclipse.core.runtime,
+  org.eclipse.emf.ecore;visibility:=reexport,
+  hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0";visibility:=reexport,
+  hu.bme.mit.inf.dslreasoner.alloy.language;bundle-version="1.0.0",
+  org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.3.0",
+  hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
+  org.eclipse.viatra.query.runtime;bundle-version="1.7.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
 Import-Package: org.apache.log4j;version="1.2.15"
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
index 07a4e05e..2556b96f 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
@@ -48,8 +48,8 @@ import org.eclipse.emf.ecore.EObject;
  */

 public interface PartialInterpretation extends EObject {

         

-//      int getAverageRepeater();

-//      int getAverageNumberHops();

+        public long getElapsedTime();

+        public void increaseElapsedTime(long nanoTime);

         /**

          * Returns the value of the '<em><b>Problem</b></em>' reference.

          * <!-- begin-user-doc -->

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
index dd744606..3ce2141d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
@@ -67,6 +67,8 @@ import org.eclipse.emf.ecore.util.InternalEList;
  * @generated

  */

 public class PartialInterpretationImpl extends MinimalEObjectImpl.Container implements PartialInterpretation {

+        private static long elapsedTime = 0; 

+        

         /**

          * The cached value of the '{@link #getProblem() <em>Problem</em>}' reference.

          * <!-- begin-user-doc -->

@@ -1040,4 +1042,14 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
                 return result.toString();

         }

 

+        @Override

+        public long getElapsedTime() {          

+                return elapsedTime;

+        }

+

+        @Override

+        public void increaseElapsedTime(long nanoTime) {

+                elapsedTime += nanoTime;

+        }

+

 } //PartialInterpretationImpl

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/ralismcalculator/RealismCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/ralismcalculator/RealismCalculator.xtend
index a9b31cef..5958ddca 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/ralismcalculator/RealismCalculator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/ralismcalculator/RealismCalculator.xtend
@@ -12,6 +12,7 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import java.util.HashMap

 import org.eclipse.emf.common.util.BasicEList

 import java.util.Map

+import java.util.ArrayList

 

 public class RealismCalculator {

                 

@@ -262,16 +263,70 @@ public class RealismCalculator {
                 return maxDegree

         }

 

+        public static def calculateAverageNumberOfHops(PartialInterpretation partialInterpretation){

+                val hops = new ArrayList<Integer>

+                var sum = 0

+                for (element : partialInterpretation.newElements) {

+                        val hop = calculateNumberOfHopsForSmartGridElement(element)

+                        hops.add(hop)

+                }

+                for(hop : hops){

+                        sum += hop.intValue

+                }

+                return (sum as double)/hops.size

+        }

+

         public static def calculateMinimumNumberOfHops(PartialInterpretation partialInterpretation){

+                var minHop = -1         

                 for (element : partialInterpretation.newElements) {
-                        
+                        val hop = calculateNumberOfHopsForSmartGridElement(element)

+                        if(hop < minHop || minHop == -1){

+                                minHop = hop

+                        }

                 }

+                return minHop

         }

         

         public static def calculateMaximumNumberOfHops(PartialInterpretation partialInterpretation){

-

+                var maxHop = 0

+                for (element : partialInterpretation.newElements) {

+                        val hop = calculateNumberOfHopsForSmartGridElement(element)

+                        if(hop > maxHop)

+                                maxHop = hop.intValue

+                }

+                return maxHop

         }

-

+        

+        public static def calculateAverageRepeaterDegree(PartialInterpretation partialInterpretation){

+                var degrees = calculateDegreeOfNodes(partialInterpretation)

+                var numberOfRepeaters = 0

+                var sum = 0

+                var typeIterator = degrees.entrySet.iterator

+                while(typeIterator.hasNext){

+                        var outerpair = typeIterator.next as Map.Entry<PartialTypeInterpratation, HashMap<DefinedElement, Integer>>;

+                        if(outerpair.key.interpretationOf.name.equals("SmartMeter class")){     

+                                var defElementIterator  = outerpair.value.entrySet.iterator                             

+                                while (defElementIterator.hasNext){

+                                        var innerpair = defElementIterator.next

+                                        

+                                        if(elementIsRepeater(innerpair.key, partialInterpretation)){

+                                                numberOfRepeaters++

+                                                sum += (innerpair.value as Integer).intValue    

+                                        }                                                                       

+                                        defElementIterator.remove

+                                }       

+                        }

+                typeIterator.remove 

+                }

+                return (sum as double)/numberOfRepeaters

+        }

+        

+        public static def calculateAverageConcentratorDegree(PartialInterpretation partialInterpretation){

+                // TODO metamodell now only contains 1 concentrator, so the average is going to be it's degree

+                // Implement this function to calculate average for multiple concentrators... 

+                return calculateMaximumDegreeOfConcentrators(partialInterpretation)

+        }

+        

         public static def calculatePercentageOfRepeatersInSmartGrid(PartialInterpretation partialInterpretation){

                 var numberOfElements = getNumberOfElements(partialInterpretation)

                 var numberOfRepeaters = getNumberOfRepeaters(partialInterpretation)

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
index c4bd4515..54a05e63 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
@@ -11,16 +11,53 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation

 import java.util.Set

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.ralismcalculator.RealismCalculator

+import java.io.PrintStream

+import java.io.FileOutputStream

+import java.io.FileDescriptor

 

 class PartialInterpretation2Gml {

         def public transform(PartialInterpretation i) {

-                System.out.println("SumElements: " + RealismCalculator.getNumberOfElements(i))

-                System.out.println("Repeaters: " + RealismCalculator.getNumberOfRepeaters(i))

-                System.out.println("percentage: " +  RealismCalculator.calculatePercentageOfRepeatersInSmartGrid(i))

-                System.out.println("MinRepeaterDegree: " + RealismCalculator.calculateMinimumDegreeOfRepeaters(i));

-                System.out.println("MaxRepeaterDegree: " + RealismCalculator.calculateMaximumDegreeOfRepeaters(i));

-                System.out.println("MinConcentratorDegree: " + RealismCalculator.calculateMinimumDegreeOfConcentrators(i));

-                System.out.println("MaxConcentratorDegree: " + RealismCalculator.calculateMaximumDegreeOfConcentrators(i));

+                var postGenCalculationStartTime = System.nanoTime();

+//              System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)))

+//              System.out.print("_____________")

+                var numberOfElements = RealismCalculator.getNumberOfElements(i)

+                var numberOfRepeaters = RealismCalculator.getNumberOfRepeaters(i)

+                var percentageOfRepeaters = RealismCalculator.calculatePercentageOfRepeatersInSmartGrid(i)

+                System.out.print("SumElements;" + numberOfElements + ";")

+                System.out.print("Repeaters;" + numberOfRepeaters + ";")

+                System.out.print("RepPercentage;" + percentageOfRepeaters + ";")

+//              System.out.print("_____________")

+                var minimumRepeaterDegree = RealismCalculator.calculateMinimumDegreeOfRepeaters(i)

+                var maximumRepeaterDegree = RealismCalculator.calculateMaximumDegreeOfRepeaters(i)

+                var averageRepeaterDegree = RealismCalculator.calculateAverageRepeaterDegree(i)

+                System.out.print("MinRepeaterDegree;" + minimumRepeaterDegree + ";");

+                System.out.print("MaxRepeaterDegree;" + maximumRepeaterDegree + ";");

+                System.out.print("AvgRepeaterDegree;" + averageRepeaterDegree + ";");           

+//              System.out.print("_____________")

+                var minimumConcentratorDegree = RealismCalculator.calculateMinimumDegreeOfConcentrators(i)

+                var maximumConcentratorDegree = RealismCalculator.calculateMaximumDegreeOfConcentrators(i)

+                var avgConcentratorDegree = RealismCalculator.calculateAverageConcentratorDegree(i)

+                System.out.print("MinConcentratorDegree;" + minimumConcentratorDegree + ";");

+                System.out.print("MaxConcentratorDegree;" + maximumConcentratorDegree + ";");

+                System.out.print("AvgConcentratorDegree;" + avgConcentratorDegree + ";");

+//              System.out.print("_____________")

+                var maxHops = RealismCalculator.calculateMaximumNumberOfHops(i)

+                var minHops= RealismCalculator.calculateMinimumNumberOfHops(i)

+                var avgHops= RealismCalculator.calculateAverageNumberOfHops(i)

+                System.out.print("MaxHops;" + maxHops + ";");

+                System.out.print("MinHops;" + minHops + ";");

+                System.out.print("AvgHops;" + avgHops + ";");

+//              System.out.print("_____________")

+                var postGenElapsedTime = (System.nanoTime()-postGenCalculationStartTime)                

+                System.out.print("Post Generation Realism Calculation Time;" + postGenElapsedTime + ";")

+                System.out.print("Post Generation Realism Calculation Time In Seconds;" + postGenElapsedTime *0.000000001 + ";")

+                var generationCalculationTime = i.elapsedTime

+                System.out.print("Realism Calculation Time During Generation;" + generationCalculationTime + ";")

+                System.out.print("Realism Calculation Time During Generation In Seconds;" + generationCalculationTime *0.000000001 + ";")

+                var totalCalculationTime = postGenElapsedTime + generationCalculationTime

+                System.out.print("Total Realism Calculation Time;" + totalCalculationTime + ";")

+                System.out.print("Total Realism Calculation Time In Seconds;" + totalCalculationTime*0.000000001 + ";")

+//              System.out.print("_____________")

                 val p = i.problem

                 val Map<DefinedElement, Integer> objectToID = new HashMap

                 val containmentRelations = p.containmentHierarchies.map[it.containmentRelations].flatten.toSet

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 8e56a8d9..c58e221d 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
@@ -6,6 +6,7 @@ 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.PartialInterpretation

 

 //class ViatraReasonerNumbers {

 //      public static val scopePriority = 2

@@ -57,11 +58,14 @@ class ModelGenerationCompositeObjective implements IObjective{
         override getFitness(ThreadContext context) {

                 var sum = 0.0

                 val scopeFitnes = scopeObjective.getFitness(context)

-                //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]

+                val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]

                 val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)

+                var startTime = System.nanoTime();

                 val realistic =  smartgridObjective.getFitness(context)

-                sum += realistic*4

-                sum+=scopeFitnes

+                var elapsedTime = System.nanoTime() - startTime;

+                (context.model as PartialInterpretation).increaseElapsedTime(elapsedTime);

+                sum += realistic*5 //real2 -> *5, real1 -> *4

+                sum += scopeFitnes

                 var multiplicity = 0.0

                 for(multiplicityObjective : unfinishedMultiplicityObjectives) {

                         multiplicity+=multiplicityObjective.getFitness(context)//*0.5

@@ -78,7 +82,7 @@ class ModelGenerationCompositeObjective implements IObjective{
         override getName() { "CompositeUnfinishednessObjective"}

         

         override isHardObjective() { true }

-        override satisifiesHardObjective(Double fitness) { fitness <= 10 }

+        override satisifiesHardObjective(Double fitness) { fitness <= 10 } //TODO tweak

         

         

         override setComparator(Comparator<Double> comparator) {

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SmartGridScopeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SmartGridScopeObjective.xtend
index 36706033..36099735 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SmartGridScopeObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SmartGridScopeObjective.xtend
@@ -7,19 +7,55 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.ral
 import java.util.Comparator

 import org.eclipse.viatra.dse.objectives.Comparators

 

+

 class SmartGridScopeObjective implements IObjective {

+            private enum setting {

+           original, real1, real2, real3

+        }    

+    val settings = setting.real2

+        public static final double desiredAvgDegreeOfRepeaters = 3.75 

+        public static final double desiredAvgDegreeOfConcentrators = 21.3       

+        public static final double desiredAvgNumberOfHops = 2.6 

         public static final double desiredPercentageOfRepeaters = 30.2  

-        public static final double maxDeviation = 5

-        //static double percentageOfRepeaters = 30.2

-        

+        public static final double maxDeviation = 5    

+

         override getFitness(ThreadContext context) {

                 val interpretation = context.model as PartialInterpretation

-                val r = RealismCalculator.calculatePercentageOfRepeatersInSmartGrid(interpretation)

-                var deviation = desiredPercentageOfRepeaters - r

-                deviation = Math.abs(deviation)

-//              System.out.println(deviation)

-                return deviation.doubleValue

-//return 1.0

+                

+                val repPerc = RealismCalculator.calculatePercentageOfRepeatersInSmartGrid(interpretation)                               

+                var repeaterPercentageDeviation = desiredPercentageOfRepeaters - repPerc

+                repeaterPercentageDeviation = Math.abs(repeaterPercentageDeviation)

+                

+                val repDegree = RealismCalculator.calculateAverageRepeaterDegree(interpretation)        

+                var repeaterDegreeDeviation = desiredAvgDegreeOfRepeaters - repDegree

+                repeaterDegreeDeviation = Math.abs(repeaterDegreeDeviation)

+                

+                val concDegree = RealismCalculator.calculateAverageConcentratorDegree(interpretation)   

+                var concentratorDegreeDeviation = desiredAvgDegreeOfConcentrators - concDegree

+                concentratorDegreeDeviation = Math.abs(concentratorDegreeDeviation)

+                

+                val avgHop = RealismCalculator.calculateAverageNumberOfHops(interpretation)     

+                var avgHopDeviation = desiredAvgNumberOfHops - avgHop

+                avgHopDeviation = Math.abs(avgHopDeviation)             

+                //println("____repDev: " + repeaterDegreeDeviation + " concDev: " + concentratorDegreeDeviation + " repPerc: " + repeaterPercentageDeviation + " avgHops: " + avgHopDeviation)

+                

+                switch (settings) {                     

+                        case original: {

+                                return 0.0; //No Reality fitness

+                        }
+                        case real1: { // Only add deviation of the percentage of repeaters to reality fitness                                                           

+                                return repeaterPercentageDeviation.doubleValue
+                        }

+                        case real2: { // Add all with same weight

+                                return (repeaterPercentageDeviation.doubleValue + repeaterDegreeDeviation + concentratorDegreeDeviation + avgHopDeviation)/4;

+                        }

+                        case real3: {

+                                return 0.0;

+                        }
+                        default: {
+                                return 0.0;
+                        }
+                }       

         }

         

         override isHardObjective() { true }