4 files changed, 523 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
new file mode 100644
index 00000000..8fa29fe6
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
@@ -0,0 +1,124 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import java.util.ArrayList
+import java.util.HashSet
+import java.util.List
+import org.eclipse.emf.common.util.EList
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.xtend.lib.annotations.Accessors
+
+class EMFGraph extends Graph{   
+        @Accessors(PUBLIC_GETTER)
+        var EObject root;
+        
+        def void init (EObject root, List<Metric> metrics, String name, List<EReference> referenceTypes){
+                val otherContents = root.eAllContents.toList();
+                this.root = root;
+                otherContents.add(root);
+                init(otherContents, metrics, name, referenceTypes);
+        }
+        
+        /**
+         * init the graph with all nodes and reference types in the meta model
+         * @param objects: objects in the instance model (exclude root)
+         * @param metrics: metrics to be evaluated
+         * @param name: name of the instance model
+         * @param ReferenceTypes: reference types defined in the meta model
+         */
+        def void init(List<EObject> objects, List<Metric> metrics, String name, List<EReference> referenceTypes){
+                objects.forEach[it|
+                        // TODO: Maybe want to consider all the super types as well
+                        var types = new HashSet();
+                        types.add(it.eClass.name);
+                        statistic.addNodeWithAllTypes(it, types);
+                ]
+                
+                referenceTypes.forEach[it|              
+                        // Only consider the edges that are not derived to preserve the statistical property
+                        if(!it.derived){
+                                statistic.addEdgeType(it.name);
+                        }
+                ];
+                
+                objects.forEach[source|
+                        source.eClass.EAllReferences.forEach[r|
+                                //many references
+                                if(r.isMany){
+                                        source.getNeighbours(r).forEach[target|
+                                                addEdge(source, target, r);
+                                        ]
+                                }else{
+                                        //single references
+                                        val target = source.eGet(r) as EObject;
+                                        addEdge(source, target, r);
+                                }
+                        ]
+                ]
+                
+                this.metrics = metrics;
+                this.name = name;
+        }
+        
+        def void removeReference(EReference r){
+                if (statistic.containsEdgeType(r.name)){
+                        statistic.removeReference(r.name, r.containment);
+                }
+        }
+        
+        /**
+         * Set basic information for the output
+         */
+   override setBasicInformation(ArrayList<ArrayList<String>> output){
+                val metaInfo = new ArrayList<String>();
+                metaInfo.add(META_MODEL_HEADER);
+                metaInfo.add(this.metaModel);
+                
+                val edgeInfo = new ArrayList<String>();
+                edgeInfo.add(NUM_EDGE_TYPE_HEADER);
+                edgeInfo.add(this.statistic.allTypes.size()+"");
+                
+                val nodeInfo = new ArrayList<String>();
+                nodeInfo.add(NUM_NODE_HEADER);
+                nodeInfo.add(this.statistic.allNodes.size()+"");
+                
+                val stateInfo = new ArrayList<String>();
+                stateInfo.add(STATE_ID_HEADER);
+                stateInfo.add(this.name);
+                
+                
+                output.add(metaInfo);
+                output.add(edgeInfo);
+                output.add(nodeInfo);
+                output.add(stateInfo);
+        }
+        
+        def EList<EObject> getNeighbours(EObject o, EReference r){
+                return (o.eGet(r, true) as EList<EObject>);
+        }
+        
+        def addEdge(EObject source, EObject target, EReference r){
+                //Only add the edge if the reference is not derived to preserve the statistical property
+                if(target !== null && r !== null && !r.derived){
+                        statistic.addEdge(source, target, r.name);
+                }
+        }
+        
+        override GraphStatistic getStatistic(){
+                return this.statistic;
+        }
+        
+        override String getName(){
+                return this.name;
+        }
+        
+        def void setMetaModel(String model){
+                this.metaModel = model;
+        }
+        
+        def String getMetaModel(){
+                return this.metaModel;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
new file mode 100644
index 00000000..6b400b0d
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
@@ -0,0 +1,71 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
+
+abstract class Graph {
+        
+        protected static val String META_MODEL_HEADER = "Meta Mode"
+        protected static val String NUM_NODE_HEADER = "Number Of Nodes";
+        protected static val String NUM_EDGE_TYPE_HEADER = "Number of Edge types"; 
+        protected static val String STATE_ID_HEADER = "State Id";
+        
+        protected val statistic = new GraphStatistic();
+        protected var List<Metric> metrics;
+        protected var String name = "";
+        protected var String metaModel = "";
+        
+        /**
+         * evaluate all metrics for this model
+         * return the result as a two dimentional list
+         */
+        def ArrayList<ArrayList<String>> evaluateAllMetrics(){
+                val result = new ArrayList<ArrayList<String>>();
+                setBasicInformation(result);
+                
+                for(metric : this.metrics){
+                        val datas = metric.evaluate(this.statistic);
+                        for(row : datas){
+                                result.add(new ArrayList<String>(row));
+                        }
+                }
+                return result;
+        }       
+        
+        def MetricSampleGroup evaluateAllMetricsToSamples(){
+                var sample = new MetricSampleGroup();
+                
+                for(metric : this.metrics){
+                        if(metric instanceof MultiplexParticipationCoefficientMetric){
+                                sample.mpcSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;                                
+                        }else if(metric instanceof NodeActivityMetric){
+                                sample.naSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
+                        }else if(metric instanceof OutDegreeMetric){
+                                sample.outDegreeSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
+                        }else if(metric instanceof TypedOutDegree){
+                                sample.typedOutDegreeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, List<Integer>>;
+                        }else if(metric instanceof NodeTypeMetric){
+                                sample.nodeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
+                        }else if (metric instanceof EdgeTypeMetric){
+                                sample.edgeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
+                        }
+                }
+                
+                return sample;
+        }
+        
+        def void setBasicInformation(ArrayList<ArrayList<String>> result);
+        
+        def GraphStatistic getStatistic();
+        
+        def String getName();
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
new file mode 100644
index 00000000..31788bb2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
@@ -0,0 +1,194 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import com.google.common.collect.ArrayListMultimap
+import com.google.common.collect.Multimap
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+
+class GraphStatistic {
+        val incomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+        val outgoingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+
+        val edgeTypes = new HashSet<String>();
+        val nodeToType = new HashMap<EObject, Set<String>>();   
+
+        /**
+         * Add an edge type to to the graph
+         * @param type: type to add
+         */
+        def void addEdgeType(String type){
+                if(edgeTypes.contains(type)){
+                        return;
+                }
+                
+                edgeTypes.add(type);
+                incomingEdges.put(type, ArrayListMultimap.create());
+                outgoingEdges.put(type, ArrayListMultimap.create());
+        }
+        
+        /**
+         * Add a node to the graph with one type in its type hierarchy
+         * @param node: node to add
+         */
+         def void addNodeWithType(EObject n, String Type){
+                var types = nodeToType.getOrDefault(n, new HashSet<String>());
+                types.add(Type);
+                nodeToType.put(n, types);
+         }
+         
+         def boolean containsNode(EObject o){
+                return nodeToType.containsKey(o);
+         }
+         
+         def Set<String> getTypesForNode(EObject o){
+                return nodeToType.getOrDefault(o, new HashSet<String>());
+         }
+         
+         def void overwriteCurrentType(EObject o, String type){
+                var typeSet = nodeToType.getOrDefault(o, new HashSet<String>());
+                
+                // clear current types
+                typeSet.clear();
+                typeSet.add(type);
+                nodeToType.put(o, typeSet);
+         }
+         
+         /**
+          * Add a node to the graph with all types in its type hierarchy
+          */
+         def void addNodeWithAllTypes(EObject n, Set<String> types){
+                nodeToType.put(n, types);
+         }
+         
+         /**
+          * Add an edge to the graph
+          * @param source: source node
+          * @param target: target node
+          * @param type: type of the reference
+          */
+          def void addEdge(EObject source, EObject target, String type){
+                outgoingEdges.get(type).put(source, target);
+                incomingEdges.get(type).put(target, source);
+          }
+          
+          /**
+           * check if this graph contains a specific edge type
+           */
+           def boolean containsEdgeType(String typeName){
+                 if(outgoingEdges.containsKey(typeName) && incomingEdges.containsKey(typeName)){
+                        return true;
+                 }
+                 return false;
+           }
+           
+           /**
+            * remove references from the statistics, potentially remove the nodes associated with it
+            * @Param name: name of the reference
+            * @Param isContainment: if true then the corresponding nodes on the incoming side will also be removed
+            */
+            def removeReference(String name, boolean isContainment){
+                if(!edgeTypes.contains(name)){
+                        return;
+                }
+                
+                edgeTypes.remove(name);
+                var incomingSet = incomingEdges.remove(name);
+                outgoingEdges.remove(name);
+                
+                // if the reference is not a containment, then removing the reference is enough
+                if(!isContainment){
+                        return;
+                }
+                
+                // else remove all corresponding nodes
+                val nodesToRemove = incomingSet.keySet();
+                
+                //remove nodes from node sets
+                nodesToRemove.forEach[nodeToType.remove(it)];
+                
+                val removeForMultimap = [Multimap<EObject, EObject> refMap| 
+                        nodesToRemove.forEach[refMap.removeAll(it)];
+                        var values = refMap.values()
+                        //remove the values from the list is equavalent to remove it in the multimap
+                        values.removeAll(nodesToRemove); 
+                        return;
+                ];
+                
+                //remove nodes from all other references on incomingEdges
+                incomingEdges.values.forEach(removeForMultimap);
+                outgoingEdges.values.forEach(removeForMultimap);
+            }
+          
+          /**
+           * calculate the out degree for an object
+           */
+          def int outDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += outgoingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the in degree of an object
+           */
+          def int inDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += incomingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the dimentional degree of a node
+           */
+          def int dimentionalDegree(EObject o, String type){
+                return incomingEdges.get(type).get(o).size() + outgoingEdges.get(type).get(o).size();
+          }
+          
+          /**
+           * calculate the number of edge types for a given node.
+           */
+          def int numOfEdgeTypes(EObject o){
+                var count = 0;
+                
+                for(String type : edgeTypes){
+                        if(dimentionalDegree(o, type) > 0){
+                                count++;
+                        }
+                }
+                
+                return count;
+          }
+          
+          def List<String> getAllTypes(){
+                return edgeTypes.toList();
+          }
+          
+          def Map<EObject, Set<String>> getNodeToTypesMap(){
+                return nodeToType;
+          }
+          
+          def List<EObject> getAllNodes(){
+                return nodeToType.keySet().toList();
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> getOutgoingEdges(){
+                return outgoingEdges; 
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> incomingEdges(){
+                return incomingEdges; 
+          }
+          
+}
+
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
new file mode 100644
index 00000000..a2934eb9
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
@@ -0,0 +1,134 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialComplexTypeInterpretationImpl
+import java.util.ArrayList
+import java.util.List
+
+class PartialInterpretationGraph extends Graph{
+        val typeToExclude = "undefinedpart";
+        val classSuffix = " class";
+        
+        /**
+         * Define a new PartialInterpretationGraph by parse every element from a PartialInterpretation
+         */
+        new(PartialInterpretation partial, List<Metric> metrics, String name){          
+                //the edge types are defined in terms of RelationDeclaration
+                partial.problem.relations.filter(RelationDeclaration).forEach[
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        var n = it.name.split(" ").get(0);
+                                this.statistic.addEdgeType(n);
+                ]
+                // add all elements
+                val typeInterpretations = getTypes(partial);
+                for(type : typeInterpretations){
+                        //Only consider the most concrete class
+                        if(isConcreteType(type.interpretationOf)){
+                                var typeName = type.interpretationOf.name.replace(classSuffix, '');
+                                for(node : type.elements){
+                                        if(!this.statistic.containsNode(node)){
+                                                this.statistic.addNodeWithType(node, typeName);
+                                        }else{
+                                                // if the current type of the node is a super type of the type to check, 
+                                                // substitute the current type with the new type
+                                                var currentType = statistic.getTypesForNode(node).get(0);
+                                                if(isSuperType(currentType, type.interpretationOf)){
+                                                        statistic.overwriteCurrentType(node, typeName);
+                                                }
+                                        }
+                                }
+                        }
+                }
+                
+                for(relationInterpretation : partial.partialrelationinterpretation) {
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        val type = relationInterpretation.interpretationOf.name.split(" ").get(0);
+                        for(edge : relationInterpretation.relationlinks.filter(BinaryElementRelationLink)){
+                                statistic.addEdge(edge.param1, edge.param2, type);
+                        }       
+                }       
+                
+                this.name = name;
+                this.metrics = metrics; 
+        }
+        
+        /**
+         * recursively check if a type is the super type of another
+         */
+         def boolean isSuperType(String typeName, Type subtypeToCheck){
+                var superTypes = subtypeToCheck.supertypes;
+                if(superTypes.size == 0){
+                        return false;
+                }else if(subtypeToCheck.supertypes.map[it.name.replace(classSuffix, '')].contains(typeName)){
+                        return true;
+                }else{
+                        for(superType : superTypes){
+                                if(isSuperType(typeName, superType)){
+                                        return true;
+                                }
+                        }
+                        return false;
+                }
+         }
+         
+         /**
+          * Check if a Type object is the class that we want to consider
+          *     A type object is to be considered if it satisfy one of the following:
+          *     1. if it is not abstract
+          *     2. if it is abstract but has a subclass of type TypeDefinition (This means the generation is
+          *        started with nodes in this type) 
+          */
+        def boolean isConcreteType(Type t){
+                if(!t.isAbstract || t.subtypes.findFirst[it instanceof TypeDefinition] !== null){
+                        return true;
+                }
+                return false;
+        }
+        
+        /**
+         * Set basic information for the output
+         */
+        override setBasicInformation(ArrayList<ArrayList<String>> output){
+                val metaInfo = new ArrayList<String>();
+                metaInfo.add(META_MODEL_HEADER);
+                metaInfo.add(this.metaModel);
+                
+                val edgeInfo = new ArrayList<String>();
+                edgeInfo.add(NUM_EDGE_TYPE_HEADER);
+                edgeInfo.add(this.statistic.allTypes.size()+"");
+                
+                val nodeInfo = new ArrayList<String>();
+                nodeInfo.add(NUM_NODE_HEADER);
+                nodeInfo.add(this.statistic.allNodes.size()+"");
+                
+                val stateInfo = new ArrayList<String>();
+                stateInfo.add(STATE_ID_HEADER);
+                stateInfo.add(this.name);
+                
+                output.add(metaInfo);
+                output.add(edgeInfo);
+                output.add(nodeInfo);
+                output.add(stateInfo);
+        }
+        
+        private def getTypes(PartialInterpretation partial){
+                //only the complex type interpretations are the ones defined in meta model
+                //do not care about undefined types as it will be included in the class type
+                return partial.partialtypeinterpratation.filter(PartialComplexTypeInterpretationImpl)
+                                                                                                .filter[!it.interpretationOf.name.toLowerCase.contains(typeToExclude)];
+        }
+        
+        override getStatistic() {
+                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+        }
+        
+        override getName() {
+                return name;
+        }
+        
+}
\ No newline at end of file