From 1cfc2e98ffbba1dc2a489ad415c81264b76d8c14 Mon Sep 17 00:00:00 2001 From: 20001LastOrder Date: Sun, 15 Nov 2020 21:56:45 -0500 Subject: code for paper --- .../SocialNetwork_plugin/Measurement_Runner.launch | 2 +- .../SocialNetwork_plugin/debug/errors.txt | 13 +- .../debug/generated3valued.vql_deactivated | 2004 ++++++++++++++++++++ .../debug/generation.logicproblem | 1114 +++++++++++ .../SocialNetwork_plugin/debug/init.partialmodel | 98 + .../SocialNetwork_plugin/debug/problem.als | 151 ++ .../SocialNetwork_plugin/ecore.vsconfig | 14 +- .../SocialNetwork_plugin/github.vsconfig | 12 +- .../ca/mcgill/ecse/socialnetwork/runner/Main.java | 7 +- .../statistics/Ecore/warmup.csv | 2 +- .../statistics/Github/warmup.csv | 107 +- .../statistics/Yakindu/warmup.csv | 11 +- .../statistics/base/Github/statistics.csv | 12 + .../statistics/runtime/Github/statistics.csv | 102 + .../statistics/runtime/Github/statistics_real.csv | 12 + .../yakinduGeneration.vsconfig | 8 +- 16 files changed, 3620 insertions(+), 49 deletions(-) create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generated3valued.vql_deactivated create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generation.logicproblem create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/init.partialmodel create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/problem.als create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/base/Github/statistics.csv create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics.csv create mode 100644 Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics_real.csv (limited to 'Metrics/Metrics-Calculation/SocialNetwork_plugin') diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/Measurement_Runner.launch b/Metrics/Metrics-Calculation/SocialNetwork_plugin/Measurement_Runner.launch index 9162f976..ae41d2c3 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/Measurement_Runner.launch +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/Measurement_Runner.launch @@ -11,7 +11,7 @@ - + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/errors.txt b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/errors.txt index 44724f1a..0654287f 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/errors.txt +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/errors.txt @@ -1,14 +1,11 @@ -Error occured (DiagnosticWrappedException): org.eclipse.emf.ecore.xmi.FeatureNotFoundException: Feature 'vertices' not found. (file:///C:/Users/chenp/Documents/Eclipse/VIATRA-Generator/Metrics/Metrics-Calculation/SocialNetwork_plugin/inputs/start.xmi, 3, 57) - org.eclipse.emf.ecore.resource.impl.ResourceSetImpl.handleDemandLoadException(ResourceSetImpl.java:319) - org.eclipse.emf.ecore.resource.impl.ResourceSetImpl.demandLoadHelper(ResourceSetImpl.java:278) - org.eclipse.xtext.resource.XtextResourceSet.getResource(XtextResourceSet.java:266) - org.eclipse.xtext.resource.SynchronizedXtextResourceSet.getResource(SynchronizedXtextResourceSet.java:25) - hu.bme.mit.inf.dslreasoner.application.execution.ModelLoader.loadModel(ModelLoader.java:41) - hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:171) +Error occured (AlloySolverException): Parser Exception + hu.bme.mit.inf.dlsreasoner.alloy.reasoner.builder.AlloyHandler.callSolver(AlloyHandler.java:98) + hu.bme.mit.inf.dlsreasoner.alloy.reasoner.AlloySolver.solve(AlloySolver.java:67) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:329) hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor._execute(ScriptExecutor.java:141) hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.execute(ScriptExecutor.java:382) hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.executeScript(ScriptExecutor.java:122) hu.bme.mit.inf.dslreasoner.application.execution.StandaloneScriptExecutor.executeScript(StandaloneScriptExecutor.java:155) hu.bme.mit.inf.dslreasoner.application.execution.StandaloneScriptExecutor.executeScript(StandaloneScriptExecutor.java:147) ca.mcgill.ecse.socialnetwork.runner.Main.runWithPath(Main.java:24) - ca.mcgill.ecse.socialnetwork.runner.Main.main(Main.java:40) + ca.mcgill.ecse.socialnetwork.runner.Main.main(Main.java:36) diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generated3valued.vql_deactivated b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generated3valued.vql_deactivated new file mode 100644 index 00000000..d553f3cf --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generated3valued.vql_deactivated @@ -0,0 +1,2004 @@ +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +/** [[exist(element)]]=1 */ +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +/** [[exist(element)]]>=1/2 */ +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) +// For non-primitive type. Boolean types always must equivalent or cannot equivalent +{ + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +pattern mustEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { +// For non-primitive and Boolean primitive type + find mustExist(problem,interpretation,a); + find mustExist(problem,interpretation,b); + a == b; +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 Required Patterns by TypeIndexer +////////// + +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1.1.2 primitive Type Indexers +////////// +// Currently unused. Refer primitive types as: +// > PrimitiveElement(element) +// specific types are referred as: +// > BooleanElement(variableName) +// > IntegerElement(variableName) +// > RealElement(variableName) +// > StringElement(variableName) +// And their value as +// > BooleanElement.value(variableName,value) +// > IntegerElement.value(variableName,value) +// > RealElement.value(variableName,value) +// > StringElement.value(variableName,value) +// Whether a value is set is defined by: +// > PrimitiveElement.valueSet(variableName,isFilled); + +////////// +// 1.1.3 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "User class". + */ +private pattern mustInstanceOfUser_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"User class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewUser_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"User class"); +} + +/** + * An element may be an instance of type "User class". + */ +private pattern mayInstanceOfUser_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find scopeDisallowsNewUser_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find scopeDisallowsNewUser_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfUser_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Project class". + */ +private pattern mustInstanceOfProject_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Project class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewProject_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Project class"); +} + +/** + * An element may be an instance of type "Project class". + */ +private pattern mayInstanceOfProject_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewProject_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewProject_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfProject_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Commit class". + */ +private pattern mustInstanceOfCommit_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Commit class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewCommit_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Commit class"); +} + +/** + * An element may be an instance of type "Commit class". + */ +private pattern mayInstanceOfCommit_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find scopeDisallowsNewCommit_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find scopeDisallowsNewCommit_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfCommit_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Issue class". + */ +private pattern mustInstanceOfIssue_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Issue class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewIssue_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Issue class"); +} + +/** + * An element may be an instance of type "Issue class". + */ +private pattern mayInstanceOfIssue_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewIssue_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewIssue_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfIssue_class(problem,interpretation,element); } +/** + * An element must be an instance of type "PullRequest class". + */ +private pattern mustInstanceOfPullRequest_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"PullRequest class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewPullRequest_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"PullRequest class"); +} + +/** + * An element may be an instance of type "PullRequest class". + */ +private pattern mayInstanceOfPullRequest_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewPullRequest_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewPullRequest_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfPullRequest_class(problem,interpretation,element); } +/** + * An element must be an instance of type "IssueEvent class". + */ +private pattern mustInstanceOfIssueEvent_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"IssueEvent class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewIssueEvent_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"IssueEvent class"); +} + +/** + * An element may be an instance of type "IssueEvent class". + */ +private pattern mayInstanceOfIssueEvent_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewIssueEvent_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewIssueEvent_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfIssueEvent_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Action enum". + */ +private pattern mustInstanceOfAction_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Action enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewAction_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Action enum"); +} + +/** + * An element may be an instance of type "Action enum". + */ +private pattern mayInstanceOfAction_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfAction_enum(problem,interpretation,element); } +/** + * An element must be an instance of type "Project class DefinedPart". + */ +private pattern mustInstanceOfProject_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Project class DefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewProject_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Project class DefinedPart"); +} + +/** + * An element may be an instance of type "Project class DefinedPart". + */ +private pattern mayInstanceOfProject_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfProject_class_DefinedPart(problem,interpretation,element); } +/** + * An element must be an instance of type "Project class UndefinedPart". + */ +private pattern mustInstanceOfProject_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Project class UndefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewProject_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Project class UndefinedPart"); +} + +/** + * An element may be an instance of type "Project class UndefinedPart". + */ +private pattern mayInstanceOfProject_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewProject_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find scopeDisallowsNewProject_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfProject_class_UndefinedPart(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []issue reference Project(source,target) + */ +private pattern mustInRelationissue_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"issue reference Project"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>issue reference Project(source,target) + */ +private pattern mayInRelationissue_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfProject_class(problem,interpretation,source); + find mayInstanceOfIssue_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationissue_reference_Project(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []projectMembers reference Project(source,target) + */ +private pattern mustInRelationprojectMembers_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"projectMembers reference Project"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>projectMembers reference Project(source,target) + */ +private pattern mayInRelationprojectMembers_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfProject_class(problem,interpretation,source); + find mayInstanceOfUser_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationprojectMembers_reference_Project(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []commits reference Project(source,target) + */ +private pattern mustInRelationcommits_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"commits reference Project"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>commits reference Project(source,target) + */ +private pattern mayInRelationcommits_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfProject_class(problem,interpretation,source); + find mayInstanceOfCommit_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationcommits_reference_Project(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []committer reference Commit(source,target) + */ +private pattern mustInRelationcommitter_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"committer reference Commit"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>committer reference Commit(source,target) + */ +private pattern mayInRelationcommitter_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfCommit_class(problem,interpretation,source); + find mayInstanceOfUser_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationcommitter_reference_Commit(problem,interpretation,source,_); + numberOfExistingReferences != 1; +} or { + find mustInRelationcommitter_reference_Commit(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parents reference Commit(source,target) + */ +private pattern mustInRelationparents_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parents reference Commit"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parents reference Commit(source,target) + */ +private pattern mayInRelationparents_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfCommit_class(problem,interpretation,source); + find mayInstanceOfCommit_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparents_reference_Commit(problem,interpretation,source,_); + numberOfExistingReferences != 2; +} or { + find mustInRelationparents_reference_Commit(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []pullrequest reference Commit(source,target) + */ +private pattern mustInRelationpullrequest_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"pullrequest reference Commit"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>pullrequest reference Commit(source,target) + */ +private pattern mayInRelationpullrequest_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfCommit_class(problem,interpretation,source); + find mayInstanceOfPullRequest_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationpullrequest_reference_Commit(problem,interpretation,source,_); + numberOfExistingReferences != 1; + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationcommit_reference_PullRequest(problem,interpretation,target,_); + numberOfExistingOppositeReferences != 1; +} or { + find mustInRelationpullrequest_reference_Commit(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []pullrequest reference Issue(source,target) + */ +private pattern mustInRelationpullrequest_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"pullrequest reference Issue"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>pullrequest reference Issue(source,target) + */ +private pattern mayInRelationpullrequest_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfIssue_class(problem,interpretation,source); + find mayInstanceOfPullRequest_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationpullrequest_reference_Issue(problem,interpretation,source,_); + numberOfExistingReferences != 1; + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationpullrequest_reference_Issue(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []issueevent reference Issue(source,target) + */ +private pattern mustInRelationissueevent_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"issueevent reference Issue"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>issueevent reference Issue(source,target) + */ +private pattern mayInRelationissueevent_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfIssue_class(problem,interpretation,source); + find mayInstanceOfIssueEvent_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationissueevent_reference_Issue(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []commit reference PullRequest(source,target) + */ +private pattern mustInRelationcommit_reference_PullRequest( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"commit reference PullRequest"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>commit reference PullRequest(source,target) + */ +private pattern mayInRelationcommit_reference_PullRequest( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfPullRequest_class(problem,interpretation,source); + find mayInstanceOfCommit_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationcommit_reference_PullRequest(problem,interpretation,source,_); + numberOfExistingReferences != 1; + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationpullrequest_reference_Commit(problem,interpretation,target,_); + numberOfExistingOppositeReferences != 1; +} or { + find mustInRelationcommit_reference_PullRequest(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []user reference IssueEvent(source,target) + */ +private pattern mustInRelationuser_reference_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"user reference IssueEvent"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>user reference IssueEvent(source,target) + */ +private pattern mayInRelationuser_reference_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfIssueEvent_class(problem,interpretation,source); + find mayInstanceOfUser_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationuser_reference_IssueEvent(problem,interpretation,source,_); + numberOfExistingReferences != 1; +} or { + find mustInRelationuser_reference_IssueEvent(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []action attribute IssueEvent(source,target) + */ +private pattern mustInRelationaction_attribute_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"action attribute IssueEvent"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>action attribute IssueEvent(source,target) + */ +private pattern mayInRelationaction_attribute_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfIssueEvent_class(problem,interpretation,source); + find mayInstanceOfAction_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationaction_attribute_IssueEvent(problem,interpretation,source,_); + numberOfExistingReferences != 1; +} or { + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// +// Must, May and Current queries for pattern queries directParent +private pattern mustInRelation_pattern_queries_directParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a, var_b) +{ + find interpretation(problem,interpretation); + // var_a exported + // var_b exported + find mustInRelationparents_reference_Commit(problem,interpretation,var_a,var_b); + find mustInstanceOfCommit_class(problem,interpretation,var_b); +} +private pattern mayInRelation_pattern_queries_directParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a, var_b) +{ + find interpretation(problem,interpretation); + // var_a exported + // var_b exported + find mayInRelationparents_reference_Commit(problem,interpretation,var_a,var_b); + find mayInstanceOfCommit_class(problem,interpretation,var_b); +} +private pattern currentInRelation_pattern_queries_directParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a, var_b) +{ + find interpretation(problem,interpretation); + // var_a exported + // var_b exported + find mustInRelationparents_reference_Commit(problem,interpretation,var_a,var_b); + find mustInstanceOfCommit_class(problem,interpretation,var_b); +} +private pattern twoParam_mustInRelation_pattern_queries_directParent(var_a, var_b) { + find mustInRelation_pattern_queries_directParent(_,_,var_a, var_b); +} +private pattern twoParam_mayInRelation_pattern_queries_directParent(var_a, var_b) { + find mayInRelation_pattern_queries_directParent(_,_,var_a, var_b); +} +private pattern twoParam_currentInRelation_pattern_queries_directParent(var_a, var_b) { + find currentInRelation_pattern_queries_directParent(_,_,var_a, var_b); +} +// Must, May and Current queries for pattern queries loopInParent +private pattern mustInRelation_pattern_queries_loopInParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a) +{ + find interpretation(problem,interpretation); + // var_a exported + find twoParam_mustInRelation_pattern_queries_directParent+(var_a,var_a); +} +private pattern mayInRelation_pattern_queries_loopInParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a) +{ + find interpretation(problem,interpretation); + // var_a exported + find twoParam_mayInRelation_pattern_queries_directParent+(var_a,var_a); +} +private pattern currentInRelation_pattern_queries_loopInParent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_a) +{ + find interpretation(problem,interpretation); + // var_a exported + find twoParam_currentInRelation_pattern_queries_directParent+(var_a,var_a); +} +// Must, May and Current queries for pattern queries checkAction +private pattern mustInRelation_pattern_queries_checkAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + // var_t exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +private pattern mayInRelation_pattern_queries_checkAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + // var_t exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +private pattern currentInRelation_pattern_queries_checkAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + // var_t exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +// Must, May and Current queries for pattern queries checkUserAction +private pattern mustInRelation_pattern_queries_checkUserAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + // var_t exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +private pattern mayInRelation_pattern_queries_checkUserAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + // var_t exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mayInstanceOfUser_class(problem,interpretation,var_u); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +private pattern currentInRelation_pattern_queries_checkUserAction( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e, var_t) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + // var_t exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_t); +} +// Must, May and Current queries for pattern queries isReopen +private pattern mustInRelation_pattern_queries_isReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); +} +private pattern mayInRelation_pattern_queries_isReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); +} +private pattern currentInRelation_pattern_queries_isReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); +} +// Must, May and Current queries for pattern queries isClose +private pattern mustInRelation_pattern_queries_isClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); +} +private pattern mayInRelation_pattern_queries_isClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); +} +private pattern currentInRelation_pattern_queries_isClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); +} +// Must, May and Current queries for pattern queries isUnSubscribe +private pattern mustInRelation_pattern_queries_isUnSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); +} +private pattern mayInRelation_pattern_queries_isUnSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mayInstanceOfUser_class(problem,interpretation,var_u); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); +} +private pattern currentInRelation_pattern_queries_isUnSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); +} +// Must, May and Current queries for pattern queries isSubscribe +private pattern mustInRelation_pattern_queries_isSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); +} +private pattern mayInRelation_pattern_queries_isSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mayInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mayInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mayInstanceOfUser_class(problem,interpretation,var_u); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); +} +private pattern currentInRelation_pattern_queries_isSubscribe( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u, var_e) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + // var_e exported + find mustInRelationissueevent_reference_Issue(problem,interpretation,var_i,var_e); + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); + find mustInRelationaction_attribute_IssueEvent(problem,interpretation,var_e,var_a); + var_a == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); +} +// Must, May and Current queries for pattern queries pullRequestOfIssue +private pattern mustInRelation_pattern_queries_pullRequestOfIssue( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_pr) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_pr exported + find mustInRelationpullrequest_reference_Issue(problem,interpretation,var_i,var_pr); + find mustInstanceOfPullRequest_class(problem,interpretation,var_pr); +} +private pattern mayInRelation_pattern_queries_pullRequestOfIssue( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_pr) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_pr exported + find mayInRelationpullrequest_reference_Issue(problem,interpretation,var_i,var_pr); + find mayInstanceOfPullRequest_class(problem,interpretation,var_pr); +} +private pattern currentInRelation_pattern_queries_pullRequestOfIssue( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_pr) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_pr exported + find mustInRelationpullrequest_reference_Issue(problem,interpretation,var_i,var_pr); + find mustInstanceOfPullRequest_class(problem,interpretation,var_pr); +} +// Must, May and Current queries for pattern queries mergedIssueWithoutPr +private pattern mustInRelation_pattern_queries_mergedIssueWithoutPr( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_MERGED_Action;DefinedElement.name(const_MERGED_Action,"MERGED Action"); //LogicProblem.elements(problem,const_MERGED_Action); + find mustInRelation_pattern_queries_checkAction(problem,interpretation,var_i,_var__0,var_virtual0); + neg find mayInRelation_pattern_queries_pullRequestOfIssue(problem,interpretation,var_i,_var__1); +} +private pattern mayInRelation_pattern_queries_mergedIssueWithoutPr( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_MERGED_Action;DefinedElement.name(const_MERGED_Action,"MERGED Action"); //LogicProblem.elements(problem,const_MERGED_Action); + find mayInRelation_pattern_queries_checkAction(problem,interpretation,var_i,_var__0,var_virtual0); + neg find mustInRelation_pattern_queries_pullRequestOfIssue(problem,interpretation,var_i,_var__1); +} +private pattern currentInRelation_pattern_queries_mergedIssueWithoutPr( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_MERGED_Action;DefinedElement.name(const_MERGED_Action,"MERGED Action"); //LogicProblem.elements(problem,const_MERGED_Action); + find currentInRelation_pattern_queries_checkAction(problem,interpretation,var_i,_var__0,var_virtual0); + neg find currentInRelation_pattern_queries_pullRequestOfIssue(problem,interpretation,var_i,_var__1); +} +// Must, May and Current queries for pattern queries consecutiveClosesWithoutReopen +private pattern mustInRelation_pattern_queries_consecutiveClosesWithoutReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find mustInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find mustInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mayEquivalent(problem, interpretation, var_a1, var_a2); + neg find mayInRelation_pattern_queries_isReopen(problem,interpretation,var_i,_var__0); +} +private pattern mayInRelation_pattern_queries_consecutiveClosesWithoutReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find mayInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find mayInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find mustInRelation_pattern_queries_isReopen(problem,interpretation,var_i,_var__0); +} +private pattern currentInRelation_pattern_queries_consecutiveClosesWithoutReopen( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find currentInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_CLOSED_Action;DefinedElement.name(const_CLOSED_Action,"CLOSED Action"); //LogicProblem.elements(problem,const_CLOSED_Action); + find currentInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find currentInRelation_pattern_queries_isReopen(problem,interpretation,var_i,_var__0); +} +// Must, May and Current queries for pattern queries consecutiveReopensWithoutClose +private pattern mustInRelation_pattern_queries_consecutiveReopensWithoutClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find mustInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find mustInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mayEquivalent(problem, interpretation, var_a1, var_a2); + neg find mayInRelation_pattern_queries_isClose(problem,interpretation,var_i,_var__0); +} +private pattern mayInRelation_pattern_queries_consecutiveReopensWithoutClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find mayInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find mayInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find mustInRelation_pattern_queries_isClose(problem,interpretation,var_i,_var__0); +} +private pattern currentInRelation_pattern_queries_consecutiveReopensWithoutClose( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find interpretation(problem,interpretation); + // var_i exported + var_virtual0 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find currentInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a1,var_virtual0); + var_virtual1 == const_REOPENED_Action;DefinedElement.name(const_REOPENED_Action,"REOPENED Action"); //LogicProblem.elements(problem,const_REOPENED_Action); + find currentInRelation_pattern_queries_checkAction(problem,interpretation,var_i,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find currentInRelation_pattern_queries_isClose(problem,interpretation,var_i,_var__0); +} +// Must, May and Current queries for pattern queries consecutiveSubWithoutUnSub +private pattern mustInRelation_pattern_queries_consecutiveSubWithoutUnSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find mustInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find mustInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mayEquivalent(problem, interpretation, var_a1, var_a2); + neg find mayInRelation_pattern_queries_isUnSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +private pattern mayInRelation_pattern_queries_consecutiveSubWithoutUnSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find mayInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find mayInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find mustInRelation_pattern_queries_isUnSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +private pattern currentInRelation_pattern_queries_consecutiveSubWithoutUnSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find currentInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_SUBSCRIBED_Action;DefinedElement.name(const_SUBSCRIBED_Action,"SUBSCRIBED Action"); //LogicProblem.elements(problem,const_SUBSCRIBED_Action); + find currentInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find currentInRelation_pattern_queries_isUnSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +// Must, May and Current queries for pattern queries consecutiveUnSubWithoutSub +private pattern mustInRelation_pattern_queries_consecutiveUnSubWithoutSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find mustInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find mustInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mayEquivalent(problem, interpretation, var_a1, var_a2); + neg find mayInRelation_pattern_queries_isSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +private pattern mayInRelation_pattern_queries_consecutiveUnSubWithoutSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find mayInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find mayInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find mustInRelation_pattern_queries_isSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +private pattern currentInRelation_pattern_queries_consecutiveUnSubWithoutSub( + problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find interpretation(problem,interpretation); + // var_i exported + // var_u exported + var_virtual0 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find currentInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a1,var_virtual0); + var_virtual1 == const_UNSUBSCRIBED_Action;DefinedElement.name(const_UNSUBSCRIBED_Action,"UNSUBSCRIBED Action"); //LogicProblem.elements(problem,const_UNSUBSCRIBED_Action); + find currentInRelation_pattern_queries_checkUserAction(problem,interpretation,var_i,var_u,var_a2,var_virtual1); + neg find mustEquivalent(problem, interpretation, var_a1, var_a2); + neg find currentInRelation_pattern_queries_isSubscribe(problem,interpretation,var_i,var_u,_var__0); +} +// Must, May and Current queries for pattern queries committer +private pattern mustInRelation_pattern_queries_committer( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c, var_u) +{ + find interpretation(problem,interpretation); + // var_c exported + // var_u exported + find mustInRelationcommitter_reference_Commit(problem,interpretation,var_c,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); +} +private pattern mayInRelation_pattern_queries_committer( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c, var_u) +{ + find interpretation(problem,interpretation); + // var_c exported + // var_u exported + find mayInRelationcommitter_reference_Commit(problem,interpretation,var_c,var_u); + find mayInstanceOfUser_class(problem,interpretation,var_u); +} +private pattern currentInRelation_pattern_queries_committer( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c, var_u) +{ + find interpretation(problem,interpretation); + // var_c exported + // var_u exported + find mustInRelationcommitter_reference_Commit(problem,interpretation,var_c,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); +} +// Must, May and Current queries for pattern queries eventUser +private pattern mustInRelation_pattern_queries_eventUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e, var_u) +{ + find interpretation(problem,interpretation); + // var_e exported + // var_u exported + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); +} +private pattern mayInRelation_pattern_queries_eventUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e, var_u) +{ + find interpretation(problem,interpretation); + // var_e exported + // var_u exported + find mayInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mayInstanceOfUser_class(problem,interpretation,var_u); +} +private pattern currentInRelation_pattern_queries_eventUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e, var_u) +{ + find interpretation(problem,interpretation); + // var_e exported + // var_u exported + find mustInRelationuser_reference_IssueEvent(problem,interpretation,var_e,var_u); + find mustInstanceOfUser_class(problem,interpretation,var_u); +} +// Must, May and Current queries for pattern queries noCommitter +private pattern mustInRelation_pattern_queries_noCommitter( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c) +{ + find interpretation(problem,interpretation); + // var_c exported + find mustInstanceOfCommit_class(problem,interpretation,var_c); + neg find mayInRelation_pattern_queries_committer(problem,interpretation,var_c,_var__0); +} +private pattern mayInRelation_pattern_queries_noCommitter( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c) +{ + find interpretation(problem,interpretation); + // var_c exported + find mayInstanceOfCommit_class(problem,interpretation,var_c); + neg find mustInRelation_pattern_queries_committer(problem,interpretation,var_c,_var__0); +} +private pattern currentInRelation_pattern_queries_noCommitter( + problem:LogicProblem, interpretation:PartialInterpretation, + var_c) +{ + find interpretation(problem,interpretation); + // var_c exported + find mustInstanceOfCommit_class(problem,interpretation,var_c); + neg find currentInRelation_pattern_queries_committer(problem,interpretation,var_c,_var__0); +} +// Must, May and Current queries for pattern queries noUser +private pattern mustInRelation_pattern_queries_noUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e) +{ + find interpretation(problem,interpretation); + // var_e exported + find mustInstanceOfIssueEvent_class(problem,interpretation,var_e); + neg find mayInRelation_pattern_queries_eventUser(problem,interpretation,var_e,_var__0); +} +private pattern mayInRelation_pattern_queries_noUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e) +{ + find interpretation(problem,interpretation); + // var_e exported + find mayInstanceOfIssueEvent_class(problem,interpretation,var_e); + neg find mustInRelation_pattern_queries_eventUser(problem,interpretation,var_e,_var__0); +} +private pattern currentInRelation_pattern_queries_noUser( + problem:LogicProblem, interpretation:PartialInterpretation, + var_e) +{ + find interpretation(problem,interpretation); + // var_e exported + find mustInstanceOfIssueEvent_class(problem,interpretation,var_e); + neg find currentInRelation_pattern_queries_eventUser(problem,interpretation,var_e,_var__0); +} + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationissue_reference_Project(problem,interpretation,source,target); }or + + { find mustInRelationprojectMembers_reference_Project(problem,interpretation,source,target); }or + + { find mustInRelationcommits_reference_Project(problem,interpretation,source,target); }or + + { find mustInRelationpullrequest_reference_Issue(problem,interpretation,source,target); }or + + { find mustInRelationissueevent_reference_Issue(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// +pattern invalidatedBy_pattern_queries_loopInParent(problem:LogicProblem, interpretation:PartialInterpretation, + var_a) +{ + find mustInRelation_pattern_queries_loopInParent(problem,interpretation,var_a); +} +pattern invalidatedBy_pattern_queries_mergedIssueWithoutPr(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find mustInRelation_pattern_queries_mergedIssueWithoutPr(problem,interpretation,var_i); +} +pattern invalidatedBy_pattern_queries_consecutiveClosesWithoutReopen(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find mustInRelation_pattern_queries_consecutiveClosesWithoutReopen(problem,interpretation,var_i); +} +pattern invalidatedBy_pattern_queries_consecutiveReopensWithoutClose(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find mustInRelation_pattern_queries_consecutiveReopensWithoutClose(problem,interpretation,var_i); +} +pattern invalidatedBy_pattern_queries_consecutiveSubWithoutUnSub(problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find mustInRelation_pattern_queries_consecutiveSubWithoutUnSub(problem,interpretation,var_i,var_u); +} +pattern invalidatedBy_pattern_queries_consecutiveUnSubWithoutSub(problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find mustInRelation_pattern_queries_consecutiveUnSubWithoutSub(problem,interpretation,var_i,var_u); +} +pattern invalidatedBy_pattern_queries_noCommitter(problem:LogicProblem, interpretation:PartialInterpretation, + var_c) +{ + find mustInRelation_pattern_queries_noCommitter(problem,interpretation,var_c); +} +pattern invalidatedBy_pattern_queries_noUser(problem:LogicProblem, interpretation:PartialInterpretation, + var_e) +{ + find mustInRelation_pattern_queries_noUser(problem,interpretation,var_e); +} + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// + + + + + + +private pattern existingMultiplicity_committer_reference_Commit(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer) { + find interpretation(problem,interpretation); + find mustExist(problem,interpretation,object); + find mustInstanceOfCommit_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationcommitter_reference_Commit(problem,interpretation,object,_); +} + + + + + + +private pattern existingMultiplicity_user_reference_IssueEvent(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer) { + find interpretation(problem,interpretation); + find mustExist(problem,interpretation,object); + find mustInstanceOfIssueEvent_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationuser_reference_IssueEvent(problem,interpretation,object,_); +} + + + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// +pattern unfinishedBy_pattern_queries_loopInParent(problem:LogicProblem, interpretation:PartialInterpretation, + var_a) +{ + find currentInRelation_pattern_queries_loopInParent(problem,interpretation,var_a); +} +pattern unfinishedBy_pattern_queries_mergedIssueWithoutPr(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find currentInRelation_pattern_queries_mergedIssueWithoutPr(problem,interpretation,var_i); +} +pattern unfinishedBy_pattern_queries_consecutiveClosesWithoutReopen(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find currentInRelation_pattern_queries_consecutiveClosesWithoutReopen(problem,interpretation,var_i); +} +pattern unfinishedBy_pattern_queries_consecutiveReopensWithoutClose(problem:LogicProblem, interpretation:PartialInterpretation, + var_i) +{ + find currentInRelation_pattern_queries_consecutiveReopensWithoutClose(problem,interpretation,var_i); +} +pattern unfinishedBy_pattern_queries_consecutiveSubWithoutUnSub(problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find currentInRelation_pattern_queries_consecutiveSubWithoutUnSub(problem,interpretation,var_i,var_u); +} +pattern unfinishedBy_pattern_queries_consecutiveUnSubWithoutSub(problem:LogicProblem, interpretation:PartialInterpretation, + var_i, var_u) +{ + find currentInRelation_pattern_queries_consecutiveUnSubWithoutSub(problem,interpretation,var_i,var_u); +} +pattern unfinishedBy_pattern_queries_noCommitter(problem:LogicProblem, interpretation:PartialInterpretation, + var_c) +{ + find currentInRelation_pattern_queries_noCommitter(problem,interpretation,var_c); +} +pattern unfinishedBy_pattern_queries_noUser(problem:LogicProblem, interpretation:PartialInterpretation, + var_e) +{ + find currentInRelation_pattern_queries_noUser(problem,interpretation,var_e); +} + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfUser_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfProject_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfIssueEvent_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfCommit_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfPullRequest_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfIssue_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfProject_class_DefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfProject_class_UndefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_IssueEvent_class_by_issueevent_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"IssueEvent class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"issueevent reference Issue"); + find mustInstanceOfIssue_class(problem,interpretation,container); + find mayInstanceOfIssueEvent_class(problem,interpretation,newObject); + find mayInRelationissueevent_reference_Issue(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_IssueEvent_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"IssueEvent class"); + find mayInstanceOfIssueEvent_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_PullRequest_class_by_pullrequest_reference_Issue( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"PullRequest class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"pullrequest reference Issue"); + find mustInstanceOfIssue_class(problem,interpretation,container); + find mayInstanceOfPullRequest_class(problem,interpretation,newObject); + find mayInRelationpullrequest_reference_Issue(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_PullRequest_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"PullRequest class"); + find mayInstanceOfPullRequest_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Project_class_UndefinedPart( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Project class UndefinedPart"); + find mayInstanceOfProject_class_UndefinedPart(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Commit_class_by_commits_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Commit class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"commits reference Project"); + find mustInstanceOfProject_class(problem,interpretation,container); + find mayInstanceOfCommit_class(problem,interpretation,newObject); + find mayInRelationcommits_reference_Project(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Commit_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Commit class"); + find mayInstanceOfCommit_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_User_class_by_projectMembers_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"User class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"projectMembers reference Project"); + find mustInstanceOfProject_class(problem,interpretation,container); + find mayInstanceOfUser_class(problem,interpretation,newObject); + find mayInRelationprojectMembers_reference_Project(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_User_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"User class"); + find mayInstanceOfUser_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Issue_class_by_issue_reference_Project( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Issue class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"issue reference Project"); + find mustInstanceOfProject_class(problem,interpretation,container); + find mayInstanceOfIssue_class(problem,interpretation,newObject); + find mayInRelationissue_reference_Project(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Issue_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Issue class"); + find mayInstanceOfIssue_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_IssueEvent_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); +} +pattern refineTypeTo_PullRequest_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); +} +pattern refineTypeTo_Project_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfProject_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); +} +pattern refineTypeTo_Commit_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); +} +pattern refineTypeTo_User_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfUser_class(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); +} +pattern refineTypeTo_Issue_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfIssueEvent_class(problem,interpretation,element); + neg find mustInstanceOfPullRequest_class(problem,interpretation,element); + neg find mustInstanceOfProject_class(problem,interpretation,element); + neg find mustInstanceOfCommit_class(problem,interpretation,element); + neg find mustInstanceOfIssue_class(problem,interpretation,element); + neg find mustInstanceOfUser_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_committer_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"committer reference Commit"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfCommit_class(problem,interpretation,from); + find mustInstanceOfUser_class(problem,interpretation,to); + find mayInRelationcommitter_reference_Commit(problem,interpretation,from,to); + neg find mustInRelationcommitter_reference_Commit(problem,interpretation,from,to); +} + +pattern refineRelation_parents_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parents reference Commit"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfCommit_class(problem,interpretation,from); + find mustInstanceOfCommit_class(problem,interpretation,to); + find mayInRelationparents_reference_Commit(problem,interpretation,from,to); + neg find mustInRelationparents_reference_Commit(problem,interpretation,from,to); +} + +pattern refineRelation_commit_reference_PullRequest_and_pullrequest_reference_Commit( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"commit reference PullRequest"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"pullrequest reference Commit"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfPullRequest_class(problem,interpretation,from); + find mustInstanceOfCommit_class(problem,interpretation,to); + find mayInRelationcommit_reference_PullRequest(problem,interpretation,from,to); + neg find mustInRelationcommit_reference_PullRequest(problem,interpretation,from,to); +} + +pattern refineRelation_user_reference_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"user reference IssueEvent"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfIssueEvent_class(problem,interpretation,from); + find mustInstanceOfUser_class(problem,interpretation,to); + find mayInRelationuser_reference_IssueEvent(problem,interpretation,from,to); + neg find mustInRelationuser_reference_IssueEvent(problem,interpretation,from,to); +} + +pattern refineRelation_action_attribute_IssueEvent( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"action attribute IssueEvent"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfIssueEvent_class(problem,interpretation,from); + find mustInstanceOfAction_enum(problem,interpretation,to); + find mayInRelationaction_attribute_IssueEvent(problem,interpretation,from,to); + neg find mustInRelationaction_attribute_IssueEvent(problem,interpretation,from,to); +} + + +////////// +// 5 Hints +////////// + +////////// +// 6 Unit Propagations +////////// + +// Collected propagation preconditions: + + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generation.logicproblem b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generation.logicproblem new file mode 100644 index 00000000..96543fe1 --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/generation.logicproblem @@ -0,0 +1,1114 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/init.partialmodel b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/init.partialmodel new file mode 100644 index 00000000..8bcbc8f2 --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/init.partialmodel @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/problem.als b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/problem.als new file mode 100644 index 00000000..dbdb8ba6 --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/debug/problem.als @@ -0,0 +1,151 @@ +one sig util'language { + AsDeclaration'pattern'queries'directParent : type'Commit'class->type'Commit'class, + util'root : one type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart)))))), + util'contains : (type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart))))))) lone->set (type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart))))))) +} +abstract sig util'Object { +} +sig type'User'class extends util'Object { +} +abstract sig type'Project'class extends util'Object { + issue'reference'Project : set type'Issue'class, + projectMembers'reference'Project : set type'User'class, + commits'reference'Project : set type'Commit'class +} +sig type'Commit'class extends util'Object { + committer'reference'Commit : one type'User'class, + parents'reference'Commit : set type'Commit'class, + pullrequest'reference'Commit : lone type'PullRequest'class +} +sig type'Issue'class extends util'Object { + pullrequest'reference'Issue : lone type'PullRequest'class, + issueevent'reference'Issue : set type'IssueEvent'class +} +sig type'PullRequest'class extends util'Object { + commit'reference'PullRequest : lone type'Commit'class +} +sig type'IssueEvent'class extends util'Object { + user'reference'IssueEvent : one type'User'class, + action'attribute'IssueEvent : one type'Action'enum +} +abstract sig type'Action'enum extends util'Object { +} +abstract sig type'Project'class'DefinedPart extends type'Project'class { +} +sig type'Project'class'UndefinedPart extends type'Project'class { +} +one sig element'SUBSCRIBED'literal'Action extends type'Action'enum { +} +one sig element'MENTIONED'literal'Action extends type'Action'enum { +} +one sig element'CLOSED'literal'Action extends type'Action'enum { +} +one sig element'REFERENCED'literal'Action extends type'Action'enum { +} +one sig element'ASSIGNED'literal'Action extends type'Action'enum { +} +one sig element'REOPENED'literal'Action extends type'Action'enum { +} +one sig element'UNSUBSCRIBED'literal'Action extends type'Action'enum { +} +one sig element'MERGED'literal'Action extends type'Action'enum { +} +one sig element'HEAD_REF_CLEANED'literal'Action extends type'Action'enum { +} +one sig element'HEAD_REF_DELETED'literal'Action extends type'Action'enum { +} +one sig element'HEAD_REF_RESTORED'literal'Action extends type'Action'enum { +} +one sig element'o'1 extends type'Project'class'DefinedPart { +} +pred pattern'queries'directParent [parameter'a: type'Commit'class, parameter'b: type'Commit'class] { + parameter'b in parameter'a.parents'reference'Commit && parameter'b in type'Commit'class +} +pred pattern'queries'loopInParent [parameter'a: type'Commit'class] { + parameter'a->parameter'a in ^ (util'language.AsDeclaration'pattern'queries'directParent) +} +pred pattern'queries'checkAction [parameter'i: type'Issue'class, parameter'e: type'IssueEvent'class, parameter't: type'Action'enum] { + parameter'e in parameter'i.issueevent'reference'Issue && parameter't in parameter'e.action'attribute'IssueEvent +} +pred pattern'queries'checkUserAction [parameter'i: type'Issue'class, parameter'u: type'User'class, parameter'e: type'IssueEvent'class, parameter't: type'Action'enum] { + parameter'e in parameter'i.issueevent'reference'Issue && (parameter'u in parameter'e.user'reference'IssueEvent && (parameter'u in type'User'class && parameter't in parameter'e.action'attribute'IssueEvent)) +} +pred pattern'queries'isReopen [parameter'i: type'Issue'class, parameter'e: type'IssueEvent'class] { + some variable'a: type'Action'enum { parameter'e in parameter'i.issueevent'reference'Issue && (variable'a in parameter'e.action'attribute'IssueEvent && variable'a = element'REOPENED'literal'Action) } +} +pred pattern'queries'isClose [parameter'i: type'Issue'class, parameter'e: type'IssueEvent'class] { + some variable'a: type'Action'enum { parameter'e in parameter'i.issueevent'reference'Issue && (variable'a in parameter'e.action'attribute'IssueEvent && variable'a = element'CLOSED'literal'Action) } +} +pred pattern'queries'isUnSubscribe [parameter'i: type'Issue'class, parameter'u: type'User'class, parameter'e: type'IssueEvent'class] { + some variable'a: type'Action'enum { parameter'e in parameter'i.issueevent'reference'Issue && (parameter'u in parameter'e.user'reference'IssueEvent && (parameter'u in type'User'class && (variable'a in parameter'e.action'attribute'IssueEvent && variable'a = element'UNSUBSCRIBED'literal'Action))) } +} +pred pattern'queries'isSubscribe [parameter'i: type'Issue'class, parameter'u: type'User'class, parameter'e: type'IssueEvent'class] { + some variable'a: type'Action'enum { parameter'e in parameter'i.issueevent'reference'Issue && (parameter'u in parameter'e.user'reference'IssueEvent && (parameter'u in type'User'class && (variable'a in parameter'e.action'attribute'IssueEvent && variable'a = element'SUBSCRIBED'literal'Action))) } +} +pred pattern'queries'consecutiveClosesWithoutReopen [parameter'i: type'Issue'class] { + some variable'a1: type'IssueEvent'class, variable'a2: type'IssueEvent'class, variable'virtual0: type'Action'enum, variable'virtual1: type'Action'enum { all variable'0: type'IssueEvent'class { variable'virtual0 = element'CLOSED'literal'Action && (pattern'queries'checkAction [ parameter'i , variable'a1 , variable'virtual0 ] && (variable'virtual1 = element'CLOSED'literal'Action && (pattern'queries'checkAction [ parameter'i , variable'a2 , variable'virtual1 ] && (variable'a1 != variable'a2 && not (pattern'queries'isReopen [ parameter'i , variable'0 ]))))) } } +} +pred pattern'queries'consecutiveReopensWithoutClose [parameter'i: type'Issue'class] { + some variable'a1: type'IssueEvent'class, variable'a2: type'IssueEvent'class, variable'virtual0: type'Action'enum, variable'virtual1: type'Action'enum { all variable'0: type'IssueEvent'class { variable'virtual0 = element'REOPENED'literal'Action && (pattern'queries'checkAction [ parameter'i , variable'a1 , variable'virtual0 ] && (variable'virtual1 = element'REOPENED'literal'Action && (pattern'queries'checkAction [ parameter'i , variable'a2 , variable'virtual1 ] && (variable'a1 != variable'a2 && not (pattern'queries'isClose [ parameter'i , variable'0 ]))))) } } +} +pred pattern'queries'consecutiveSubWithoutUnSub [parameter'i: type'Issue'class, parameter'u: type'User'class] { + some variable'a1: type'IssueEvent'class, variable'a2: type'IssueEvent'class, variable'virtual0: type'Action'enum, variable'virtual1: type'Action'enum { all variable'0: type'IssueEvent'class { variable'virtual0 = element'SUBSCRIBED'literal'Action && (pattern'queries'checkUserAction [ parameter'i , parameter'u , variable'a1 , variable'virtual0 ] && (variable'virtual1 = element'SUBSCRIBED'literal'Action && (pattern'queries'checkUserAction [ parameter'i , parameter'u , variable'a2 , variable'virtual1 ] && (variable'a1 != variable'a2 && not (pattern'queries'isUnSubscribe [ parameter'i , parameter'u , variable'0 ]))))) } } +} +pred pattern'queries'consecutiveUnSubWithoutSub [parameter'i: type'Issue'class, parameter'u: type'User'class] { + some variable'a1: type'IssueEvent'class, variable'a2: type'IssueEvent'class, variable'virtual0: type'Action'enum, variable'virtual1: type'Action'enum { all variable'0: type'IssueEvent'class { variable'virtual0 = element'UNSUBSCRIBED'literal'Action && (pattern'queries'checkUserAction [ parameter'i , parameter'u , variable'a1 , variable'virtual0 ] && (variable'virtual1 = element'UNSUBSCRIBED'literal'Action && (pattern'queries'checkUserAction [ parameter'i , parameter'u , variable'a2 , variable'virtual1 ] && (variable'a1 != variable'a2 && not (pattern'queries'isSubscribe [ parameter'i , parameter'u , variable'0 ]))))) } } +} +pred pattern'queries'committer [parameter'c: type'Commit'class, parameter'u: type'User'class] { + parameter'u in parameter'c.committer'reference'Commit && parameter'u in type'User'class +} +pred pattern'queries'eventUser [parameter'e: type'IssueEvent'class, parameter'u: type'User'class] { + parameter'u in parameter'e.user'reference'IssueEvent && parameter'u in type'User'class +} +pred pattern'queries'noCommitter [parameter'c: type'Commit'class] { + all variable'0: type'User'class { parameter'c in type'Commit'class && not (pattern'queries'committer [ parameter'c , variable'0 ]) } +} +pred pattern'queries'noUser [parameter'e: type'IssueEvent'class] { + all variable'0: type'User'class { parameter'e in type'IssueEvent'class && not (pattern'queries'eventUser [ parameter'e , variable'0 ]) } +} +fact EqualsAsDeclaration'pattern'queries'directParent { + all a: type'Commit'class, b: type'Commit'class { pattern'queries'directParent [ a , b ] <=> a->b in util'language.AsDeclaration'pattern'queries'directParent } +} +fact util'containmentDefinition { + util'language.util'contains = issue'reference'Project + (projectMembers'reference'Project + (commits'reference'Project + (pullrequest'reference'Issue + issueevent'reference'Issue))) +} +fact util'noParentForRoot { + no parent: type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart)))))) { parent->(util'language.util'root) in util'language.util'contains } +} +fact util'atLeastOneParent { + all child: type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart)))))) { child = util'language.util'root or (some parent: type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart)))))) { parent->child in util'language.util'contains }) } +} +fact util'noCircularContainment { + no circle: type'PullRequest'class + (type'IssueEvent'class + (type'Commit'class + (type'User'class + (type'Project'class + (type'Issue'class + (type'Project'class'DefinedPart + type'Project'class'UndefinedPart)))))) { circle->circle in ^ (util'language.util'contains) } +} +fact upperMultiplicity'parents'Commit { + all src: type'Commit'class, trg'1: type'Commit'class, trg'2: type'Commit'class, trg'3: type'Commit'class { trg'1 in src.parents'reference'Commit && (trg'2 in src.parents'reference'Commit && trg'3 in src.parents'reference'Commit) => not (trg'1 != trg'2 && (trg'1 != trg'3 && trg'2 != trg'3)) } +} +fact oppositeReference'pullrequest'Commit { + pullrequest'reference'Commit = ~ commit'reference'PullRequest +} +fact errorpattern'queries'loopInParent { + all p0: type'Commit'class { not (pattern'queries'loopInParent [ p0 ]) } +} +fact errorpattern'queries'consecutiveClosesWithoutReopen { + all p0: type'Issue'class { not (pattern'queries'consecutiveClosesWithoutReopen [ p0 ]) } +} +fact errorpattern'queries'consecutiveReopensWithoutClose { + all p0: type'Issue'class { not (pattern'queries'consecutiveReopensWithoutClose [ p0 ]) } +} +fact errorpattern'queries'consecutiveSubWithoutUnSub { + all p0: type'Issue'class, p1: type'User'class { not (pattern'queries'consecutiveSubWithoutUnSub [ p0 , p1 ]) } +} +fact errorpattern'queries'consecutiveUnSubWithoutSub { + all p0: type'Issue'class, p1: type'User'class { not (pattern'queries'consecutiveUnSubWithoutSub [ p0 , p1 ]) } +} +fact errorpattern'queries'noCommitter { + all p0: type'Commit'class { not (pattern'queries'noCommitter [ p0 ]) } +} +fact errorpattern'queries'noUser { + all p0: type'IssueEvent'class { not (pattern'queries'noUser [ p0 ]) } +} +run { } for exactly 41 util'Object , 1 Int , exactly 0 String \ No newline at end of file diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/ecore.vsconfig b/Metrics/Metrics-Calculation/SocialNetwork_plugin/ecore.vsconfig index 9d3dd0e9..c0ba6fab 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/ecore.vsconfig +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/ecore.vsconfig @@ -6,7 +6,7 @@ generate { metamodel = {package ecore excluding{EClassifier.instanceClass, EClassifier.defaultValue, EEnumLiteral.instance, EStructuralFeature.defaultValue, EStructuralFeature.changeable, EStructuralFeature.derived, ENamedElement.name, EClass.interface, EClass.abstract, EClassifier.instanceTypeName, - EClassifier.instanceClassName, EPackage.nsPrefix, EPackage.nsURI, EAnnotation.source, + EClassifier.instanceClassName, EPackage.nsPrefix, EPackage.nsURI, EAttribute.iD, EDataType.serializable, EEnumLiteral.literal, EEnumLiteral.value, EReference.resolveProxies, EReference.container, EReference.containment, EStringToStringMapEntry.key, EStringToStringMapEntry.value, EStructuralFeature.defaultValueLiteral, EStructuralFeature.transient, @@ -19,7 +19,7 @@ generate { EClass. eAllOperations, EClass.eAllStructuralFeatures, EClass.eAttributes, EClass.eIDAttribute, EClass.eReferences, EAttribute.eAttributeType, EGenericType.eRawType, EReference.eReferenceType, //Generic Types - EClass.eGenericSuperTypes, ETypedElement.eGenericType, EOperation.eGenericExceptions, EObject, EAnnotation.references, EAnnotation.contents + EClass.eGenericSuperTypes, ETypedElement.eGenericType, EOperation.eGenericExceptions, EObject, EAnnotation, EModelElement.eAnnotations, EAnnotation.details, EAnnotation.contents, EAnnotation.references, EAnnotation.source, EAnnotation.eModelElement }} partial-model = { "inputs/ecore.xmi"} @@ -30,22 +30,22 @@ generate { //median run time scope = { - #node = 30 // (warm-up: 10) 30, 50, 80, 100, 120 .... + #node = 101 // (warm-up: 10) 30, 50, 80, 100, 120 .... } number = 1 runs = 1 config = { log-level = none, - runtime = 300, // the runtime is in seconds, want to set is to 5 mins - "optional-wf" = "false", + //runtime = 300, // the runtime is in seconds, want to set is to 5 mins + "optional-wf" = "true", "realistic-guidance" = "Composite", - "allow-must-violations" = "false", + "allow-must-violations" = "true", "domain" = "Ecore", "scopePropagator" = "typeHierarchy" } debug = "debug" statistics = "statistics/Ecore/warmup.csv" //give different set up different filenames - output = "output/Ecore/run_time/" + output = "output/Alloy/Ecore/" } diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/github.vsconfig b/Metrics/Metrics-Calculation/SocialNetwork_plugin/github.vsconfig index e9f9a8d5..22b0facb 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/github.vsconfig +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/github.vsconfig @@ -4,7 +4,7 @@ import viatra "../../../Domains/github-graph/queries/queries/github.vql" generate { metamodel = {package github excluding{ Project.creatd_at, Project.updated_at, Project.url, User.name, User.url, Commit.created_at, Commit.sha, Commit.parents_sha, Issue.created_at, Issue.url, PullRequest.url, IssueEvent.created_at, - IssueEvent.actor_url, Action, IssueEvent.action, Project.deleted}} + IssueEvent.actor_url, Project.deleted}} partial-model = { "inputs/github.xmi"} constraints = { package queries } @@ -12,14 +12,14 @@ generate { solver = ViatraSolver scope = { - #node = 30 + #node = 41 } number = 1 - runs = 5 + runs = 100 config = { log-level = none, - runtime = 300, + //runtime = 300, "optional-wf" = "false", "realistic-guidance" = "Composite", "allow-must-violations" = "false", @@ -28,8 +28,8 @@ generate { } debug = "debug" - statistics = "statistics/Github/warmup.csv" - output = "output/Github/Composite" + statistics = "statistics/runtime/Github/statistics.csv" + output = "output/Real/Github/" } // generate { diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/src/ca/mcgill/ecse/socialnetwork/runner/Main.java b/Metrics/Metrics-Calculation/SocialNetwork_plugin/src/ca/mcgill/ecse/socialnetwork/runner/Main.java index e4e5b61f..f41e61ee 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/src/ca/mcgill/ecse/socialnetwork/runner/Main.java +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/src/ca/mcgill/ecse/socialnetwork/runner/Main.java @@ -31,14 +31,9 @@ public class Main { private static String fileReadFolder = "output/Ecore_100/"; public static void main(String args[]) { - String ecoreFile = args[0]; System.out.println("Generation Started"); - System.out.println(System.getProperty("java.library.path")); - - long begin = System.currentTimeMillis(); - String message = runWithPath(ecoreFile); - long elapsed = System.currentTimeMillis() - begin; + String message = runWithPath(args[0]); if(message != null) { System.out.println(message); diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Ecore/warmup.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Ecore/warmup.csv index 4e752917..1cc1302f 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Ecore/warmup.csv +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Ecore/warmup.csv @@ -1,3 +1,3 @@ Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls -1,1,ModelResultImpl,1606,10223,12802,105,12895,1128,389,150,0,354,2147,0,8,1911,4420,2032,16,0,2,0,2105,2083,618,0 +1,1,ModelResultImpl,1720,10871,57313,271,57355,1062,840,223,0,383,17405,0,5,7417,12196,4062,13,24,14,0,12282,7657,929,0 diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Github/warmup.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Github/warmup.csv index 989c2411..f531c6b8 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Github/warmup.csv +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Github/warmup.csv @@ -1,7 +1,102 @@ -Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,_Solution0FoundAt,TransformationExecutionTime,TypeAnalysisTime,MetricCalculationTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime -1,1,ModelResultImpl,1483,2558,3108,60043900,1609,456,424,87,272,0,1 -1,2,ModelResultImpl,1483,1126,1487,9020100,931,292,1,60,256,0,1 -1,3,ModelResultImpl,1483,927,1424,9739900,827,263,0,51,217,0,0 -1,4,ModelResultImpl,1483,886,1069,8613600,495,208,1,25,97,0,0 -1,5,ModelResultImpl,1483,768,1268,9369800,856,262,0,35,223,0,0 +Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls +1,1,ModelResultImpl,1837,6117,12674,162,12793,948,419,38,0,340,2142,0,4,2431,5503,1800,15,15,2,0,1353,2849,233,0 +1,2,ModelResultImpl,1837,3840,8029,24,8019,137,207,14,0,1,1447,0,4,2129,3825,969,13,22,0,0,959,2840,222,0 +1,3,ModelResultImpl,1837,3355,8112,22,8105,107,161,8,0,0,1591,0,1,2496,3768,1001,17,20,0,0,902,3074,225,0 +1,4,ModelResultImpl,1837,3652,15894,39,15875,128,340,11,0,0,3134,0,4,3748,7781,2384,26,16,1,0,1203,4288,250,0 +1,5,ModelResultImpl,1837,3293,7261,17,7251,79,160,8,0,0,1362,0,1,2298,3539,888,13,17,0,0,784,3009,248,0 +1,6,ModelResultImpl,1837,3235,10546,18,10530,114,213,9,0,0,1938,0,5,2260,5176,1318,22,22,0,0,1086,2910,227,0 +1,7,ModelResultImpl,1837,2354,8484,13,8475,85,163,7,0,0,1700,0,1,2884,4027,1186,15,11,0,0,832,3420,244,0 +1,8,ModelResultImpl,1837,2380,7128,13,7120,70,143,7,0,0,1371,0,1,2260,3366,899,10,15,0,0,814,2955,234,0 +1,9,ModelResultImpl,1837,2277,8266,18,8258,83,175,8,0,0,1522,0,1,2282,4002,1080,12,10,0,0,890,2949,232,0 +1,10,ModelResultImpl,1837,2470,8318,14,8308,82,183,9,0,0,1647,0,1,2284,3854,1058,19,16,0,0,916,2676,228,0 +1,11,ModelResultImpl,1837,2767,7245,16,7235,107,153,8,0,0,1341,0,2,2470,3496,949,19,23,0,0,723,2833,265,0 +1,12,ModelResultImpl,1837,2197,6661,13,6653,62,134,7,0,0,1356,0,2,2365,3121,804,10,14,0,0,746,2914,258,0 +1,13,ModelResultImpl,1837,2278,8037,11,8027,67,172,8,0,0,1500,0,1,2086,3874,1062,11,8,0,0,861,3068,268,0 +1,14,ModelResultImpl,1837,2159,8654,17,8645,112,179,9,0,0,1588,0,1,2540,4095,1158,18,16,0,0,960,3014,231,0 +1,15,ModelResultImpl,1837,2122,7507,10,7495,70,152,6,0,0,1424,0,1,2382,3574,990,14,56,0,0,794,3119,227,0 +1,16,ModelResultImpl,1837,2221,7044,15,7038,66,135,6,0,0,1423,0,1,2107,3225,799,14,9,0,0,901,2955,215,0 +1,17,ModelResultImpl,1837,2032,6883,11,6871,61,144,7,0,0,1242,0,1,1961,3346,864,10,8,0,0,772,3019,266,0 +1,18,ModelResultImpl,1837,2077,7848,10,7840,59,154,7,0,0,1441,0,1,2705,3772,1122,10,15,0,0,829,3163,260,0 +1,19,ModelResultImpl,1837,2139,6288,11,6280,61,126,6,0,0,1143,0,1,1898,3057,852,7,13,0,0,661,2669,241,0 +1,20,ModelResultImpl,1837,2052,6709,16,6698,56,138,7,0,0,1235,0,5,2215,3252,906,9,12,0,0,714,2741,255,0 +1,21,ModelResultImpl,1837,1979,7165,12,7158,52,138,6,0,0,1362,0,1,2316,3411,888,10,12,0,0,853,3042,235,0 +1,22,ModelResultImpl,1837,2275,6871,11,6862,61,131,5,0,0,1288,0,2,2411,3309,930,11,8,0,0,724,2969,206,0 +1,23,ModelResultImpl,1837,2226,8932,9,8925,58,192,9,0,0,1575,0,2,2740,4460,1315,9,8,0,0,847,3387,295,0 +1,24,ModelResultImpl,1837,2628,6715,10,6707,60,134,6,0,0,1310,0,1,1970,3175,812,8,9,0,0,758,2841,221,0 +1,25,ModelResultImpl,1837,2552,7769,11,7759,70,163,7,0,0,1393,0,1,2365,3748,1056,9,13,0,0,817,2772,236,0 +1,26,ModelResultImpl,1837,2219,7586,10,7576,55,156,7,0,0,1421,0,1,2377,3585,1027,10,12,0,0,830,2775,227,0 +1,27,ModelResultImpl,1837,1974,7241,15,7233,71,147,5,0,0,1312,0,1,2151,3417,961,10,20,0,0,845,2699,183,0 +1,28,ModelResultImpl,1837,2181,7117,10,7106,83,141,6,0,0,1393,0,1,2264,3296,920,21,10,0,0,760,2815,224,0 +1,29,ModelResultImpl,1837,2109,7350,13,7338,60,145,6,0,0,1416,0,1,2363,3536,999,9,9,0,0,759,2961,234,0 +1,30,ModelResultImpl,1837,2086,7998,18,7985,54,156,8,0,0,1455,0,2,2805,3930,1146,14,15,0,0,810,3249,253,0 +1,31,ModelResultImpl,1837,2091,7463,10,7450,72,146,7,0,0,1430,0,2,2444,3545,1015,11,13,0,0,782,3023,250,0 +1,32,ModelResultImpl,1837,2201,7078,12,7070,69,142,7,0,0,1279,0,2,1978,3475,901,8,8,0,0,774,2808,246,0 +1,33,ModelResultImpl,1837,1888,6669,9,6662,66,122,7,0,0,1338,0,1,2607,3161,901,9,13,0,0,669,2945,264,0 +1,34,ModelResultImpl,1837,2096,6852,9,6846,58,129,6,0,1,1304,0,1,2389,3259,852,9,8,0,0,821,3071,240,0 +1,35,ModelResultImpl,1837,1912,6954,10,6947,53,131,6,0,0,1410,0,2,2039,3232,869,14,10,0,0,776,3004,239,0 +1,36,ModelResultImpl,1837,2431,7681,7,7672,67,165,7,0,2,1348,0,1,2249,3748,1069,14,12,0,0,801,2859,232,0 +1,37,ModelResultImpl,1837,1979,7307,8,7299,56,144,7,0,0,1317,0,1,2712,3570,1017,12,10,0,0,777,3062,247,0 +1,38,ModelResultImpl,1837,1959,6786,7,6775,52,135,6,0,0,1309,0,1,2248,3212,875,11,9,0,0,736,2808,233,0 +1,39,ModelResultImpl,1837,2133,6693,10,6682,63,133,7,0,0,1224,0,1,2072,3218,866,8,15,0,0,753,2869,242,0 +1,40,ModelResultImpl,1837,2043,7444,8,7435,70,146,7,0,0,1384,0,1,2463,3527,1015,8,12,0,0,823,3042,238,0 +1,41,ModelResultImpl,1837,2017,6678,8,6667,56,134,6,0,0,1211,0,1,1837,3180,858,9,9,0,0,755,2801,245,0 +1,42,ModelResultImpl,1837,2142,8098,12,8089,73,162,6,0,0,1584,0,1,2274,3680,1066,14,16,0,0,946,2877,208,0 +1,43,ModelResultImpl,1837,2143,8116,17,8101,61,178,8,0,0,1449,0,2,2213,3959,1107,15,11,0,0,844,3002,255,0 +1,44,ModelResultImpl,1837,2182,8124,12,8116,63,178,7,0,0,1483,0,1,1854,3861,1036,10,11,0,0,927,3004,247,0 +1,45,ModelResultImpl,1837,2210,8320,11,8309,65,176,7,0,0,1547,0,1,2307,3924,1123,12,15,0,0,892,2877,228,0 +1,46,ModelResultImpl,1837,2368,8485,14,8478,80,172,6,0,0,1652,0,1,2473,3958,1133,16,19,0,0,897,3020,221,0 +1,47,ModelResultImpl,1837,2783,14961,11,14949,76,318,12,0,0,2829,0,1,2742,7176,2130,14,14,0,0,1483,3287,262,0 +1,48,ModelResultImpl,1837,2348,8657,9,8644,82,178,7,0,0,1596,0,2,2535,4116,1177,13,11,0,0,901,2903,228,0 +1,49,ModelResultImpl,1837,2405,7564,13,7549,68,162,7,0,0,1377,0,2,2016,3615,1036,8,11,0,0,817,2696,238,0 +1,50,ModelResultImpl,1837,2207,7821,11,7812,65,167,8,0,0,1456,0,3,2500,3729,1100,12,14,0,0,824,2846,272,0 +1,51,ModelResultImpl,1837,2222,7165,9,7156,61,135,6,0,0,1459,0,1,2287,3249,838,8,11,0,0,877,2879,200,0 +1,52,ModelResultImpl,1837,2053,7991,8,7984,55,149,6,0,0,1623,0,1,2518,3645,982,10,12,0,0,937,3141,214,0 +1,53,ModelResultImpl,1837,2225,8130,7,8122,63,169,8,0,0,1502,0,2,2657,3958,1117,15,20,0,0,824,3164,263,0 +1,54,ModelResultImpl,1837,2131,7761,7,7753,69,152,7,0,0,1402,0,1,2033,3739,1014,9,11,0,0,906,3327,268,0 +1,55,ModelResultImpl,1837,3913,9755,8,9741,92,209,9,0,0,1688,0,2,2517,4669,1409,15,18,0,0,1025,2895,231,0 +1,56,ModelResultImpl,1837,2172,7846,11,7836,53,155,6,0,0,1530,0,2,2523,3687,992,12,13,0,0,835,3010,213,0 +1,57,ModelResultImpl,1837,2329,7936,24,7913,73,161,10,0,0,1431,0,1,2383,3802,1098,11,13,0,0,808,2999,242,0 +1,58,ModelResultImpl,1837,2806,6725,7,6717,79,136,7,0,0,1239,0,1,1901,3209,847,13,16,0,0,756,2855,241,0 +1,59,ModelResultImpl,1837,1972,8194,10,8185,65,149,6,0,0,1590,0,2,3030,3850,1112,8,10,0,0,886,3387,230,0 +1,60,ModelResultImpl,1837,1907,6172,8,6164,61,124,6,0,0,1182,0,1,2171,2924,787,7,9,0,0,697,2671,243,0 +1,61,ModelResultImpl,1837,1929,7400,12,7391,63,138,6,0,0,1420,0,2,2342,3481,943,10,11,0,0,850,2980,233,0 +1,62,ModelResultImpl,1837,1985,7669,10,7662,57,148,7,0,0,1416,0,1,2961,3731,1042,9,10,0,0,848,3309,290,0 +1,63,ModelResultImpl,1837,2045,9181,10,9174,89,203,11,0,0,1759,0,1,2125,4390,1158,11,14,0,0,1002,2953,223,0 +1,64,ModelResultImpl,1837,2467,12967,11,12950,98,279,11,0,0,2220,0,1,2297,6234,1958,15,17,0,0,1292,2781,247,0 +1,65,ModelResultImpl,1837,2679,6673,7,6665,67,128,6,0,0,1280,0,1,2298,3116,815,10,13,0,0,784,2717,199,0 +1,66,ModelResultImpl,1837,4230,8564,7,8557,110,190,8,0,0,1563,0,1,2508,4065,1120,23,25,0,0,926,3035,236,0 +1,67,ModelResultImpl,1837,2004,6411,7,6402,76,125,7,0,0,1139,0,1,2236,3148,789,13,10,0,0,740,2802,245,0 +1,68,ModelResultImpl,1837,2033,6886,11,6878,52,136,6,0,0,1276,0,1,2357,3298,921,11,8,0,0,756,2924,223,0 +1,69,ModelResultImpl,1837,2106,11529,10,11518,55,290,11,0,0,2009,0,2,2614,5745,1722,11,11,0,0,1093,2962,253,0 +1,70,ModelResultImpl,1837,2732,9237,9,9227,77,196,9,0,0,1651,0,1,2480,4450,1312,23,17,0,0,948,2829,243,0 +1,71,ModelResultImpl,1837,2308,7444,6,7433,71,156,7,0,0,1313,0,1,1825,3583,973,10,17,0,0,855,2861,252,0 +1,72,ModelResultImpl,1837,1950,10129,10,10121,63,205,8,0,0,1880,0,3,2784,4770,1425,11,13,0,0,1029,3327,240,0 +1,73,ModelResultImpl,1837,2052,8735,58,8723,57,185,7,0,0,1587,0,1,2368,4237,1260,8,9,0,0,865,3017,244,0 +1,74,ModelResultImpl,1837,2314,6782,6,6774,56,130,6,0,0,1277,0,1,2332,3219,857,11,13,0,0,759,2866,217,0 +1,75,ModelResultImpl,1837,1937,8288,8,8278,56,155,7,0,0,1592,0,1,2691,3928,1103,12,10,0,0,881,3433,255,0 +1,76,ModelResultImpl,1837,1949,6292,7,6280,54,124,6,0,0,1244,0,1,1977,2948,705,10,11,0,0,761,2718,204,0 +1,77,ModelResultImpl,1837,2036,7303,7,7291,58,142,6,0,0,1372,0,1,2317,3420,948,11,9,0,0,848,2992,232,0 +1,78,ModelResultImpl,1837,2116,7548,8,7539,61,147,8,0,0,1466,0,1,2739,3609,1011,9,11,0,0,810,3148,258,0 +1,79,ModelResultImpl,1837,1914,7609,9,7600,56,140,6,0,0,1541,0,1,2988,3599,1012,11,11,0,0,795,3224,247,0 +1,80,ModelResultImpl,1837,1975,7818,9,7809,68,152,7,0,0,1448,0,1,2403,3784,1089,9,9,0,0,818,3213,264,0 +1,81,ModelResultImpl,1837,2005,7659,9,7651,53,145,6,0,0,1476,0,1,2342,3564,952,8,10,0,0,885,3211,238,0 +1,82,ModelResultImpl,1837,2010,7084,7,7076,65,136,7,0,0,1352,0,1,2493,3332,896,14,13,0,0,822,2989,253,0 +1,83,ModelResultImpl,1837,2199,6854,12,6844,56,141,8,0,0,1246,0,1,2272,3328,885,11,10,0,0,741,2768,227,0 +1,84,ModelResultImpl,1837,2520,8156,8,8147,69,174,8,0,0,1484,0,1,2667,3934,1098,10,10,0,0,938,3217,266,0 +1,85,ModelResultImpl,1837,3333,7368,7,7361,76,145,8,0,0,1375,0,2,2377,3553,990,15,11,0,0,799,3080,285,0 +1,86,ModelResultImpl,1837,1947,7934,9,7921,56,160,7,0,0,1553,0,1,2234,3697,1031,7,9,0,0,914,3106,237,0 +1,87,ModelResultImpl,1837,1944,7279,8,7269,61,147,8,0,0,1356,0,1,2349,3526,964,9,10,0,0,784,3028,272,0 +1,88,ModelResultImpl,1837,2133,7005,6,6997,52,133,7,0,0,1266,0,1,2166,3398,919,14,9,0,0,817,3048,250,0 +1,89,ModelResultImpl,1837,1830,7421,7,7414,49,130,7,0,0,1499,0,1,2643,3480,939,8,11,0,0,827,3284,248,0 +1,90,ModelResultImpl,1837,1819,6537,9,6527,52,115,6,0,0,1334,0,1,2625,3066,816,8,8,0,0,726,2982,229,0 +1,91,ModelResultImpl,1837,1872,5674,8,5666,48,112,7,0,0,1031,0,1,1999,2809,691,9,10,0,0,649,2818,273,0 +1,92,ModelResultImpl,1837,1841,6782,9,6766,57,118,5,0,0,1443,0,1,2317,3056,810,9,8,0,0,805,2905,222,0 +1,93,ModelResultImpl,1837,1816,7569,9,7561,46,132,6,0,0,1532,0,1,2694,3498,942,7,11,0,0,898,3259,217,0 +1,94,ModelResultImpl,1837,1932,6539,8,6532,48,118,6,0,0,1224,0,1,2529,3191,847,11,10,0,0,697,3021,248,0 +1,95,ModelResultImpl,1837,1776,6516,6,6509,47,118,6,0,0,1235,0,1,2213,3129,772,14,10,0,0,777,3020,226,0 +1,96,ModelResultImpl,1837,1800,6836,8,6828,50,123,6,0,0,1307,0,1,2509,3300,867,8,9,0,0,760,3126,246,0 +1,97,ModelResultImpl,1837,1909,6676,8,6667,62,122,7,0,0,1306,0,1,2625,3208,866,8,9,0,0,718,3035,262,0 +1,98,ModelResultImpl,1837,1786,6203,8,6191,49,116,7,0,0,1157,0,1,2114,3032,815,8,9,0,0,682,2890,270,0 +1,99,ModelResultImpl,1837,1762,7047,8,7040,55,127,7,0,0,1358,0,1,2875,3376,927,9,13,0,0,751,3246,259,0 +1,100,ModelResultImpl,1837,1836,6691,7,6684,48,122,6,0,0,1262,0,1,2604,3290,871,10,10,0,0,693,3119,251,0 diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Yakindu/warmup.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Yakindu/warmup.csv index 12b0bf9d..d39e8cd0 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Yakindu/warmup.csv +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/Yakindu/warmup.csv @@ -1,12 +1,3 @@ Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls -1,1,ModelResultImpl,1643,5499,8730,150,8800,955,382,107,0,365,1483,0,6,1361,3560,1527,16,0,2,0,790,2113,919,0 -1,2,ModelResultImpl,1643,3215,5612,28,5605,106,218,63,0,0,747,0,1,1428,2734,1077,16,0,1,0,493,1942,979,0 -1,3,ModelResultImpl,1643,2911,6335,24,6328,102,206,54,0,0,1142,0,1,1884,2985,1085,24,0,1,0,560,2741,1014,0 -1,4,ModelResultImpl,1643,2587,4554,22,4549,78,123,25,0,0,814,0,2,1151,2105,845,12,0,0,0,418,1833,531,0 -1,5,ModelResultImpl,1643,2416,4379,16,4373,75,150,52,0,0,647,0,1,1556,2165,833,16,0,0,0,360,1967,1030,0 -1,6,ModelResultImpl,1643,2028,4553,16,4547,65,123,25,0,0,814,0,2,1149,2127,821,12,0,0,0,417,1894,507,0 -1,7,ModelResultImpl,1643,2041,4786,19,4777,59,154,44,0,0,755,0,1,1383,2264,901,15,0,0,0,474,2113,906,0 -1,8,ModelResultImpl,1643,2032,6211,15,6202,57,208,46,0,0,1040,0,1,1798,3051,1088,12,0,0,0,561,2882,951,0 -1,9,ModelResultImpl,1643,1958,4846,17,4839,75,122,26,0,0,876,0,1,1362,2205,892,16,0,0,0,421,1936,542,0 -1,10,ModelResultImpl,1643,2092,5974,28,5964,71,199,58,0,0,930,0,2,1643,2898,1133,12,0,0,0,541,2259,993,0 +1,1,ModelResultImpl,1639,5885,29226,380,29273,882,863,372,0,373,7868,0,11,6069,10459,5104,15,33,2,0,3693,6279,4704,0 diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/base/Github/statistics.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/base/Github/statistics.csv new file mode 100644 index 00000000..b6f7adc3 --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/base/Github/statistics.csv @@ -0,0 +1,12 @@ +Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,Solution1DetailedStatistics,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls +1,1,ModelResultImpl,2242,6308,1413,176,1512,(TransformationExecutionTime50|ForwardTime:425|Backtrackingtime:42|GlobalConstraintEvaluationTime:31|FitnessCalculationTime:9|ActivationSelectionTime:1|SolutionCopyTime:7|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),680,50,12,0,413,479,0,7,84,425,77,31,9,1,83,0,83,30,0 +1,2,ModelResultImpl,2242,5017,676,19,645,(TransformationExecutionTime38|ForwardTime:347|Backtrackingtime:62|GlobalConstraintEvaluationTime:18|FitnessCalculationTime:12|ActivationSelectionTime:0|SolutionCopyTime:4|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),74,38,9,0,0,81,0,4,108,347,93,18,12,0,107,0,107,30,0 +1,3,ModelResultImpl,2242,3852,422,20,401,(TransformationExecutionTime20|ForwardTime:201|Backtrackingtime:21|GlobalConstraintEvaluationTime:20|FitnessCalculationTime:15|ActivationSelectionTime:0|SolutionCopyTime:2|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),61,20,4,0,0,53,0,2,88,201,42,20,15,0,89,0,89,32,0 +1,4,ModelResultImpl,2242,3481,371,25,362,(TransformationExecutionTime16|ForwardTime:181|Backtrackingtime:26|GlobalConstraintEvaluationTime:19|FitnessCalculationTime:12|ActivationSelectionTime:0|SolutionCopyTime:3|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),56,16,3,0,0,42,0,3,105,181,36,19,12,0,104,0,104,30,0 +1,5,ModelResultImpl,2242,3814,475,25,457,(TransformationExecutionTime19|ForwardTime:211|Backtrackingtime:26|GlobalConstraintEvaluationTime:15|FitnessCalculationTime:12|ActivationSelectionTime:0|SolutionCopyTime:3|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),50,19,2,0,1,114,0,3,107,211,44,15,12,0,107,0,107,31,0 +1,6,ModelResultImpl,2242,2816,212,17,201,(TransformationExecutionTime10|ForwardTime:103|Backtrackingtime:2|GlobalConstraintEvaluationTime:14|FitnessCalculationTime:10|ActivationSelectionTime:0|SolutionCopyTime:1|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),38,10,2,0,1,16,0,1,66,103,13,14,10,0,65,0,65,30,0 +1,7,ModelResultImpl,2242,2601,278,23,262,(TransformationExecutionTime12|ForwardTime:140|Backtrackingtime:11|GlobalConstraintEvaluationTime:10|FitnessCalculationTime:10|ActivationSelectionTime:0|SolutionCopyTime:2|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),42,12,1,0,0,28,0,2,79,140,27,10,10,0,79,0,79,31,0 +1,8,ModelResultImpl,2242,2427,200,16,191,(TransformationExecutionTime7|ForwardTime:95|Backtrackingtime:6|GlobalConstraintEvaluationTime:10|FitnessCalculationTime:8|ActivationSelectionTime:0|SolutionCopyTime:2|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),39,7,1,0,0,19,0,2,78,95,15,10,8,0,77,0,77,30,0 +1,9,ModelResultImpl,2242,2358,355,16,344,(TransformationExecutionTime13|ForwardTime:189|Backtrackingtime:18|GlobalConstraintEvaluationTime:20|FitnessCalculationTime:14|ActivationSelectionTime:0|SolutionCopyTime:5|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),37,13,1,0,0,40,0,5,98,189,29,20,14,0,97,0,97,30,0 +1,10,ModelResultImpl,2242,2415,220,18,208,(TransformationExecutionTime8|ForwardTime:101|Backtrackingtime:5|GlobalConstraintEvaluationTime:10|FitnessCalculationTime:8|ActivationSelectionTime:0|SolutionCopyTime:3|NumericalSolverSumTime:0|NumericalSolverProblemFormingTime:0|NumericalSolverSolvingTime:0|NumericalSolverInterpretingSolution:0),49,8,1,0,0,19,0,3,79,101,17,10,8,0,78,0,78,30,0 + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics.csv new file mode 100644 index 00000000..2fa5bafe --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics.csv @@ -0,0 +1,102 @@ +Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls +1,1,ModelResultImpl,2436,7220,11084,118,11208,873,333,37,0,427,2056,0,5,2369,4931,1557,16,24,1,0,1092,3058,289,0 +1,2,ModelResultImpl,2436,2992,6563,23,6555,125,151,13,0,0,1226,0,2,2457,3226,840,12,30,0,0,692,2676,324,0 +1,3,ModelResultImpl,2436,2752,6147,16,6140,85,129,12,0,0,1128,0,1,2602,3038,878,16,16,0,0,609,2825,411,0 +1,4,ModelResultImpl,2436,2245,5882,16,5875,69,115,8,0,0,1104,0,2,2513,2941,768,8,14,0,0,627,2809,363,0 +1,5,ModelResultImpl,2436,2462,5898,17,5892,77,167,9,0,0,1114,0,2,2397,2920,740,10,13,0,0,625,2666,367,0 +1,6,ModelResultImpl,2436,2206,6460,16,6446,75,140,9,0,0,1172,0,2,2152,3275,840,10,15,0,0,658,2547,325,0 +1,7,ModelResultImpl,2436,3093,8809,20,8798,90,250,11,0,0,1647,0,3,2628,4379,1216,17,29,0,0,856,2969,312,0 +1,8,ModelResultImpl,2436,10023,15618,19,15611,97,396,26,0,0,2374,0,2,2450,8397,2603,23,30,0,0,1344,2674,348,0 +1,9,ModelResultImpl,2436,2487,7617,27,7602,71,166,9,0,0,1449,0,2,2436,3774,1098,13,16,0,0,718,2599,309,0 +1,10,ModelResultImpl,2436,2940,8028,15,8020,81,175,11,0,0,1503,0,3,2621,3974,1169,17,19,0,0,704,2860,353,0 +1,11,ModelResultImpl,2436,2607,6080,15,6070,63,113,6,0,0,1155,0,2,2407,3046,821,12,15,0,0,601,2824,266,0 +1,12,ModelResultImpl,2436,2012,5989,12,5983,69,114,7,0,0,1202,0,1,2414,2914,794,13,15,0,0,622,2686,292,0 +1,13,ModelResultImpl,2436,2331,6596,16,6589,80,139,8,0,0,1129,0,2,2354,3369,955,18,20,0,0,597,2515,273,0 +1,14,ModelResultImpl,2436,3256,7740,15,7729,90,171,11,0,1,1347,0,2,2306,3902,1147,19,25,0,0,736,2530,298,0 +1,15,ModelResultImpl,2436,2242,7267,14,7258,70,155,9,0,0,1231,0,1,2517,3649,1043,12,15,0,0,786,2753,303,0 +1,16,ModelResultImpl,2436,2466,7153,20,7143,68,145,7,0,0,1216,0,3,2388,3687,1057,11,14,0,0,644,2568,258,0 +1,17,ModelResultImpl,2436,2673,7837,16,7824,74,170,12,0,0,1297,0,2,2047,3966,1139,13,15,0,0,795,2397,324,0 +1,18,ModelResultImpl,2436,2815,9328,16,9314,107,213,10,0,0,1524,0,1,2420,4808,1314,16,19,0,0,908,2998,285,0 +1,19,ModelResultImpl,2436,2179,7559,18,7552,73,153,9,0,0,1353,0,1,2571,3738,1134,9,14,0,0,717,2764,331,0 +1,20,ModelResultImpl,2436,2145,6837,14,6826,68,141,8,0,0,1136,0,1,2266,3529,987,14,20,0,0,650,2626,276,0 +1,21,ModelResultImpl,2436,2203,6641,13,6632,68,139,8,0,0,1056,0,1,2179,3388,1015,11,25,0,0,656,2443,263,0 +1,22,ModelResultImpl,2436,2191,7014,108,7000,76,147,10,0,0,1154,0,1,2504,3571,1081,17,21,0,0,669,2681,355,0 +1,23,ModelResultImpl,2436,2276,8024,12,8017,87,160,9,0,0,1404,0,1,2582,3981,1182,15,17,0,0,818,2915,302,0 +1,24,ModelResultImpl,2436,2317,7036,12,7028,75,145,9,0,0,1245,0,1,1866,3501,953,13,19,0,0,763,2541,296,0 +1,25,ModelResultImpl,2436,2324,8080,14,8072,76,164,10,0,0,1423,0,1,2669,4059,1226,13,17,0,0,750,2922,349,0 +1,26,ModelResultImpl,2436,2299,8684,12,8676,67,176,9,0,0,1752,0,1,2738,4321,1268,10,16,0,0,714,3241,342,0 +1,27,ModelResultImpl,2436,2100,7844,12,7834,74,173,13,0,0,1305,0,1,2462,4039,1182,16,20,0,0,729,2673,334,0 +1,28,ModelResultImpl,2436,2266,7497,13,7491,62,149,9,0,0,1397,0,2,2439,3691,1089,10,14,0,0,743,2722,319,0 +1,29,ModelResultImpl,2436,2264,6602,11,6589,66,138,10,0,0,1054,0,2,2256,3400,989,11,13,0,0,663,2566,323,0 +1,30,ModelResultImpl,2436,2261,7345,13,7337,62,144,7,0,0,1304,0,1,2520,3679,1091,10,16,0,0,718,2713,238,0 +1,31,ModelResultImpl,2436,2539,6763,11,6748,74,138,8,0,0,1135,0,3,2234,3427,987,9,16,0,0,675,2502,265,0 +1,32,ModelResultImpl,2436,2257,7952,15,7940,67,161,11,0,0,1337,0,1,2584,3990,1194,10,15,0,0,838,2987,375,0 +1,33,ModelResultImpl,2436,2169,6231,11,6224,62,129,8,0,0,1082,0,1,1750,3164,864,12,14,0,0,637,2438,280,0 +1,34,ModelResultImpl,2436,2227,7685,12,7677,66,159,10,0,0,1456,0,1,2018,3784,1069,16,19,0,0,792,2742,335,0 +1,35,ModelResultImpl,2436,2110,6739,12,6726,68,139,8,0,0,1168,0,3,2406,3459,926,15,16,0,0,667,2667,260,0 +1,36,ModelResultImpl,2436,2432,9946,16,9939,77,203,10,0,0,2068,0,2,3363,4894,1406,19,20,0,0,848,3666,341,0 +1,37,ModelResultImpl,2436,2759,6376,9,6367,74,141,11,0,0,1118,0,1,2179,3217,965,20,22,0,0,581,2334,344,0 +1,38,ModelResultImpl,2436,2526,7310,12,7301,69,150,9,0,0,1283,0,2,2284,3611,1042,20,17,0,0,780,2753,315,0 +1,39,ModelResultImpl,2436,2152,6745,12,6737,69,132,8,0,0,1229,0,1,2336,3335,978,15,17,0,0,670,2522,271,0 +1,40,ModelResultImpl,2436,2439,6258,12,6249,76,139,10,0,0,1069,0,3,1881,3154,917,9,16,0,0,609,2181,307,0 +1,41,ModelResultImpl,2436,2454,6898,10,6891,61,146,9,0,0,1181,0,1,2389,3492,983,9,17,0,0,718,2672,311,0 +1,42,ModelResultImpl,2436,2155,6061,16,6054,63,125,8,0,0,1050,0,1,1936,2960,869,13,13,0,0,679,2282,299,0 +1,43,ModelResultImpl,2436,2235,7792,11,7784,84,159,10,0,0,1516,0,2,2384,3754,1110,18,16,0,0,783,2762,317,0 +1,44,ModelResultImpl,2436,2262,7389,10,7381,59,151,9,0,0,1355,0,1,2568,3683,1077,11,13,0,0,726,2787,326,0 +1,45,ModelResultImpl,2436,2134,6916,14,6907,61,138,9,0,0,1213,0,1,2418,3442,1042,12,16,0,0,692,2665,309,0 +1,46,ModelResultImpl,2436,2247,6803,12,6797,58,143,10,0,0,1100,0,1,2210,3441,1038,14,13,0,0,693,2473,354,0 +1,47,ModelResultImpl,2436,2271,6398,14,6388,70,130,8,0,0,1017,0,1,2306,3291,958,9,17,0,0,639,2565,286,0 +1,48,ModelResultImpl,2436,2183,8123,14,8113,61,166,11,0,0,1503,0,4,2742,4049,1172,12,16,0,0,807,2943,364,0 +1,49,ModelResultImpl,2436,2124,7114,12,7106,63,143,7,0,0,1210,0,1,2431,3628,1080,9,14,0,0,661,2656,267,0 +1,50,ModelResultImpl,2436,2253,6152,12,6143,66,125,7,0,0,1022,0,1,2244,3176,909,15,14,0,0,572,2439,278,0 +1,51,ModelResultImpl,2436,2103,5803,17,5794,65,124,8,0,0,1069,0,2,1785,2859,774,13,15,0,0,625,2274,286,0 +1,52,ModelResultImpl,2436,2406,6811,13,6802,69,142,9,0,0,1175,0,3,1929,3392,976,15,21,0,0,716,2489,294,0 +1,53,ModelResultImpl,2436,2198,6228,13,6215,62,126,8,0,0,1074,0,1,2108,3152,861,9,14,0,0,647,2452,310,0 +1,54,ModelResultImpl,2436,2150,9054,11,9048,61,176,8,0,0,1935,0,1,2887,4385,1240,12,15,0,0,827,3257,288,0 +1,55,ModelResultImpl,2436,2198,6914,13,6906,68,149,9,0,0,1142,0,2,2065,3549,1022,10,14,0,0,670,2623,285,0 +1,56,ModelResultImpl,2436,2109,6268,14,6258,63,134,9,0,0,996,0,1,2342,3264,946,9,14,0,0,600,2475,332,0 +1,57,ModelResultImpl,2436,2147,6410,12,6402,64,131,8,0,0,1071,0,2,2394,3283,951,13,16,0,0,606,2533,274,0 +1,58,ModelResultImpl,2436,2146,5775,14,5765,62,121,8,0,0,978,0,1,1536,2906,795,11,13,0,0,624,2300,299,0 +1,59,ModelResultImpl,2436,2238,6474,15,6467,79,138,10,0,0,1070,0,1,2337,3330,961,19,23,0,0,603,2466,337,0 +1,60,ModelResultImpl,2436,2065,8370,11,8364,58,172,8,0,0,1658,0,1,2839,4219,1119,10,13,0,0,760,3179,290,0 +1,61,ModelResultImpl,2436,2060,6616,12,6606,61,139,10,0,0,1278,0,1,2189,3266,910,10,12,0,0,664,2548,342,0 +1,62,ModelResultImpl,2436,2184,6687,13,6678,77,142,10,0,0,1227,0,1,2258,3362,950,9,16,0,0,638,2466,316,0 +1,63,ModelResultImpl,2436,2054,7579,14,7571,60,153,10,0,0,1369,0,1,2484,3740,1095,10,17,0,0,787,2860,357,0 +1,64,ModelResultImpl,2436,2129,6559,15,6549,67,135,8,0,0,1134,0,1,1896,3291,896,12,17,0,0,712,2568,297,0 +1,65,ModelResultImpl,2436,2099,7535,11,7528,60,155,10,0,0,1355,0,2,2327,3756,1125,12,14,0,0,752,2728,350,0 +1,66,ModelResultImpl,2436,2138,6999,12,6991,58,139,9,0,0,1210,0,1,2420,3522,1054,11,18,0,0,689,2657,302,0 +1,67,ModelResultImpl,2436,2066,6193,9,6183,58,132,8,0,0,1087,0,1,1754,3093,853,12,13,0,0,660,2460,305,0 +1,68,ModelResultImpl,2436,2173,7889,13,7882,75,158,10,0,0,1410,0,1,2768,3911,1151,9,16,0,0,802,2934,356,0 +1,69,ModelResultImpl,2436,2277,6903,13,6894,74,144,9,0,0,1134,0,1,2230,3498,1035,13,14,0,0,705,2608,311,0 +1,70,ModelResultImpl,2436,2115,7746,13,7738,94,151,7,0,0,1379,0,1,2873,3963,1137,18,22,0,0,642,3069,252,0 +1,71,ModelResultImpl,2436,2176,7486,11,7479,71,154,10,0,0,1294,0,1,2527,3730,1160,9,14,0,0,745,2884,332,0 +1,72,ModelResultImpl,2436,2158,7647,11,7633,62,158,9,0,0,1403,0,1,2437,3790,1121,12,19,0,0,727,2728,296,0 +1,73,ModelResultImpl,2436,2122,6465,14,6454,68,146,12,0,0,1110,0,1,1876,3265,914,12,19,0,0,671,2540,413,0 +1,74,ModelResultImpl,2436,2181,7503,12,7496,77,152,10,0,0,1396,0,1,2475,3675,1095,17,17,0,0,742,2765,345,0 +1,75,ModelResultImpl,2436,2755,6765,14,6753,68,143,9,0,0,1165,0,2,1854,3399,942,12,14,0,0,716,2408,277,0 +1,76,ModelResultImpl,2436,2208,6995,13,6986,54,139,9,0,0,1321,0,1,2271,3445,1003,13,17,0,0,700,2578,300,0 +1,77,ModelResultImpl,2436,2155,13652,14,13640,66,282,16,0,0,2511,0,2,3579,6828,1908,14,23,0,0,1441,5046,570,0 +1,78,ModelResultImpl,2436,2153,6910,12,6897,58,139,8,0,0,1172,0,2,2104,3490,1034,11,14,0,0,696,2453,262,0 +1,79,ModelResultImpl,2436,2133,6576,10,6569,62,131,7,0,0,1155,0,1,2242,3311,880,11,12,0,0,692,2629,259,0 +1,80,ModelResultImpl,2436,2107,6000,9,5990,63,132,10,0,0,1010,0,1,1891,3040,880,12,11,0,0,601,2328,373,0 +1,81,ModelResultImpl,2436,2234,7024,14,7016,64,144,8,0,0,1232,0,1,2389,3511,1024,12,14,0,0,714,2704,303,0 +1,82,ModelResultImpl,2436,2375,7166,14,7158,74,144,8,0,0,1276,0,1,2127,3549,985,18,22,0,0,773,2677,265,0 +1,83,ModelResultImpl,2436,2081,7324,10,7316,62,146,9,0,0,1275,0,1,2463,3656,1144,11,12,0,0,694,2725,335,0 +1,84,ModelResultImpl,2436,2113,6294,10,6285,58,130,8,0,0,1056,0,1,2282,3216,889,9,12,0,0,636,2505,273,0 +1,85,ModelResultImpl,2436,2183,5660,12,5653,60,120,8,0,0,972,0,1,1624,2818,756,15,14,0,0,627,2223,280,0 +1,86,ModelResultImpl,2436,2184,9069,9,9062,58,188,10,0,0,1648,0,1,3206,4670,1308,11,14,0,0,810,3517,358,0 +1,87,ModelResultImpl,2436,2180,5831,10,5825,58,125,9,0,0,907,0,1,2054,3006,831,17,18,0,0,610,2309,281,0 +1,88,ModelResultImpl,2436,2142,7243,11,7233,62,146,9,0,0,1285,0,2,2267,3620,1038,18,12,0,0,730,2716,268,0 +1,89,ModelResultImpl,2436,2316,6986,13,6974,82,146,11,0,0,1193,0,1,2190,3548,1042,13,14,0,0,677,2553,341,0 +1,90,ModelResultImpl,2436,2176,7202,9,7192,61,144,9,0,0,1234,0,1,2240,3693,1044,10,13,0,0,700,2538,272,0 +1,91,ModelResultImpl,2436,2144,6845,10,6836,59,143,11,0,0,1112,0,1,2486,3508,1059,11,11,0,0,662,2661,402,0 +1,92,ModelResultImpl,2436,2291,7195,10,7186,63,147,9,0,0,1260,0,1,2415,3753,1032,14,16,0,0,618,2841,318,0 +1,93,ModelResultImpl,2436,2318,7516,14,7506,60,147,8,0,0,1239,0,1,2558,3846,1137,11,12,0,0,729,2939,270,0 +1,94,ModelResultImpl,2436,2102,7173,11,7167,59,154,10,0,0,1264,0,2,2240,3618,1018,8,14,0,0,728,2758,363,0 +1,95,ModelResultImpl,2436,2170,6642,11,6632,67,134,8,0,0,1169,0,1,2198,3321,943,9,13,0,0,688,2491,274,0 +1,96,ModelResultImpl,2436,2289,7678,11,7669,73,160,11,0,0,1242,0,1,2521,3955,1099,21,24,0,0,765,2857,316,0 +1,97,ModelResultImpl,2436,2079,8228,12,8220,67,164,7,0,0,1435,0,1,3043,4248,1151,12,15,0,0,777,3304,246,0 +1,98,ModelResultImpl,2436,2065,6976,11,6967,59,140,9,0,0,1239,0,1,2465,3500,1037,11,13,0,0,683,2624,307,0 +1,99,ModelResultImpl,2436,2095,7581,9,7574,63,151,8,0,0,1307,0,1,2458,3811,1105,15,14,0,0,784,2769,277,0 +1,100,ModelResultImpl,2436,2164,6739,11,6729,70,138,10,0,0,1166,0,1,2144,3347,1029,11,11,0,0,684,2496,345,0 + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics_real.csv b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics_real.csv new file mode 100644 index 00000000..c60433f3 --- /dev/null +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/statistics/runtime/Github/statistics_real.csv @@ -0,0 +1,12 @@ +Task,Run,Result,Domain to logic transformation time,Logic to solver transformation time,Solver time,Postprocessing time,Solution0FoundAt,ExplorationInitializationTime,TransformationExecutionTime,ScopePropagationTime,MustRelationPropagationTime,TypeAnalysisTime,StateCoderTime,StateCoderFailCount,SolutionCopyTime,States,ForwardTime,BacktrackingTime,GlobalConstraintEvaluationTime,FitnessCalculationTime,ActivationSelectionTime,Decisions,MetricCalculationTime,Transformations,ScopePropagations,ScopePropagationsSolverCalls +1,1,ModelResultImpl,2318,8713,11477,137,11602,1015,370,38,0,386,1985,0,7,2253,4806,1639,18,16,2,0,1304,2544,230,0 +1,2,ModelResultImpl,2318,4109,9168,27,9153,143,269,18,0,0,1619,0,2,2288,4476,1242,16,22,0,0,949,2905,242,0 +1,3,ModelResultImpl,2318,5518,9272,27,9248,121,221,12,0,0,1700,0,5,2425,4417,1273,30,24,0,0,957,2881,261,0 +1,4,ModelResultImpl,2318,3405,7896,18,7888,65,175,7,0,0,1540,0,2,2413,3656,1064,11,11,0,0,875,2862,233,0 +1,5,ModelResultImpl,2318,2660,6884,21,6875,71,147,7,0,0,1363,0,1,2511,3348,849,13,14,0,0,736,3163,279,0 +1,6,ModelResultImpl,2318,3583,7557,15,7545,91,166,7,0,0,1526,0,1,2118,3585,951,16,21,1,0,788,2745,222,0 +1,7,ModelResultImpl,2318,2668,6837,13,6827,63,152,7,0,0,1265,0,2,2418,3307,885,11,9,0,0,786,2897,250,0 +1,8,ModelResultImpl,2318,3444,7171,11,7164,88,213,7,0,0,1294,0,2,1951,3560,940,14,15,0,0,741,2721,238,0 +1,9,ModelResultImpl,2318,2289,7093,20,7082,77,152,6,0,0,1311,0,2,2651,3452,1008,9,12,0,0,717,3119,258,0 +1,10,ModelResultImpl,2318,2356,7077,14,7066,68,149,6,0,0,1507,0,3,1902,3238,791,13,14,0,0,836,2939,225,0 + diff --git a/Metrics/Metrics-Calculation/SocialNetwork_plugin/yakinduGeneration.vsconfig b/Metrics/Metrics-Calculation/SocialNetwork_plugin/yakinduGeneration.vsconfig index 1cbf8469..95aa7486 100644 --- a/Metrics/Metrics-Calculation/SocialNetwork_plugin/yakinduGeneration.vsconfig +++ b/Metrics/Metrics-Calculation/SocialNetwork_plugin/yakinduGeneration.vsconfig @@ -9,16 +9,16 @@ generate { solver = ViatraSolver scope = { - #node = 30 + #node = 100 } number = 1 - runs = 10 + runs = 1 config = { log-level = none, - "optional-wf" = "false", + "optional-wf" = "true", "realistic-guidance" = "Composite", - "allow-must-violations" = "false", + "allow-must-violations" = "true", "domain" = "Yakindumm", "scopePropagator" = "typeHierarchy" } -- cgit v1.2.3-54-g00ecf