sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Performances.kerml

@@ -0,0 +1,293 @@
+standard library package Performances {
+	doc
+	/*
+	 * This package defines classifiers and features that related to the typing of performances and evaluations.
+	 */
+
+	private import Base::Anything;
+	private import Base::things;
+	private import Occurrences::Occurrence;
+	private import Occurrences::occurrences;
+	private import Occurrences::HappensDuring;
+	private import Objects::Object;
+	private import Links::BinaryLink;
+	private import Metaobjects::Metaobject;
+	private import Transfers::Transfer;
+	private import Transfers::transfers;
+	private import Transfers::TransferBefore;
+	private import Transfers::transfersBefore;
+	private import ScalarValues::*;
+	private import SequenceFunctions::includes;
+	
+	abstract behavior Performance specializes Occurrence disjoint from Object {
+		doc
+		/*
+		 * Performance is the most general class of behavioral Occurrences that may be performed over time.
+		 */
+
+		feature self: Performance redefines Occurrence::self;
+		
+		feature involvedObjects: Object[0..*] {
+			doc
+			/*
+			 * Objects that are involved in this Performance.
+			 */
+		}
+		
+		feature performers: Object[0..*] subsets involvedObjects {
+			doc
+			/*
+			 * Objects that enact this Performance.
+			 */
+		}
+		
+		feature redefines isDispatch default true;
+  		feature redefines dispatchScope default thisPerformance;
+  		
+		step enclosedPerformances: Performance[0..*] subsets performances, timeEnclosedOccurrences
+			intersects performances, timeEnclosedOccurrences {
+			doc
+			/*
+			 * timeEnclosedOccurrences of this Performance that are also Performances.
+			 */
+		}
+		
+		feature thisPerformance: Performance [1] default self {
+			doc
+			/*
+			 * Defaults to the root of the subperformance composition tree.
+			 */
+		}
+		connector :HappensDuring from [1] self to [1] thisPerformance; 
+		
+		composite step subperformances: Performance[0..*] subsets enclosedPerformances, suboccurrences
+			intersects enclosedPerformances, suboccurrences {
+			doc
+			/*
+			 * enclosedPerformances that are composite. 
+			 */
+		
+			feature redefines this default (that as Performance).this {
+				doc
+				/*
+				 * The default "this" context of a subperformance is the same as that of its owning Performance.
+				 * This means that the context for any Performance that is in a composition tree rooted
+				 * in a Performance that is not itself owned by an Object is the root Performance. If the
+				 * root Performance is an ownedPerformance of an Object, then that Object is the context.
+				 */
+			}
+		
+			feature redefines thisPerformance default (that as Performance).thisPerformance;
+		}		
+	}
+	
+	abstract function Evaluation specializes Performance {
+		doc
+		/*
+		 * Evaluation is the most general class of functions that may be evaluated to compute
+		 * a result.
+		 */
+	 
+		return result: Anything[0..*] nonunique;
+	}
+	
+	abstract predicate BooleanEvaluation specializes Evaluation {
+		doc
+		/*
+		 * BooleanEvaluation is a specialization of Evaluation that is the most general class of
+		 * Predicates that may be evaluated to produce a Boolean truth value.
+		 */
+	 
+		return : Boolean[1];
+	}
+	
+	abstract function MetadataAccessEvaluation specializes Evaluation {
+		doc
+		/*
+		 * MetadataAccessEvaluation is a specialization of Evaluation for the case of MetadataAccessExpressions.
+		 */
+		
+		return : Metaobject[1..*];
+	}
+	
+	abstract function LiteralEvaluation specializes Evaluation {
+		doc
+		/*
+		 * LiteralEvaluation is a specialization of Evaluation for the case of LiteralExpressions.
+		 */
+	 
+		return : ScalarValue[1];
+	}
+	
+	abstract predicate LiteralBooleanEvaluation specializes LiteralEvaluation, BooleanEvaluation
+		intersects LiteralEvaluation, BooleanEvaluation {
+		doc
+		/*
+		 * LiteralBooleanEvaluation is a specialization of LiteralEvaluation for the case of LiteralBooleans.
+		 * It is also a predicate and thus a specialization of BooleanEvaluation. 
+		 */
+	 
+		return : Boolean[1];
+	}
+	abstract function LiteralIntegerEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralIntegerEvaluation is a specialization of LiteralEvaluation for the case of LiteralIntegers.
+		 */
+	 
+		return : Integer[1];
+	}
+
+	abstract function LiteralRationalEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralRationalEvaluation is a specialization of LiteralEvaluation for the case of LiteralRationals.
+		 * (Note: Return type is Real to allow easy type conformance of LiteralRationals when a Real result is expected.)
+		 */
+	 
+		return : Real[1];
+	}
+	
+	abstract function LiteralStringEvaluation specializes LiteralEvaluation {
+		doc
+		/*
+		 * LiteralStringEvaluation is a specialization of LiteralEvaluation for the case of LiteralStrings.
+		 */
+	 
+		return : String[1];
+	}
+	
+	function NullEvaluation specializes Evaluation {
+		doc
+		/*
+		 * NullEvaluation is a specialization of Evaluation for the case of NullExpressions.
+		 */
+	 
+		return : Anything[0..0];
+	}
+
+	assoc all InvolvedIn specializes BinaryLink { 
+		doc
+		/*
+		 * InvolvedIn asserts that the involvedObject is involved in the Behavior carried out by the 
+		 * involvingPerformance.
+		 */
+		 
+		end feature involvedObject: Object redefines source crosses involvingPerformance.involvedObjects;
+		end feature involvingPerformance: Performance redefines target crosses involvedObject.involvingPerformances;
+	}
+	
+	assoc all Performs specializes InvolvedIn {
+		doc
+		/*
+		 * Performs asserts that the performer enacts the Behavior carried out by the performance.
+		 */
+	
+	 	end feature performerObject: Object redefines involvedObject crosses performance.performers;
+	 	end feature performance: Performance redefines involvingPerformance crosses performerObject.enactedPerformances;
+	 }
+
+	abstract step performances: Performance[0..*] nonunique subsets occurrences {
+		doc
+		/*
+		 * performances is the most general feature for performances of Behaviors.
+		 */
+	}
+	
+	abstract expr evaluations: Evaluation[0..*] nonunique subsets performances {
+		doc
+		/*
+		 * evaluations is a specialization of performances for evaluations of Functions.
+		 */
+	}
+	
+	abstract expr constructorEvaluations [0..*] nonunique subsets evaluations  {
+	    doc
+	    /*
+	     * constructorEvaluations is a specialization of evaluations that restricts the multiplicity 
+	     * of its result parameter to 1..1, requiring a constructorEvaluation to result in a single value.
+	     */
+	     
+	     return result [1..1];
+	}
+	
+	abstract expr booleanEvaluations: BooleanEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * booleanEvaluations is a specialization of evaluations restricted to type BooleanEvaluation.
+		 */
+	}
+	
+	abstract expr trueEvaluations subsets booleanEvaluations {
+		doc
+		/*
+		 * trueEvaluations is a subset of booleanEvaluations that result in true. It is the most general
+		 * feature of invariants that are not negated. 
+		 */
+	
+		private feature trueValue = true;
+		binding result = trueValue;
+	}
+	
+	abstract expr falseEvaluations subsets booleanEvaluations {
+		doc
+		/*
+		 * falseEvaluations is a subset of booleanEvaluations that result in false. It is the most general
+		 * feature of invariants that are negated.
+		 */
+	
+        private feature falseValue = false;
+        binding result = falseValue;
+	}
+	
+	abstract expr metadataAccessEvaluations: MetadataAccessEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * metadataAccessEvaluations is a specialization of evaluations restricted to type MetadataAccessEvaluation. 
+		 */
+	}
+	
+	abstract expr literalEvaluations: LiteralEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.
+		 */
+	}
+	
+	abstract expr literalBooleanEvaluations: LiteralBooleanEvaluation[0..*] nonunique subsets literalEvaluations, booleanEvaluations
+		intersects literalEvaluations, booleanEvaluations {
+		doc
+		/*
+		 * literaBooleanlEvaluations is a specialization of literalEvaluations and booleanEvaluations restricted 
+		 * to type LiteralBooleanEvaluation.
+		 */
+	}
+	
+	abstract expr literalIntegerEvaluations: LiteralIntegerEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.
+		 */
+	}
+	
+	abstract expr literalRationalEvaluations: LiteralRationalEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalRationalEvaluations is a specialization of literalEvaluations restricted to type LiteralRationalEvaluation.
+		 */
+	}
+	
+	abstract expr literalStringEvaluations: LiteralStringEvaluation[0..*] nonunique subsets literalEvaluations {
+		doc
+		/*
+		 * literalStringEvaluations is a specialization of literalEvaluations restricted to type LiteralStringEvaluation.
+		 */
+	}
+	
+	abstract expr nullEvaluations: NullEvaluation[0..*] nonunique subsets evaluations {
+		doc
+		/*
+		 * nullEvaluations is a specialization of evaluations restricted to type NullEvaluation.
+		 */
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/SpatialFrames.kerml

@@ -0,0 +1,197 @@
+standard library package SpatialFrames {
+    doc
+    /*
+     * This package models spatial frames of reference for quantifying the position of points 
+     * in a three-dimensional space. 
+     */
+
+    private import Clocks::*;
+    private import ScalarValues::NumericalValue;
+    private import VectorValues::ThreeVectorValue;
+    private import VectorValues::CartesianThreeVectorValue;
+    private import VectorFunctions::isZeroVector;
+    private import Occurrences::Life;
+    private import Objects::Body;
+    private import Objects::Point;
+    private import ControlFunctions::forAll;
+    private import SequenceFunctions::includes;
+    
+    private struct DefaultFrameLife[1] :> SpatialFrame, Life {
+        doc
+        /*
+         * DefaultFrameLife is the classifier of the singleton Life of the defaultFrame.
+         */
+    }
+    
+    feature defaultFrame : DefaultFrameLife[1] {
+        doc
+        /*
+         * defaultFrame is a fixed SpatialFrame used as a universal default.
+         */
+    }
+    
+    abstract struct SpatialFrame specializes Body {
+        doc
+        /*
+         * A SpatialFrame is a three-dimensional Body that provides a spatial extent that 
+         * acts as a frame of reference for defining the physical position and displacement 
+         * vectors of Points over time.
+         */
+    }
+    
+    abstract function PositionOf {
+        doc
+        /*
+         * The PositionOf a Point relative to a SpatialFrame, at a specific time relative to a given
+         * Clock, as a positionVector that is a ThreeVectorValue.
+         */
+    
+        in point : Point[1];
+        in time : NumericalValue[1];
+        in frame : SpatialFrame[1] default defaultFrame;
+        in clock : Clock[1] default frame.localClock;
+        return positionVector : ThreeVectorValue[1];
+        
+        inv positionTimePrecondition {
+            doc
+            /*
+             * The given point must exist at the given time.
+             */
+        
+            TimeOf(point.startShot) <= time and
+            time <= TimeOf(point.endShot)
+        }
+        
+        inv spacePositionConstraint {
+            doc
+            /*
+             * The result positionVector is equal to the PositionOf the Point spaceShot of the
+             * frame that encloses the given point, at the given time.
+             */
+        
+            (frame.spaceShots as Point)->forAll{in p : Point;
+                p.spaceTimeEnclosedOccurrences->includes(point) implies
+                    positionVector == PositionOf(p, time, frame)
+            }
+        }
+    }
+    
+    abstract function CurrentPositionOf {
+        doc
+        /*
+         * The CurrentPositionOf a Point relative to a SpatialFrame and a Clock is the PositionOf
+         * the Point relative to the SpatialFrame at the currentTime of the Clock.
+         */
+    
+        in point : Point[1];
+        in frame : SpatialFrame[1] default defaultFrame;
+        in clock : Clock[1] default frame.localClock;
+        return positionVector : ThreeVectorValue[1] =
+            PositionOf(point, clock.currentTime, frame, clock);
+    }
+        
+    function DisplacementOf {
+        doc
+        /*
+         * The DisplacementOf two Points relative to a SpatialFrame, at a specific time relative to a
+         * given Clock, is the displacementVector computed as the difference between the PositionOf the 
+         * first Point and PositionOf the second Point, relative to that SpatialFrame, at that time.
+         */
+    
+        in point1 : Point[1];
+        in point2 : Point[1];
+        in time : NumericalValue;
+        in frame : SpatialFrame[1] default defaultFrame;
+        in clock : Clock[1] default frame.localClock;
+        return displacementVector : ThreeVectorValue[1] =
+            PositionOf(point2, time, frame, clock) - PositionOf(point1, time, frame, clock);
+            
+        inv zeroDisplacementConstraint {
+        doc
+        /*
+         * If either point1 or point2 occurs within the other, then the displacementVector is
+         * the zero vector.
+         */
+        
+            (point1.spaceTimeEnclosedOccurrences->includes(point2) or
+            point2.spaceTimeEnclosedOccurrences->includes(point1)) implies
+                isZeroVector(displacementVector)
+        }
+    }
+    
+    function CurrentDisplacementOf {
+        doc
+        /*
+         * The CurrentDisplacementOf two Points relative to a SpatialFrame and Clock is the DisplacementOf
+         * the Points relative to the SpatialFrame at the currentTime of the Clock.
+         */
+    
+        in point1 : Point[1];
+        in point2 : Point[1];
+        in frame : SpatialFrame[1] default defaultFrame;
+        in clock : Clock[1] default frame.localClock;
+        return displacementVector : ThreeVectorValue[1] =
+            DisplacementOf(point1, point2, clock.currentTime, frame, clock);
+    }
+    
+    abstract struct CartesianSpatialFrame :> SpatialFrame {
+        doc
+        /*
+         * A CartesianSpatialFrame is a SpatialFrame relative to which all position and displacement
+         * vectors can be represented as CartesianThreeVectorValues.
+         */
+    }
+    
+    abstract function CartesianPositionOf :> PositionOf {
+        doc
+        /*
+         * The PositionOf a Point relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.
+         */
+    
+        in point : Point[1];
+        in time : NumericalValue[1];
+        in frame : CartesianSpatialFrame[1];
+        in clock : Clock[1] default frame.localClock;
+        return positionVector : CartesianThreeVectorValue[1];
+    }
+    
+    abstract function CartesianCurrentPositionOf :> CurrentPositionOf {
+        doc
+        /*
+         * The CurrentPositionOf a Point relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.
+         */
+    
+        in point : Point[1];
+        in frame : CartesianSpatialFrame[1];
+        in clock : Clock[1] default frame.localClock;
+        return positionVector : CartesianThreeVectorValue[1];
+    }
+    
+    function CartesianDisplacementOf :> DisplacementOf {
+        doc
+        /*
+         * The DisplacementOf two Points relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.
+         */
+    
+        in point1 : Point[1];
+        in point2 : Point[1];
+        in time : NumericalValue[1];
+        in frame : CartesianSpatialFrame[1];
+        in clock : Clock[1] default frame.localClock;
+        return displacementVector : CartesianThreeVectorValue[1];
+    }
+        
+    function CartesianCurrentDisplacementOf :> CurrentDisplacementOf {
+        doc
+        /*
+         * The CurrentDisplacementOf two Points relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.
+         */
+    
+        in point1 : Point[1];
+        in point2 : Point[1];
+        in frame : CartesianSpatialFrame[1];
+        in clock : Clock[1] default frame.localClock;
+        return displacementVector : CartesianThreeVectorValue[1];
+    }
+
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/StatePerformances.kerml

@@ -0,0 +1,145 @@
+standard library package StatePerformances {
+	doc
+	/*
+	 * This package contains a library model of the semantics of state-based behavior,
+	 * including the performance of (behavioral) states and the transitions between them.
+	 */
+
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Natural;
+	private import TransitionPerformances::TransitionPerformance;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensDuring;
+	private import Transfers::Transfer;
+	private import Transfers::MessageTransfer;
+	private import Performances::Performance;
+	private import ControlPerformances::DecisionPerformance;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::select;
+	private import ControlFunctions::collect;
+	private import SequenceFunctions::*;
+	
+	behavior StatePerformance specializes DecisionPerformance {
+		feature isTriggerDuring: Boolean default true;
+
+		abstract step middle[1..*] {
+			doc
+			/*
+			 * All modeler-defined steps must subset this.
+			 */
+		}
+		
+		/* 
+		 * Note: All steps are implicitly considered to be enclosedPerformances,
+		 * and hence happening during the state performance.
+		 */
+		
+		step entry[1];
+		step do[1] subsets middle;
+		step exit[1];
+		
+		step nonDoMiddle[*] subsets middle = middle->excluding(do);
+
+		private succession [1] entry then [*] middle;
+		private succession [1] do.startShot then [*] nonDoMiddle.startShot;
+		private succession [*] middle then [1] exit;
+
+
+		feature incomingTransitionTrigger : MessageTransfer [0..1] default null {
+			doc
+			/*
+			 * Transfer that triggered a transition into this state performance. 
+			 */
+		}
+
+		private inv { isEmpty(accepted) == isEmpty(acceptable) }
+		feature accepted: Transfer[0..1] subsets acceptable {
+			doc
+			/* A transfer to the trigger target of an outgoing transition performance
+			 * for an outgoing successon that is taken for this state occurrence.
+			 */
+		}
+		feature deferrable: Transfer[0..*] subsets acceptable {
+			doc
+			/* Transfers to trigger targets of outgoing transition performances can be
+			 * considered for acceptance more than once.
+			 */
+		}
+		abstract feature acceptable: Transfer[*] {
+			doc
+			/*
+			 * Transfers that might be accepted. 
+			 */
+			feature thatSP : StatePerformance [1] = that as StatePerformance;
+			feature accableT : Transfer redefines self;
+			feature accT : Transfer = thatSP.accepted;
+			inv { accableT == accT | incomingTransferSort(accT, accableT) }  
+			inv { isDispatch implies
+				     allSubstatePerformances(dispatchScope)->forAll{in oSP : StatePerformance;						
+						  oSP == thatSP | isEmpty(oSP.accepted) |
+	   					  includes(thatSP.exit.startShot.successors, oSP.exit.startShot) |
+						  ( oSP.accepted != accableT & 
+							( incomingTransferSort(oSP.accepted, accableT) |
+							  includes(oSP.deferrable, accableT) ) ) } }
+		}
+		
+		function allSubstatePerformances {
+			in p : Performance [1];
+			feature substatePerformances: StatePerformance [*] =
+				p.subperformances->select{in subp:Performance; subp istype StatePerformance};
+			return  : StatePerformance [*] =
+				union(substatePerformances,  
+					  substatePerformances->collect{in sp:StatePerformance; allSubstatePerformances(sp) } );
+		}
+		
+		private succession [*] acceptable then [1] exit;
+		
+		feature redefines isRunToCompletion default this.isRunToCompletion;
+		feature redefines runToCompletionScope default this.runToCompletionScope; 
+		inv { isRunToCompletion implies
+			     allSubtransitionPerformances(runToCompletionScope)->forAll{in tp : TransitionPerformance;
+				    includes(tp.successors, entry) | includes(tp.predecessors, entry) }
+		}
+		
+		function allSubtransitionPerformances {
+			in p : Performance [1];
+			feature subtransitionPerformances: TransitionPerformance [*] =
+	 			 p.subperformances->select{in subp:Performance;
+		 			   subp istype StateTransitionPerformance };
+			return  : TransitionPerformance [*] =
+				union(subtransitionPerformances,  
+		      		subtransitionPerformances->collect{in sp:TransitionPerformance; 
+							 		allSubtransitionPerformances(sp) } ); 
+ 		}
+	}
+	
+	behavior StateTransitionPerformance specializes TransitionPerformance {
+		feature isTriggerDuring: Boolean[1];
+		inv { not transitionLinkSource.isTriggerDuring | isTriggerDuring  }
+
+		in feature transitionLinkSource: StatePerformance redefines TransitionPerformance::transitionLinkSource {
+			feature redefines accepted;
+			feature redefines StatePerformance::acceptable;
+		}
+		private succession [*] transitionLinkSource.nonDoMiddle then [1] Performance::self;
+
+		private feature transitionLinkTarget [0..1] : Occurrence = transitionLink.laterOccurrence {
+			inv { (that istype StatePerformance) implies
+			      (that as StatePerformance).incomingTransitionTrigger == trigger }
+		}
+		
+		feature acceptable: Transfer [*] subsets transitionLinkSource.acceptable, triggerTarget.incomingTransfersToSelf;
+
+		feature trigger redefines TransitionPerformance::trigger subsets acceptable, transitionLinkSource.accepted {
+			feature redefines endShot;
+		}
+		
+		private feature tdNum: Natural [1] = if not isTriggerDuring ? 0 else size(trigger);
+		private connector linkTriggerDuring: HappensDuring[tdNum] from [*] trigger.endShot to [0..1] transitionLinkSource;
+		
+		private succession all [*] acceptable then [*] guard;
+		private succession [*] guard then [1] transitionLinkSource.exit;
+
+		private succession [accNum] accept then [1] transitionLinkSource.exit;
+	}
+}