Updated for 2022-06.

install/jupyter/install.bat

@@ -20,7 +20,7 @@
 
 @echo off
 
-set /A SYSML_VERSION="0.24.0"
+set /A SYSML_VERSION="0.25.0"
 
 echo --- Step 1: Testing Conda installation ---
 where conda

install/jupyter/install.sh

@@ -21,7 +21,7 @@
 
 set -e
 
-SYSML_VERSION="0.24.0"
+SYSML_VERSION="0.25.0"
 
 echo "--- Step 1: Testing Conda installation ---"
 command -v conda || (echo "Conda is not installed. Please install Conda and re-run." && return 1)

sysml.library/Domain Libraries/Analysis/SampledFunctions.sysml

@@ -1,5 +1,5 @@
 /**
- * This package provides a libary model of discretely sampled mathematical functions.
+ * This package provides a library model of discretely sampled mathematical functions.
  */
 package SampledFunctions {
 	private import Base::Anything;
@@ -44,7 +44,7 @@ package SampledFunctions {
 	/* Range returns the sequence of the rangeValues of all samples in a SampledFunction. */	
 	calc def Range(fn : SampledFunction) : Anything[0..*] = fn.samples.rangeValue;
 
-	/* Sample returns a SampledFunction that samples a given calculation over a seqence of domainValues. */
+	/* Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues. */
 	calc def Sample {
 		in calc calculation (x);
 		in attribute domainValues [0..*];

sysml.library/Domain Libraries/Cause and Effect/CausationConnections.sysml

@@ -0,0 +1,74 @@
+package CausationConnections {	
+	doc 
+	/* 
+	 * This package provides a library model modeling causes, effects, and causation connections 
+	 * between them.
+	 */
+
+	abstract occurrence causes[*] {
+		doc /* Occurrences that are causes. */
+	}
+
+	abstract occurrence effects[*]  {
+		doc /* Occurrences that are effects. */
+	}
+
+	abstract connection def Multicausation {
+		doc
+		/*
+		 * A Multicausation connection models the situation in which one set of
+		 * occurrences causes another.
+		 * 
+		 * To create a Multicausation connection, specialize this connection definition
+		 * adding specific end features of the relavent types. Ends representing causes
+		 * should subset 'causes', while ends representing effects should subset 'effects'.
+		 * There must be at least one cause and at least one effect.
+		 */
+
+		private import SequenceFunctions::*;
+
+		ref occurrence causes[1..*] :>> causes :> participant {
+			doc /* The causing occurrences. */
+		}
+		ref occurrence effects[1..*] :>> effects :> participant {
+			doc /* The effect occurrences caused by the causing occurrences. */
+		}
+
+		private assert constraint disjointCauseEffect {
+			doc /* causes must be disjoint from effects. */
+			isEmpty(intersection(causes, effects))
+		}
+
+		private succession causalOrdering first causes.startShot[nCauses] then effects[nEffects] {
+			doc /* All causes must exist before all effects. */
+			attribute nCauses = size(causes);
+			attribute nEffects = size(effects);
+		}
+	}
+
+	abstract connection multicausations : Multicausation[*] {
+		doc /* multicausations is the base feature for Multicausation ConnectionUsages. */
+	}
+
+	connection def Causation :> Multicausation {
+		doc
+		/*
+		 * A Causation is a binary Multicausation in which a single cause occurrence
+		 * causes a single effect occurrence. (However, a single cause can separately
+		 * have multiple effects, and a single effect can have separate Causation
+		 * connections with multiple causes.)
+		 */
+
+		end occurrence theCause[*] :>> causes :> source {
+			doc /* The single causing occurrence. */
+		}
+
+		end occurrence theEffect[*] :>> effects :> target {
+			doc /* The single effect occurrence resulting from the cause. */
+		}
+	}
+
+	abstract connection causations : Causation[*] :> multicausations {
+		doc /* causations is the base feature for Causation ConnectionUsages. */
+	}
+}

sysml.library/Domain Libraries/Cause and Effect/CauseAndEffect.sysml

@@ -0,0 +1,81 @@
+package CauseAndEffect {
+	doc /* This package provides language-extension metadata for cause-effect modeling. */
+
+	import CausationConnections::*;
+	private import ScalarValues::*;
+	private import Metaobjects::SemanticMetadata;
+
+	metadata def <cause> CauseMetadata :> SemanticMetadata {
+		doc
+		/*
+		 * CauseMetadata identifies a usage as being a cause occurrence.
+		 * It is intended to be used to tag the cause ends of a Multicausation.
+		 */
+
+		ref :>> annotatedElement : SysML::Usage;
+		ref :>> baseType = causes as SysML::Usage;
+	}
+
+	metadata def <effect> EffectMetadata :> SemanticMetadata {
+		doc
+		/*
+		 * EffectMetadata identifies a usage as being an effect occurrence.
+		 * It is intended to be used to tag the effect ends of a Multicausation.
+		 */
+
+		ref :>> annotatedElement : SysML::Usage;
+		ref :>> baseType = effects as SysML::Usage;
+	}
+
+	metadata def CausationMetadata {
+		doc
+		/*
+		 * CausationMetadata allows for the specification of additional metadata about
+		 * a cause-effect connection definition or usage.
+		 */
+
+		ref :> annotatedElement : SysML::ConnectionDefinition;
+		ref :> annotatedElement : SysML::ConnectionUsage;
+
+		attribute isNecessary : Boolean default false {
+			doc 
+			/* 
+			 * Whether all the causes are necessary for all the effects to occur.
+			 * If this is false (the default), then some or all of the effects may 
+			 * still have occurred even if some of the causes did not.
+			 */
+		}
+
+		attribute isSufficient : Boolean default false {
+			doc
+			/*
+			 * Whether the causes were sufficient for all the effects to occur.
+			 * If this is false (the default), then it may be the case that some
+			 * other occurrences were also necessary for some or all of the effects
+			 * to have occurred.
+			 */
+		}
+
+		attribute probability : Real[0..1] {
+			doc /* The probability that the causes will actually result in effects occurring. */
+		}	
+	}
+
+	metadata def <multicausation> MulticausationSemanticMetadata :> CausationMetadata, SemanticMetadata {
+		doc
+		/*
+		 * MulticausationMetadata is SemanticMetadata for a Multicausation connection.
+		 */
+
+		ref :>> baseType = multicausations as SysML::Usage;
+	}
+
+	metadata def <causation> CausationSemanticMetadadata :> CausationMetadata, SemanticMetadata {
+		doc
+		/*
+		 * CausationMetadata is SemanticMetadata for a Causation connection.
+		 */
+
+		ref :>> baseType = causations as SysML::Usage;
+	}
+}

sysml.library/Domain Libraries/Metadata/ImageMetadata.sysml

@@ -0,0 +1,78 @@
+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.
+	 */
+
+	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.
+			 */
+		}
+	}
+
+}

sysml.library/Domain Libraries/Metadata/ModelingMetadata.sysml

@@ -81,4 +81,13 @@ package ModelingMetadata {
 		attribute text : String;
 	}
 
+	/** 
+	 * 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.
+	 */
+	metadata def <refinement> Refinement {
+		:>> annotatedElement : SysML::Dependency;
+	}
+
 }

sysml.library/Domain Libraries/Metadata/ParametersOfInterestMetadata.sysml

@@ -0,0 +1,39 @@
+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).
+	 */
+
+	 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 as 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 as SysML::Usage;
+	 }
+}

sysml.library/Domain Libraries/Requirement Derivation/DerivationConnections.sysml

@@ -0,0 +1,58 @@
+package DerivationConnections {
+	doc
+	/*
+	 * This package provides a library model for derivation connections between requirements.
+	 */
+
+	requirement originalRequirements[*] {
+		doc /* originalRequirements are the original requirements in Derivation connections. */
+	}
+	requirement derivedRequirements[*] {
+		doc /* derivedRequiremetns are the derived requirments in Derivation connections. */
+	}
+
+	abstract connection def Derivation {
+		doc
+		/*
+		 * A Derivation connection asserts that one or more derivedRequirements are derived from
+		 * a single originalRequirement. This means that any subject that satisfies the
+		 * originalRequirement should, in itself or though other things related to it, satisfy
+		 * each of the derivedRequirements.
+		 * 
+		 * A connection usage typed by Derivation must have requirement usages for all its ends.
+		 * The single end for the originalRequirement should subset originalRequirement, while
+		 * the rest of the ends should subset derivedRequirements.
+		 */
+
+		ref requirement :>> participant {
+			doc /* All the participants in a Derivation must be requirements. */
+		}
+
+		ref requirement originalRequirement[1] :>> originalRequirements :> participant {
+			doc /* The single original requirement. */
+		}
+		ref requirement :>> derivedRequirements[1..*] :> participant {
+			doc /* The one or more requirements that are derived from the original requirement. */
+		}
+
+		private assert constraint originalNotDerived {
+			doc /* The original requirement must not be a derived requirement. */
+
+			derivedRequirements->SequenceFunctions::excludes(originalRequirement)
+		}
+
+		private assert constraint originalImpliesDerived {
+			doc 
+			/* 
+			 * Whenever the originalRequirement is satisfied, all of the derivedRequirements must also
+			 * be satisfied.
+			 */
+
+			originalRequirement.result implies ControlFunctions::allTrue(derivedRequirements.result)
+		}	
+	}
+
+	abstract connection derivations : Derivation[*] {
+		doc /* derivations is the base feature for Derivation connection usages. */
+	}
+}