sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/kernel/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];
+    }
+
+}

sysmlpy/library/kernel/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;
+	}
+}

sysmlpy/library/kernel/StringFunctions.kerml

@@ -0,0 +1,25 @@
+standard library package StringFunctions {
+	doc
+	/*
+	 * This package defines functions on String values, including those corresponding to string concatenation 
+	 * and comparison operators in the KerML expression notation.
+	 */
+
+	public import ScalarValues::*;
+	
+	function '+' specializes ScalarFunctions::'+' { in x: String[1]; in y:String[1]; return : String[1]; }
+	
+	function Length{ in x: String[1]; return : Natural[1]; }
+	function Substring{ in x: String[1]; in lower: Integer[1]; in upper: Integer[1]; return : String[1]; }
+	
+	function '<' specializes ScalarFunctions::'<' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '>' specializes ScalarFunctions::'>' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '<=' specializes ScalarFunctions::'<=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '>=' specializes ScalarFunctions::'>=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+
+	function '==' specializes DataFunctions::'==' { in x: String[0..1]; in y: String[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: String[1];
+		return : String[1] = x;
+	}
+}

sysmlpy/library/kernel/Transfers.kerml

@@ -0,0 +1,281 @@
+standard library package Transfers {
+    doc
+    /*
+     * This package defines the transfer interactions used to type flows.
+     */
+
+    private import Base::Anything;
+    private import Occurrences::*;
+    private import Links::*;
+    private import Objects::BinaryLinkObject;
+    private import Performances::Performance;
+    private import Performances::performances;
+    private import ScalarValues::Boolean;
+    private import ScalarValues::Natural;
+    private import SequenceFunctions::*;
+    
+    interaction Transfer specializes Performance, BinaryLink {
+        doc
+        /*
+         * A Transfer represents the transfer of a payload from the source of the interaction 
+         * to the target of the interaction.
+         */
+    
+        end feature source: Occurrence redefines BinaryLink::source {
+            doc
+            /*
+             * The entity whose output is the source of the payload to be transferred.
+             */
+        
+            feature sourceOutput: Anything[0..*];
+        }
+        
+        end feature target: Occurrence redefines BinaryLink::target {
+            doc
+            /*
+             * The entity whose input is the target of the payload to be transferred.
+             */
+        
+            feature targetInput: Anything[0..*];
+        }
+        
+        feature isInstant: Boolean[1] {
+            doc
+            /*
+             * If isInstance is true, then the transfer is instantaneous.
+             */
+        }
+        
+        feature payload: Anything[1..*] {
+            doc
+            /*
+             * The things that are to be transferred.
+             */
+        }
+        
+        feature payloadNum: Natural [1] = size(payload);
+        
+        private instantNum: Natural[1] = if isInstant? 1 else 0;
+        private binding instant[instantNum] of [0..1] startShot = [0..1] endShot {
+            doc
+            /*
+             * If isInstant is true, then the start and end of the transfer happen at the same time.
+             */
+        }
+    }
+    
+    interaction MessageTransfer specializes Transfer {
+        doc
+        /*
+         * A MessageTransfer is a Transfer that does not specify where the payload is picked
+         * up and dropped off (see FlowTransfer). They are sent by SendPerformances and
+         * accepted by AcceptPerformances.
+         */
+    }
+     
+    interaction FlowTransfer specializes Transfer disjoint from MessageTransfer {
+        doc
+        /*
+         * A FlowTransfer is a Transfer identifying an output feature of the source from which
+         * to pick up a payload and an input feature of the target to which to drop it off. They can
+         * start when the payload is available at the source and move or copy it to the target.
+         */
+         
+        feature isMove: Boolean[1] default true {
+            doc
+            /*
+             * If isMove is true, then the entire payload leaves the source at the start
+             * of the transfer.
+             */
+        }
+        
+        feature isPush: Boolean[1] default true {
+            doc
+            /*
+             * If isPush is true, then the transfer begins when the payload is available
+             * at the source.
+             */
+        }
+        
+        connector sourceOutputLink: BinaryLinkObject[payloadNum] {
+            doc
+            /*
+             * The output of the payloads from the sourceOutput.
+             */
+        
+            end [1] feature transferSource references source;
+            end [payloadNum] feature transferPayload references payload subsets transferSource.sourceOutput;
+        }
+        
+        connector targetInputLink: BinaryLinkObject[payloadNum] {
+            doc
+            /*
+             * The input of the payload to the targetInput.
+             */
+        
+            end [1] feature transferTarget references target;
+            end [payloadNum] feature transferPayload references payload subsets transferTarget.targetInput;
+        }
+        
+        private connector sending: HappensDuring[payloadNum] from [1] startShot to [payloadNum] sourceOutputLink {
+          doc
+            /*
+             * The start of the transfer happens during the output of each of the payloads from the
+             * source. 
+             */
+        }
+        
+        private connector moving: HappensWhile[0..*] from [0..*] sourceOutputLink.endShot to [0..1] startShot {
+            doc
+            /*
+             * If isMove is true, then all payloads leave the source at the start
+             * of the transfer.
+             */
+        }
+        private inv { isMove implies size(moving) == size(sourceOutputLink) }
+        
+        private connector pushing: HappensWhile[0..*] from [0..*] sourceOutputLink.startShot to [0..1] startShot {
+            doc
+            /*
+             * If isPush is true, then the transfer begins when the payloads are available
+             * at the source.
+             */
+        }
+        private inv { isPush implies size(pushing) == size(sourceOutputLink) }
+        
+        private connector delivering: HappensWhile[payloadNum] from [payloadNum] targetInputLink.startShot to [1] endShot {
+            doc
+            /*
+             * The input of each of the payloads to the target starts at the end of the transfer.
+             */
+        }
+    }
+    
+    interaction TransferBefore specializes Transfer, HappensBefore intersects Transfer, HappensBefore {
+        doc
+        /*
+         * TransferBefore is a specialization of Transfer in which the source happens before
+         * the transfer, which happens before the target.
+         */
+    
+        end feature source: Occurrence redefines Transfer::source, HappensBefore::earlierOccurrence;
+        end feature target: Occurrence redefines Transfer::target, HappensBefore::laterOccurrence;
+        
+        feature self: TransferBefore redefines Performance::self;
+        
+        private succession source then self;
+        private succession self then target;
+    }
+    
+    interaction FlowTransferBefore specializes TransferBefore, FlowTransfer intersects FlowTransfer, TransferBefore {
+        doc
+        /*
+         * FlowTransferBefore is a FlowTransfer that is also a TransferBefore. 
+         */
+         
+        end feature source: Occurrence redefines Transfer::source, TransferBefore::source;
+        end feature target: Occurrence redefines Transfer::target, TransferBefore::target;         
+    }
+    
+    abstract step transfers: Transfer[0..*] nonunique subsets performances, binaryLinks {
+        doc
+        /*
+         * transfers is a specialization of performances and binaryLinks restricted to type 
+         * Transfer.
+         */
+    
+        end feature source: Occurrence redefines Transfer::source, binaryLinks::source;
+        end feature target: Occurrence redefines Transfer::target, binaryLinks::target;
+    }
+    
+    abstract step messageTransfers: MessageTransfer[0..*] nonunique subsets transfers {
+        doc
+        /*
+         * messageTransfers is a specialization of transfers restricted to type MessageTransfers.
+         */
+        
+        end feature source: Occurrence redefines MessageTransfer::source, transfers::source;
+        end feature target: Occurrence redefines MessageTransfer::target, transfers::target;      
+    }
+    
+    abstract flow flowTransfers: FlowTransfer[0..*] nonunique subsets transfers {
+        doc
+        /*
+         * flowTransfers is a specialization of transfers restricted to type FlowTransfers.
+         * It is the default subsetting for non-succession flows.
+         */
+         
+        end feature source: Occurrence redefines FlowTransfer::source, transfers::source;
+        end feature target: Occurrence redefines FlowTransfer::target, transfers::target;
+    }
+      
+    abstract flow transfersBefore: TransferBefore[0..*] nonunique subsets transfers, happensBeforeLinks
+        intersects transfers, happensBeforeLinks {
+        doc
+        /*
+         * transfersBefore is a specialization of transfers and happensBeforeLinks restricted to
+         * type TransferBefore.
+         */
+    
+        end feature source: Occurrence redefines TransferBefore::source, transfers::source, happensBeforeLinks::earlierOccurrence;
+        end feature target: Occurrence redefines TransferBefore::target, transfers::target, happensBeforeLinks::laterOccurrence;
+    }
+    
+    abstract flow flowTransfersBefore: FlowTransferBefore[0..*] nonunique subsets flowTransfers, transfersBefore
+        intersects flowTransfers, transfersBefore {
+        doc
+        /*
+         * flowTransfersBefore is a specialization of flowTransfers and transfersBefore that is restricted
+         * to type FlowTransferBefore. IT is the default subsetting for succession flows.
+         */
+    
+        end feature source: Occurrence redefines FlowTransferBefore::source, flowTransfers::source, transfersBefore::source;
+        end feature target: Occurrence redefines FlowTransferBefore::target, flowTransfers::target, transfersBefore::target;
+    }
+
+    behavior SendPerformance specializes Performance  {
+        doc
+        /*
+         * SendPerformances are Performance that require an outgoingTransferFromSelf 
+         * from a designated sender Occurrence carrying a given payload, optionally to a designated receiver.
+         */
+    
+        in feature payload [0..*];
+        in feature sender: Occurrence[1] default this;
+        in feature receiver: Occurrence[0..1];
+        feature sentTransfer: MessageTransfer [1] subsets sender.outgoingTransfersFromSelf {
+            feature redefines payload = SendPerformance::payload;
+        }
+        binding [0..1] receiver.incomingTransfersToSelf = [1] sentTransfer;
+
+        succession self then sentTransfer;
+    }
+    
+    behavior AcceptPerformance specializes Performance {
+        doc
+        /*
+         * AcceptPerformance is a performance that requires an incomingTransferToSelf
+         * of a desigated receiver Occurrence, providing its payload as output.
+         */
+        inout feature payload[0..*];
+        in feature receiver: Occurrence[1] default this;
+        feature acceptedTransfer: MessageTransfer[1] subsets receiver.incomingTransfersToSelf;
+        succession acceptedTransfer then self.endShot;
+        
+        binding payload = acceptedTransfer.payload;
+    }
+
+    abstract step sendPerformances: SendPerformance[0..*] nonunique subsets performances {
+        doc
+        /*
+         * sendPerformances is a specialization of performances for SendPerformances.
+         */
+    }
+        
+    abstract step acceptPerformances: AcceptPerformance[0..*] nonunique subsets performances {
+        doc
+        /*
+         * acceptPerformances is a specialization of performances for AcceptPerformances.
+         */
+    }
+}