1 files changed, 217 insertions, 85 deletions

diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
index 34f3c267..54724226 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
+++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
@@ -4,18 +4,23 @@ import functionalarchitecture.FunctionalarchitecturePackage
 import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore

 import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem

 import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage

+import hu.bme.mit.inf.dslreasoner.domains.satellite.queries.internal.SatelliteQueriesAll

 import hu.bme.mit.inf.dslreasoner.domains.transima.fam.FamPatterns

 import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage

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

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

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

 import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns

 import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint

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

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

 import java.util.Collection

 import java.util.HashMap

 import java.util.LinkedHashMap

 import java.util.List

+import java.util.Map

 import java.util.Set

 import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EClass

@@ -24,60 +29,83 @@ import org.eclipse.emf.ecore.EEnumLiteral
 import org.eclipse.emf.ecore.EObject

 import org.eclipse.emf.ecore.EReference

 import org.eclipse.emf.ecore.EcorePackage

+import org.eclipse.xtend.lib.annotations.Data

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

-import hu.bme.mit.inf.dslreasoner.domains.transima.fam.Type

-import hu.bme.mit.inf.dslreasoner.domains.transima.fam.Model

+import satellite.SatellitePackage

+

+@Data

+class TypeQuantiles {

+        double low

+        double high

+}

 

 abstract class MetamodelLoader {

         protected val ReasonerWorkspace workspace

+

         new(ReasonerWorkspace workspace) {

                 this.workspace = workspace

-        } 

+        }

+

         def EcoreMetamodelDescriptor loadMetamodel()

+

         def Set<EClass> getRelevantTypes(EcoreMetamodelDescriptor descriptor)

+

         def Set<EReference> getRelevantReferences(EcoreMetamodelDescriptor descriptor)

+

         def ViatraQuerySetDescriptor loadQueries(EcoreMetamodelDescriptor metamodel)

+

         def List<EObject> loadPartialModel()

-        

-        def List<Function1<ModelGenerationMethod,ModelGenerationMethodBasedGlobalConstraint>> additionalConstraints()

-        

-        def <T> filterByNames(Iterable<T> collection, Function1<T,String> nameExtractor, Collection<String> requiredNames) {

+

+        def List<Function1<ModelGenerationMethod, ModelGenerationMethodBasedGlobalConstraint>> additionalConstraints()

+

+        def Map<String, TypeQuantiles> getTypeQuantiles() {

+                emptyMap

+        }

+

+        def List<LinearTypeConstraintHint> getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {

+                emptyList

+        }

+

+        def <T> filterByNames(Iterable<T> collection, Function1<T, String> nameExtractor,

+                Collection<String> requiredNames) {

                 val res = collection.filter[requiredNames.contains(nameExtractor.apply(it))]

                 if(res.size != requiredNames.size) throw new IllegalArgumentException

                 return res.toSet

         }

 }

 

-class FAMLoader extends MetamodelLoader{

-        

+class FAMLoader extends MetamodelLoader {

+

         new(ReasonerWorkspace workspace) {

                 super(workspace)

         }

-        

+

         override loadMetamodel() {

                 val package = FunctionalarchitecturePackage.eINSTANCE

                 val List<EClass> classes = package.EClassifiers.filter(EClass).toList

                 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList

                 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList

-                val List<EReference> references = classes.map[EReferences].flatten.toList

+                val List<EReference> references = classes.map[EReferences].flatten.filter[name != "type" && name != "model"].

+                        toList

                 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList

-                return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes)

+                return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)

         }

-        

-        override  getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

-                return descriptor.classes.filterByNames([it.name],#["FunctionalElement"])

+

+        override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

+                return descriptor.classes.filterByNames([it.name], #["FunctionalElement"])

         }

+

         override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {

-                return descriptor.references.filterByNames([it.name],#["subElements"])

+                return descriptor.references.filterByNames([it.name], #["subElements"])

         }

-        

+

         override loadQueries(EcoreMetamodelDescriptor metamodel) {

                 val i = FamPatterns.instance

                 val patterns = i.specifications.toList

-                val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet

+                val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet

                 val derivedFeatures = new LinkedHashMap

-                derivedFeatures.put(Type.instance,metamodel.attributes.filter[it.name == "type"].head)

-                derivedFeatures.put(Model.instance,metamodel.references.filter[it.name == "model"].head)

+//              derivedFeatures.put(Type.instance,metamodel.attributes.filter[it.name == "type"].head)

+//              derivedFeatures.put(Model.instance,metamodel.references.filter[it.name == "model"].head)

                 val res = new ViatraQuerySetDescriptor(

                         patterns,

                         wfPatterns,

@@ -85,65 +113,67 @@ class FAMLoader extends MetamodelLoader{
                 )

                 return res

         }

+

         override loadPartialModel() {

-                this.workspace.readModel(EObject,"FAM.xmi").eResource.allContents.toList

+                this.workspace.readModel(EObject, "FAM.xmi").eResource.allContents.toList

         }

-        

+

         override additionalConstraints() { #[] }

 }

 

-class YakinduLoader extends MetamodelLoader{

-        

+class YakinduLoader extends MetamodelLoader {

+

         var useSynchronization = true;

-        var useComplexStates = false; 

-        public static val patternsWithSynchronization = #[

-                "synchHasNoOutgoing", "synchHasNoIncoming", "SynchronizedIncomingInSameRegion", "notSynchronizingStates",

-                "hasMultipleOutgoingTrainsition", "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings",

-                "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch","noSynch2","synch","noSynch4","noSynch3","noSynch"]

-        public static val patternsWithComplexStates =#["outgoingFromExit","outgoingFromFinal","choiceHasNoOutgoing","choiceHasNoIncoming"]

+        var useComplexStates = false;

+        public static val patternsWithSynchronization = #["synchHasNoOutgoing", "synchHasNoIncoming",

+                "SynchronizedIncomingInSameRegion", "SynchronizedIncomingInSameRegionHelper1",

+                "SynchronizedIncomingInSameRegionHelper2", "notSynchronizingStates", "hasMultipleOutgoingTrainsition",

+                "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings",

+                "SynchronizedRegionsAreNotSiblingsHelper1", "SynchronizedRegionsAreNotSiblingsHelper2",

+                "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch", "noSynch2", "synch", "noSynch4",

+                "noSynch3", "noSynch"]

+        public static val patternsWithComplexStates = #["outgoingFromExit", "outgoingFromFinal", "choiceHasNoOutgoing",

+                "choiceHasNoIncoming"]

+

         new(ReasonerWorkspace workspace) {

                 super(workspace)

                 YakindummPackage.eINSTANCE.eClass

         }

-        

+

         def setUseSynchronization(boolean useSynchronization) {

                 this.useSynchronization = useSynchronization

         }

+

         def setUseComplexStates(boolean useComplexStates) {

                 this.useComplexStates = useComplexStates

         }

-        

+

         override loadMetamodel() {

                 val useSynchInThisLoad = this.useSynchronization

                 val useComplexStates = this.useComplexStates

-                

+

                 val package = YakindummPackage.eINSTANCE

-                val List<EClass> classes = package.EClassifiers.filter(EClass)

-                        .filter[useSynchInThisLoad || (it.name != "Synchronization")]

-                        .filter[useComplexStates   || (it.name != "Choice" && it.name != "Exit" && it.name != "FinalState")]

-                        .toList

+                val List<EClass> classes = package.EClassifiers.filter(EClass).filter [

+                        useSynchInThisLoad || (it.name != "Synchronization")

+                ].filter[useComplexStates || (it.name != "Choice" && it.name != "Exit" && it.name != "FinalState")].toList

                 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList

                 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList

                 val List<EReference> references = classes.map[EReferences].flatten.toList

                 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList

 

-                return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes)

+                return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)

         }

+

         override loadQueries(EcoreMetamodelDescriptor metamodel) {

                 val useSynchInThisLoad = this.useSynchronization

-                

+

                 val i = Patterns.instance

-                val patterns = i.specifications

-                        .filter[spec |

-                                useSynchInThisLoad ||

-                                !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)]

-                        ]

-                        .filter[spec |

-                                useComplexStates ||

-                                !patternsWithComplexStates.exists[spec.fullyQualifiedName.endsWith(it)]

-                        ]

-                        .toList

-                val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet

+                val patterns = i.specifications.filter [ spec |

+                        useSynchInThisLoad || !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)]

+                ].filter [ spec |

+                        useComplexStates || !patternsWithComplexStates.exists[spec.fullyQualifiedName.endsWith(it)]

+                ].toList

+                val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet

                 val derivedFeatures = new LinkedHashMap

                 val res = new ViatraQuerySetDescriptor(

                         patterns,

@@ -152,53 +182,71 @@ class YakinduLoader extends MetamodelLoader{
                 )

                 return res

         }

+

         override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

-                descriptor.classes.filterByNames([it.name],#["Vertex","Transition","Synchronization"])

+                descriptor.classes.filterByNames([it.name], #["Vertex", "Transition", "Synchronization"])

         }

-        

+

         override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {

-                descriptor.references.filterByNames([it.name],#["source","target"])

+                descriptor.references.filterByNames([it.name], #["source", "target"])

         }

-        

+

         override loadPartialModel() {

-                this.workspace.readModel(EObject,"Yakindu.xmi").eResource.allContents.toList

+                this.workspace.readModel(EObject, "Yakindu.xmi").eResource.allContents.toList

         }

-        

-        override additionalConstraints() { //#[]

-                #[[method | new SGraphInconsistencyDetector(method)]]

+

+        override additionalConstraints() { // #[]

+                #[[method|new SGraphInconsistencyDetector(method)]]

+        }

+

+        override getTypeQuantiles() {

+                #{

+                        "Choice" -> new TypeQuantiles(0.118279569892473, 0.154020979020979),

+                        "Entry" -> new TypeQuantiles(0.0283018867924528, 0.0620167525773196),

+                        "Exit" -> new TypeQuantiles(0, 0),

+                        "FinalState" -> new TypeQuantiles(0, 0),

+                        "Region" -> new TypeQuantiles(0.0294117647058824, 0.0633258678611422),

+                        "State" -> new TypeQuantiles(0.132023636740618, 0.175925925925926),

+//                      "Statechart" -> new TypeQuantiles(0.00961538461538462, 0.010752688172043),

+                        "Transition" -> new TypeQuantiles(0.581632653061224, 0.645161290322581)

+                }

+        }

+

+        override getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {

+                #[new SGraphHint(ecore2Logic, trace)]

         }

 }

 

-class FileSystemLoader extends MetamodelLoader{

-        

+class FileSystemLoader extends MetamodelLoader {

+

         new(ReasonerWorkspace workspace) {

                 super(workspace)

         }

-        

+

         override loadMetamodel() {

                 val package = FilesystemPackage.eINSTANCE

                 val List<EClass> classes = package.EClassifiers.filter(EClass).toList

                 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList

                 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList

-                val List<EReference> references = classes.map[EReferences].flatten.toList

+                val List<EReference> references = classes.map[EReferences].flatten.filter[name != "live"].toList

                 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList

-                return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes)

+                return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)

         }

-        

+

         override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

                 return null

         }

-        

+

         override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {

                 null

         }

-        

+

         override loadQueries(EcoreMetamodelDescriptor metamodel) {

                 val patternGroup = FileSystem.instance

                 val patterns = patternGroup.specifications.toList

                 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet

                 val derivedFeatures = new HashMap

-                derivedFeatures.put(patternGroup.live,metamodel.references.filter[it.name == "live"].head)

+//              derivedFeatures.put(patternGroup.live,metamodel.references.filter[it.name == "live"].head)

                 return new ViatraQuerySetDescriptor(

                         patterns,

                         wfPatterns,

@@ -206,41 +254,46 @@ class FileSystemLoader extends MetamodelLoader{
                 )

 

         }

-        

+

         override loadPartialModel() {

-                this.workspace.readModel(EObject,"fs.xmi").eResource.allContents.toList

+                this.workspace.readModel(EObject, "fs.xmi").eResource.allContents.toList

         }

-        

+

         override additionalConstraints() {

-                #[[method | new FileSystemInconsistencyDetector(method)]]

+                #[[method|new FileSystemInconsistencyDetector(method)]]

         }

-        

+

 }

 

 class EcoreLoader extends MetamodelLoader {

-        

+

         new(ReasonerWorkspace workspace) {

                 super(workspace)

         }

-        

+

         override loadMetamodel() {

                 val package = EcorePackage.eINSTANCE

-                val List<EClass> classes = package.EClassifiers.filter(EClass).filter[it.name!="EFactory"].toList

+                val List<EClass> classes = package.EClassifiers.filter(EClass).filter [

+                        it.name != "EFactory" && it.name != "EObject" && it.name != "EResource"

+                ].toList

                 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList

                 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList

-                val List<EReference> references = classes.map[EReferences].flatten.filter[it.name!="eFactoryInstance"].filter[!it.derived].toList

-                val List<EAttribute> attributes = #[] //classes.map[EAttributes].flatten.toList

-                return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes)

+                val List<EReference> references = classes.map[EReferences].flatten.filter [

+                        it.name != "eFactoryInstance" && it.name != "contents" && it.name != "references" &&

+                                it.name != "eGenericType" && it.name != "eGenericSuperTypes"

+                ].filter[!it.derived].toList

+                val List<EAttribute> attributes = #[] // classes.map[EAttributes].flatten.toList

+                return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)

         }

-        

+

         override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

                 return null

         }

-        

+

         override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {

                 null

         }

-        

+

         override loadQueries(EcoreMetamodelDescriptor metamodel) {

                 val patternGroup = Ecore.instance

                 val patterns = patternGroup.specifications.toList

@@ -253,13 +306,92 @@ class EcoreLoader extends MetamodelLoader {
                 )

 

         }

-        

+

         override loadPartialModel() {

-                this.workspace.readModel(EObject,"ecore.xmi").eResource.allContents.toList

+                this.workspace.readModel(EObject, "ecore.xmi").eResource.allContents.toList

         }

-        

+

         override additionalConstraints() {

                 #[]

         }

+

+        override getTypeQuantiles() {

+                #{

+                        "EAnnotation" -> new TypeQuantiles(0, 0),

+                        "EAttribute" -> new TypeQuantiles(0.14, 0.300943396226415),

+                        "EClass" -> new TypeQuantiles(0.224014336917563, 0.372881355932203),

+                        "EDataType" -> new TypeQuantiles(0, 0),

+                        "EEnum" -> new TypeQuantiles(0, 0.0275208638045255),

+                        "EEnumLiteral" -> new TypeQuantiles(0, 0.105204907665065),

+                        "EGenericType" -> new TypeQuantiles(0, 0),

+                        "EOperation" -> new TypeQuantiles(0, 0),

+                        "EPackage" -> new TypeQuantiles(0.0119047619047619, 0.0192307692307692),

+                        "EParameter" -> new TypeQuantiles(0, 0),

+                        "EReference" -> new TypeQuantiles(0.217599234815878, 0.406779661016949),

+                        "EStringToStringMapEntry" -> new TypeQuantiles(0, 0),

+                        "ETypeParameter" -> new TypeQuantiles(0, 0)

+                }

+        }

+

+}

+

+class SatelliteLoader extends MetamodelLoader {

+

+        new(ReasonerWorkspace workspace) {

+                super(workspace)

+        }

+

+        override loadMetamodel() {

+                val package = SatellitePackage.eINSTANCE

+                val List<EClass> classes = package.EClassifiers.filter(EClass).toList

+                val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList

+                val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList

+                val List<EReference> references = classes.map[EReferences].flatten.toList

+                val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList

+                return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)

+        }

+

+        override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {

+                null

+        }

+

+        override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {

+                null

+        }

+

+        override loadQueries(EcoreMetamodelDescriptor metamodel) {

+                val i = SatelliteQueriesAll.instance

+                val patterns = i.specifications.toList

+                val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet

+                val derivedFeatures = new LinkedHashMap

+                val res = new ViatraQuerySetDescriptor(

+                        patterns,

+                        wfPatterns,

+                        derivedFeatures

+                )

+                return res

+        }

+

+        override loadPartialModel() {

+                this.workspace.readModel(EObject, "satellite.xmi").eResource.allContents.toList

+        }

+

+        override additionalConstraints() { #[] }

+        

+        override getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {

+                #[new SatelliteHint(ecore2Logic, trace)]

+        }

+        

+        override getTypeQuantiles() {

+                #{

+                        "CubeSat3U" -> new TypeQuantiles(0.1, 0.25),

+                        "CubeSat6U" -> new TypeQuantiles(0, 0.25),

+                        "SmallSat" -> new TypeQuantiles(0, 0.15),

+                        "UHFCommSubsystem" -> new TypeQuantiles(0.08, 0.25),

+                        "XCommSubsystem" -> new TypeQuantiles(0.08, 0.25),

+                        "KaCommSubsystem" -> new TypeQuantiles(0, 0.1),

+                        "InterferometryPayload" -> new TypeQuantiles(0.15, 0.25)

+                }

+        }

         

-}
\ No newline at end of file
+}