sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Geometry/SpatialItems.sysml

@@ -0,0 +1,168 @@
+standard library package SpatialItems {
+	doc
+	/*
+	 * This package models physical items that have a spatial extent and act as a spatial frame of reference
+	 * for obtaining position and displacement vectors of points within them.
+	 */
+
+	private import Objects::Point;
+	private import SpatialFrames::SpatialFrame;
+	private import Quantities::VectorQuantityValue;
+	private import MeasurementReferences::ThreeDCoordinateFrame;
+	private import MeasurementReferences::nullTransformation;
+	private import Time::Clock;
+	private import Time::TimeInstantValue;
+	private import ScalarValues::Natural;
+	private import ISQ::universalCartesianSpatial3dCoordinateFrame;
+	private import ISQ::Position3dVector;
+	private import ISQ::Displacement3dVector;
+	private import VectorFunctions::isZeroVector;
+	private import SequenceFunctions::isEmpty;
+	private import ControlFunctions::forAll;
+	
+	item def SpatialItem :> SpatialFrame {
+		doc
+		/*
+		 * A SpatialItem is an Item with a three-dimensional spatial extent that also acts as a SpatialFrame of reference.
+		 */
+	
+		ref item :>> localClock : Clock[1] default Time::universalClock {
+			doc
+			/*
+			 * A local Clock to be used as the corresponding time reference within this SpatialItem. 
+			 * By default this is the singleton universalClock.
+			 */
+		}
+		
+		attribute coordinateFrame : ThreeDCoordinateFrame[1] default universalCartesianSpatial3dCoordinateFrame {
+            doc
+            /*
+             * The three-dimensional CoordinateFrame to be used as the measurement reference for position 
+             * and displacement vector values relative to this SpatialItem.
+             * By default this is the singleton universalCartesianSpatial3dCoordinateFrame.
+             */
+        }
+        		
+		item originPoint : Point[1] :> spaceShots {
+			doc
+			/*
+			 * The Point at the origin of the coordinateFrame of this SpatialItem.
+			 */
+		}
+		
+		assert constraint originPointConstraint {
+			doc
+			/*
+			 * The CurrentPositionOf the originPoint must always be a zero vector.
+			 */
+		
+			isZeroVector(CurrentPositionOf(originPoint, that))
+		}
+
+        item subSpatialItems : SpatialItem[1..*] :> subitems {
+            ref item :>> SpatialItem::localClock, subitems::localClock;
+        }
+        
+        part subSpatialParts : SpatialItem[1..*] :> subSpatialItems, subparts {
+            ref item :>> SpatialItem::localClock, subSpatialItems::localClock, subparts::localClock;
+        }
+
+		item componentItems : SpatialItem[1..*] :> subSpatialItems {
+			doc
+			/*
+			 * A SpatialItem with componentItems is entirely made up of those items (the SpatialItem occurs only
+			 * as a collection of its componentItems).  By default they have the same localClock and equivalent
+			 * coordinate frame as the SpatialItem they make up.  A SpatialItem without componentItems occurs
+			 * on its own, separately from its subitems.
+			 */		
+			ref item :>> SpatialItem::localClock, subSpatialItems::localClock default (that as SpatialItem).localClock;
+			attribute :>> coordinateFrame {
+				attribute :>> mRefs default (that.that as SpatialItem).coordinateFrame.mRefs;
+				attribute :>> transformation[1] default nullTransformation {
+					attribute :>> source default (that.that.that as SpatialItem).coordinateFrame;
+				}
+			}
+		}
+
+		private attribute cunionNum: Natural [1] = if isEmpty(componentItems) ? 0 else 1;
+		private attribute componentUnion[cunionNum] :> unionsOf {
+			doc
+			/*
+			 * A SpatialItem with componentItems is is a spatial union of them.
+			 */
+		
+			item :>> elements : SpatialItem [1..*] = componentItems;
+		}
+		
+		part componentParts : SpatialItem[1..*] :> componentItems, subSpatialParts {
+		    ref item :>> SpatialItem::localClock, componentItems::localClock, subSpatialParts::localClock, subparts::localClock;
+		}
+	}
+
+	calc def PositionOf :> SpatialFrames::PositionOf {
+		doc
+		/*
+		 * The PositionOf a Point relative to a SpatialItem, at a specific TimeInstantValue relative to a given Clock,
+		 * is a positionVector that is a VectorQuantityValue in the coordinateFrame of the SpatialItem.
+		 * The default Clock is the localClock of the SpatialItem.
+		 */
+	
+		in point : Point[1];
+		in timeInstant : TimeInstantValue[1];
+		in enclosingItem :>> 'frame' : SpatialItem[1];
+		in clock : Clock[1] default enclosingItem.localClock;
+		return positionVector : Position3dVector[1] {
+			attribute :>> mRef = enclosingItem.coordinateFrame;
+		}
+	}
+
+	calc def CurrentPositionOf :> SpatialFrames::CurrentPositionOf {
+		doc
+		/*
+		 * The CurrentPositionOf a Point relative to a SpatialItem and a Clock is the PositionOf
+		 * the Point relative to the SpatialItem at the currentTime of the Clock.
+		 */
+	
+		in point : Point[1];
+		in enclosingItem :>> 'frame' : SpatialItem[1];
+		in clock : Clock[1] default enclosingItem.localClock;
+		return positionVector : Position3dVector[1] {
+			attribute :>> mRef = enclosingItem.coordinateFrame;
+		}
+	}
+
+	calc def DisplacementOf :> SpatialFrames::DisplacementOf {
+		doc
+		/*
+		 * The DisplacementOf two Points relative to a SpatialItem, at a specific TimeInstantValue 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 SpatialItem, at that timeInstant.
+		 */
+	
+		in point1 : Point[1];
+		in point2 : Point[1];
+		in timeInstant : TimeInstantValue[1];
+		in spatialItem :>> 'frame' : SpatialItem[1];
+		in clock : Clock[1] default spatialItem.localClock;
+		return displacementVector : Displacement3dVector[1] {
+			attribute :>> mRef = spatialItem.coordinateFrame;
+		}
+	}
+
+	calc def CurrentDisplacementOf :> SpatialFrames::CurrentDisplacementOf {
+		doc
+		/*
+		 * The CurrentDisplacementOf two Points relative to a SpatialItem and a Clock is the DisplacementOf
+		 * the Points relative to the SpatialItem, at the currentTime of the Clock.
+		 */
+	
+		in point1 : Point[1];
+		in point2 : Point[1];
+		in spatialItem :>> 'frame' : SpatialItem[1];
+		in clock : Clock[1] default spatialItem.localClock;
+		return displacementVector : Displacement3dVector[1] {
+			attribute :>> mRef = spatialItem.coordinateFrame;
+		}
+	}
+
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/.meta.json

@@ -0,0 +1,10 @@
+{
+  "index": {
+    "ImageMetadata": "ImageMetadata.sysml",
+    "ModelingMetadata": "ModelingMetadata.sysml",
+    "ParametersOfInterestMetadata": "ParametersOfInterestMetadata.sysml",
+    "RiskMetadata": "RiskMetadata.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/.project.json

@@ -0,0 +1,19 @@
+{
+  "name": "SysML Metadata Library",
+  "version": "2.0.0",
+  "description": "Standard metadata domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/ImageMetadata.sysml

@@ -0,0 +1,78 @@
+standard library package ImageMetadata {
+	doc
+	/*
+	 * This package provides attributive data and metadata to allow a model element to be
+	 * annotated with an image to be used in its graphical rendering or as a marker to
+	 * adorn graphical or textual renderings.
+	 */
+	 
+	private import ScalarValues::String;
+	
+	attribute def Image {
+		doc
+		/*
+		 * Image provides the data necessary for the physical definition of 
+		 * a graphical image.
+		 */
+		 
+		attribute content : String[0..1] {
+			doc
+			/*
+			 * Binary data for the image according to the given MIME type, 
+			 * encoded as given by the encoding.
+			 */
+		}
+		
+		attribute encoding : String[0..1] {
+			doc
+			/*
+			 * Describes how characters in the content are to be decoded into 
+			 * binary data. At least "base64", "hex", "identify", and "JSONescape"
+			 * shall be supported.
+			 */
+		}
+		
+		attribute type : String[0..1] {
+			doc
+			/*
+			 * The MIME type according to which the content should be interpreted.
+			 */
+		}
+		
+		attribute location : String[0..1] {
+			doc
+			/*
+			 * A URI for the location of a resource containing the image content,
+			 * as an alternative for embedding it in the content attribute.
+			 */
+		}
+	}
+	
+	metadata def Icon {
+		doc
+		/*
+		 * Icon metadata can be used to annotate a model element with an image to be used
+		 * to show render the element on a diagram and/or a small image to be used as an
+		 * adornment on a graphical or textual rendering. Alternatively, another metadata
+		 * definition can be annotated with an Icon to indicate that any model element 
+		 * annotated by the containing metadata can be rendered according to the Icon.
+		 */
+		 
+		attribute fullImage : Image[0..1] {
+			doc
+			/*
+			 * A full-sized image that can be used to render the annotated element on a
+			 * graphical view, potentially as an alternative to its standard rendering.
+			 */
+		}
+		
+		attribute smallImage : Image[0..1] {
+			doc
+			/*
+			 * A smaller image that can be used as an adornment on the graphical rendering
+			 * of the annotated element or as a marker in a textual rendering.
+			 */
+		}
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/ModelingMetadata.sysml

@@ -0,0 +1,143 @@
+standard library package ModelingMetadata {
+	doc
+	/*
+	 * This package contains definitions of metadata generally useful for annotating models.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::String;
+	private import RiskMetadata::Risk;
+	
+	enum def StatusKind {
+		doc
+		/*
+		 * StatusKind enumerates the possible statuses of work on a model element.
+		 */
+	
+		open {
+			doc
+			/*
+			 * Status is open.
+			 */
+		}
+		
+		tbd {
+			doc
+			/*
+			 * Status is to be determined.
+			 */
+		}
+		
+		tbr {
+			doc
+			/*
+			 * Status is to be resolved.
+			 */
+		}
+		
+		tbc {
+			doc
+			/*
+			 * Status is to be confirmed.
+			 */
+		}
+		
+		done {
+			doc
+			/*
+			 * Status is done.
+			 */
+		}
+		
+		closed {
+			doc
+			/*
+			 * Status is closed.
+			 */
+		}
+	}
+	
+	metadata def StatusInfo {
+		doc
+		/*
+		 * StatusInfo is used to annotate a model element with status information.
+		 */
+	
+		attribute originator : String [0..1] {
+			doc
+			/*
+			 * The originator of the annotated element.
+			 */
+		}
+		
+		attribute owner : String [0..1] {
+			doc
+			/*
+			 * The current owner of the annotated element.
+			 */
+		}
+		
+		attribute status : StatusKind {
+			doc
+			/*
+			 * The current status of work on the annotated element (required).
+			 */
+		}
+		
+		item risk : Risk [0..1] {
+			doc
+			/*
+			 * An assessment of risk for the annotated element.
+			 */
+		}
+	}
+	
+	metadata def Rationale {
+		doc
+		/*
+		 * Rationale is used to explain a choice or other decision made related to the
+		 * annotated element.
+		 */
+	
+		attribute text : String {
+			doc
+			/*
+			 * A textual description of the rationale (required).
+			 */
+		}
+		
+		ref explanation : Anything [0..1] {
+			doc
+			/*
+			 * A reference to a feature that provides a formal explanation of the rationale.
+			 * (For example, a trade study whose result explains the choice of a certain alternative).
+			 */
+		}
+	}
+	
+	metadata def Issue {
+		doc
+		/*
+		 * Issue is used to record some issue concerning the annotated element.
+		 */
+	
+		attribute text : String {
+		doc
+		/*
+		 * A textual description of the issue.
+		 */
+		}
+	}
+	
+	metadata def <refinement> Refinement {
+		doc
+		/*
+		 * Refinement is used to identify a dependency as modeling a refinement relationship.
+		 * In such a relationship, the source elements of the relationship provide a more precise and/or 
+		 * accurate representation than the target elements.
+		 */
+	
+		:>> annotatedElement : SysML::Dependency;
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/ParametersOfInterestMetadata.sysml

@@ -0,0 +1,39 @@
+standard library package ParametersOfInterestMetadata {
+	doc
+	/*
+	 * This package contains definitions of metadata to identify key parameters of interest,
+	 * including measures of effectiveness (MOE) and other key measures of performance (MOP).
+	 */
+	 
+	 private import Metaobjects::SemanticMetadata;
+	 
+	 attribute measuresOfEffectiveness[*] nonunique {
+	 	doc /* Base feature for attributes that are measures of effectiveness. */
+	 }
+	 
+	 attribute measuresOfPerformance[*] nonunique {
+	 	doc /* Base feature for attributes that are measures of performance. */
+	 }
+	 
+	 metadata def <moe> MeasureOfEffectiveness :> SemanticMetadata {
+	 	doc 
+	 	/*
+	 	 * MeasureOfEffectiveness is semantic metadata for identifying an attribute as a
+	 	 * measure of effectiveness.
+	 	 */
+	 	
+	 	:>> annotatedElement : SysML::Usage;
+	 	:>> baseType = measuresOfEffectiveness meta SysML::Usage;
+	 }
+	 
+	 metadata def <mop> MeasureOfPerformance :> SemanticMetadata {
+	 	doc 
+	 	/*
+	 	 * MeasureOfPerformance is semantic metadata for identifying an attribute as a
+	 	 * measure of performance.
+	 	 */
+	 	
+	 	:>> annotatedElement : SysML::Usage;
+	 	:>> baseType = measuresOfPerformance meta SysML::Usage;
+	 }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Metadata/RiskMetadata.sysml

@@ -0,0 +1,100 @@
+standard library package RiskMetadata {
+	doc
+	/*
+	 * This package defines metadata for annotating model elements with assessments of risk.
+	 */
+
+	private import ScalarValues::Real;
+	
+	attribute def Level :> Real {
+		doc
+		/*
+		 * A Level is a Real number in the interval 0.0 to 1.0, inclusive.
+		 */
+	
+		assert constraint { that >= 0.0 and that <= 1.0 }
+	}
+	
+	enum def LevelEnum :> Level {
+		doc
+		/*
+		 * LevelEnum provides standard probability Levels for low, medium and high risks.
+		 */
+	
+		low = 0.25;
+		medium = 0.50;
+		high = 0.75;
+	}
+
+	attribute def RiskLevel {
+		doc
+		/*
+		 * RiskLevel gives the probability of a risk occurring and, optionally, the impact
+		 * if the risk occurs.
+		 */
+	
+		attribute probability : Level {
+			doc
+			/*
+			 * The probability that a risk will occur.
+			 */
+		}
+		
+		attribute impact : Level [0..1] {
+			doc
+			/*
+			 * The impact of the risk if it occurs (with 0.0 being no impact and 1.0 being 
+			 * the most severe impact).
+			 */
+		}
+	}
+	
+	enum def RiskLevelEnum :> RiskLevel {
+		doc
+		/*
+		 * RiskLevelEnum enumerates standard RiskLevels for low, medium and high risks
+		 * (without including impact).
+		 */
+
+		low = new RiskLevel(probability = LevelEnum::low);
+		medium = new RiskLevel(probability = LevelEnum::medium);
+		high = new RiskLevel(probability = LevelEnum::high);
+	}
+	
+	metadata def Risk {
+		doc
+		/*
+		 * Risk is used to annotate a model element with an assessment of the risk related to it
+		 * in some typical risk areas.
+		 */
+	
+		attribute totalRisk : RiskLevel [0..1] {
+			doc
+			/*
+			 * The total risk associated with the annotated element.
+			 */
+		}
+		
+		attribute technicalRisk : RiskLevel [0..1] {
+			doc
+			/*
+			 * The risk of unresolved technical issues regarding the annotated element.
+			 */
+		}
+		
+		attribute scheduleRisk : RiskLevel [0..1] {
+			doc
+			/*
+			 * The risk that work on the annotated element will not be completed on schedule.
+			 */
+		}
+		
+		attribute costRisk : RiskLevel [0..1] {
+			doc
+			/*
+			 * The risk that work on the annotated element will exceed its planned cost.
+			 */
+		}
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/.meta.json

@@ -0,0 +1,29 @@
+{
+  "index": {
+    "ISQ": "ISQ.sysml",
+    "ISQAcoustics": "ISQAcoustics.sysml",
+    "ISQAtomicNuclear": "ISQAtomicNuclear.sysml",
+    "ISQBase": "ISQBase.sysml",
+    "ISQCharacteristicNumbers": "ISQCharacteristicNumbers.sysml",
+    "ISQChemistryMolecular": "ISQChemistryMolecular.sysml",
+    "ISQCondensedMatter": "ISQCondensedMatter.sysml",
+    "ISQElectromagnetism": "ISQElectromagnetism.sysml",
+    "ISQInformation": "ISQInformation.sysml",
+    "ISQLight": "ISQLight.sysml",
+    "ISQMechanics": "ISQMechanics.sysml",
+    "ISQSpaceTime": "ISQSpaceTime.sysml",
+    "ISQThermodynamics": "ISQThermodynamics.sysml",
+    "MeasurementRefCalculations": "MeasurementRefCalculations.sysml",
+    "MeasurementReferences": "MeasurementReferences.sysml",
+    "Quantities": "Quantities.sysml",
+    "QuantityCalculations": "QuantityCalculations.sysml",
+    "SI": "SI.sysml",
+    "SIPrefixes": "SIPrefixes.sysml",
+    "TensorCalculations": "TensorCalculations.sysml",
+    "Time": "Time.sysml",
+    "USCustomaryUnits": "USCustomaryUnits.sysml",
+    "VectorCalculations": "VectorCalculations.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/.project.json

@@ -0,0 +1,23 @@
+{
+  "name": "SysML Quantities and Units Library",
+  "version": "2.0.0",
+  "description": "Standard quantities and units domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/ISQ.sysml

@@ -0,0 +1,42 @@
+standard library package ISQ {
+    doc
+    /*
+     * International system of quantities (ISQ), as defined in ISO/IEC 80000
+     */
+
+	private import ScalarValues::Real;
+	private import Quantities::*;
+	private import MeasurementReferences::*;
+
+	public import ISQBase::*;                  // ISO/IEC 80000 base quantities and general concepts
+    public import ISQSpaceTime::*;             // ISO 80000-3 "Space and Time"
+    public import ISQMechanics::*;             // ISO 80000-4 "Mechanics"
+    public import ISQThermodynamics::*;        // ISO 80000-5 "Thermodynamics"
+    public import ISQElectromagnetism::*;      // IEC 80000-6 "Electromagnetism"
+    public import ISQLight::*;                 // ISO 80000-7 "Light"
+    public import ISQAcoustics::*;             // ISO 80000-8 "Acoustics"
+    public import ISQChemistryMolecular::*;    // ISO 80000-9 "Physical chemistry and molecular physics"
+    public import ISQAtomicNuclear::*;         // ISO 80000-10 "Atomic and nuclear physics"
+    public import ISQCharacteristicNumbers::*; // ISO 80000-11 "Characteristic numbers"
+    public import ISQCondensedMatter::*;       // ISO 80000-12 "Condensed matter physics"
+    public import ISQInformation::*;           // IEC 80000-13 "Information science and technology"
+
+    /* Additional quantity declarations */
+
+    attribute def TemperatureDifferenceValue :> ScalarQuantityValue {
+        doc
+        /*
+         * temperature difference
+         * A separate temperature difference quantity and unit are needed in order to support °C, °F and centrigrade temperature differences
+         */
+        attribute :>> num: Real;
+        attribute :>> mRef: TemperatureDifferenceUnit[1];
+    }
+    
+    attribute temperatureDifference: TemperatureDifferenceValue [*] nonunique :> scalarQuantities;
+
+    attribute def TemperatureDifferenceUnit :> SimpleUnit {    
+        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'Θ'; :>> exponent = 1; }
+        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }
+    }
+}