Merge branch 'master' of https://github.com/ModelDriven/SysML-v2-Pilot-Implementation

Author: ivan-gomes

sysml.library/Kernel Library/ComplexFunctions.kerml

@@ -24,11 +24,11 @@ package ComplexFunctions {
 	function ToString(x: Complex): String specializes BaseFunctions::ToString;
 	function ToComplex(x: String): Complex;
 
-	function sum(collection: Complex[0..*]): Complex {
-		ScalarFunctions::sum(collection, Rect(0.0, 0.0))
+	function sum(collection: Complex[0..*]): Complex specializes ScalarFunctions::sum {
+		ScalarFunctions::sum0(collection, Rect(0.0, 0.0))
 	}
 
-	function product(collection: Real[0..*]): Real {
-		ScalarFunctions::product(collection, Rect(1.0, 0.0))
+	function product(collection: Complex[0..*]): Complex specializes ScalarFunctions::product {
+		ScalarFunctions::product1(collection, Rect(1.0, 0.0))
 	}	
 }

sysml.library/Kernel Library/IntegerFunctions.kerml

@@ -28,11 +28,11 @@ package IntegerFunctions {
 	function ToInteger(x: String): Integer;
 	function ToReal(x: Integer): Real;
 
-	function sum(collection: Integer[0..*]): Integer {
-		ScalarFunctions::sum(collection, 0)
+	function sum(collection: Integer[0..*]): Integer specializes ScalarFunctions::sum {
+		ScalarFunctions::sum0(collection, 0)
 	}
 
-	function product(collection: Integer[0..*]): Integer {
-		ScalarFunctions::product(collection, 1)
+	function product(collection: Integer[0..*]): Integer specializes ScalarFunctions::product {
+		ScalarFunctions::product1(collection, 1)
 	}
 }	

sysml.library/Kernel Library/RealFunctions.kerml

@@ -28,11 +28,11 @@ package RealFunctions {
 	function ToReal(x: String): Real;
 	function ToComplex(x: Real): Complex;
 
-	function sum(collection: Real[0..*]): Real {
-		ScalarFunctions::sum(collection, 0.0)
+	function sum(collection: Real[0..*]): Real specializes ScalarFunctions::sum {
+		ScalarFunctions::sum0(collection, 0.0)
 	}
 
-	function product(collection: Real[0..*]): Real {
-		ScalarFunctions::product(collection, 1.0)
+	function product(collection: Real[0..*]): Real specializes ScalarFunctions::product {
+		ScalarFunctions::product1(collection, 1.0)
 	}	
 }

sysml.library/Kernel Library/ScalarFunctions.kerml

@@ -27,11 +27,14 @@ package ScalarFunctions {
 
 	abstract function '..'(lower: ScalarValue, upper: ScalarValue): ScalarValue[0..*];
 
-	function sum(collection: ScalarValue[0..*], zero: ScalarValue): ScalarValue {
+	abstract function sum(collection: ScalarValue[0..*]): ScalarValue;
+	abstract function product(collection: ScalarValue[0..*]);
+	
+	function sum0(collection: ScalarValue[0..*], zero: ScalarValue): ScalarValue {
 		collection->reduce '+' ?? zero
 	}
 
-	function product(collection: ScalarValue[0..*], one: ScalarValue): ScalarValue {
+	function product1(collection: ScalarValue[0..*], one: ScalarValue): ScalarValue {
 		collection->reduce '*' ?? one
 	}
 }

sysml/src/examples/Mass Roll-up Example/Vehicles.sysml

@@ -1,4 +1,4 @@
-package Vehicles {
+package VehicleMasses {
 	import ScalarValues::*;
 	import MassRollup::*;
 
@@ -21,16 +21,15 @@ package Vehicles {
 	}
 
 	// Example usage
-	
+	import SI::*;	
 	part c :> car {
-		import SI::*;
-		redefines mass = 1000@[kg];
+		redefines car::mass = 1000@[kg];
 		part redefines engine {
-			redefines mass = 100@[kg];
+			redefines engine::mass = 100@[kg];
 		}
 
 		part redefines transmission {
-			redefines mass = 50@[kg];
+			redefines transmission::mass = 50@[kg];
 		}	
 	}
 

sysml/src/training/22. Expressions/MassRollup.sysml

@@ -0,0 +1,27 @@
+package MassRollup {
+	import ScalarFunctions::*;
+	
+	block MassedThing {
+		value mass :> ISQ::mass; 
+		value totalMass :> ISQ::mass;
+	}
+	
+	part simpleThing : MassedThing {
+		value totalMass redefines MassedThing::totalMass = mass;
+	}
+	
+	part compositeThing : MassedThing {
+		part subcomponents: MassedThing[*];
+		
+		value totalMass redefines MassedThing::totalMass =
+			mass + sum(subcomponents->collect p:MassedThing (p::totalMass)); 
+	}
+	
+	part filteredMassThing :> compositeThing {
+		abstract value minMass :> ISQ::mass;
+		
+		value totalMass redefines MassedThing::totalMass =
+			sum(./subcomponents/totalMass[p (p >= minMass)]);
+	}
+
+}

sysml/src/training/22. Expressions/VehicleMasses.sysml

@@ -0,0 +1,38 @@
+package Vehicles {
+	import ScalarValues::*;
+	import MassRollup::*;
+	
+	block CarPart :> MassedThing {			
+		value serialNumber: String;
+	}
+	
+	part car: CarPart :> compositeThing {	
+		value vin redefines serialNumber;
+		
+		part carParts: CarPart[*] redefines subcomponents;
+		
+		part engine :> simpleThing, carParts {
+			//...
+		}
+		
+		part transmission :> simpleThing, carParts {
+			//...
+		}
+	}
+
+	// Example usage
+	
+	part c :> car {
+		import SI::*;
+		redefines mass = 1000@[kg];
+		part redefines engine {
+			redefines mass = 100@[kg];
+		}
+		
+		part redefines transmission {
+			redefines mass = 50@[kg];
+		}	
+	}
+	
+	// c::totalMass --> 1150.0@[kg]
+}

sysml/src/training/23. Constraints/Constraint Assertions-1.sysml

@@ -0,0 +1,32 @@
+package 'Constraint Assertions-1' {
+	import ISQ::*;
+	import SI::*;
+	import ScalarFunctions::*;
+	
+	block Engine;
+	block Transmission;
+	
+	constraint def MassConstraint (
+		partMasses : MassValue[0..*],
+		massLimit : MassValue) {
+			
+		sum(partMasses) <= massLimit
+	}
+	
+	block Vehicle {
+		assert constraint massConstraint : MassConstraint (
+			partMasses = {chassisMass, engine::mass, transmission::mass},
+			massLimit = 2500@[kg]
+		);
+		
+		value chassisMass : MassValue;
+		
+		value engine : Engine {
+			value mass : MassValue;
+		}
+		
+		value transmission : Engine {
+			value mass : MassValue;
+		}
+	}	
+}

sysml/src/training/23. Constraints/Constraint Assertions-2.sysml

@@ -0,0 +1,36 @@
+package 'Constraint Assertions-2' {
+	import ISQ::*;
+	import SI::*;
+	import ScalarFunctions::*;
+	
+	block Engine;
+	block Transmission;
+	
+	constraint def MassConstraint (
+		partMasses : MassValue[0..*],
+		massLimit : MassValue);
+	
+	constraint massConstraint : MassConstraint (
+		partMasses : MassValue[0..*],
+		massLimit : MassValue) {
+			
+		sum(partMasses) <= massLimit
+	}
+	
+	block Vehicle {
+		assert massConstraint (
+			partMasses = {chassisMass, engine::mass, transmission::mass},
+			massLimit = 2500@[kg]
+		);
+		
+		value chassisMass : MassValue;
+		
+		value engine : Engine {
+			value mass : MassValue;
+		}
+		
+		value transmission : Engine {
+			value mass : MassValue;
+		}
+	}	
+}

sysml/src/training/23. Constraints/Constraints Example-1.sysml

@@ -0,0 +1,32 @@
+package 'Constraints Example-1' {
+	import ISQ::*;
+	import SI::*;
+	import ScalarFunctions::*;
+	
+	block Engine;
+	block Transmission;
+	
+	constraint def MassConstraint (
+		partMasses : MassValue[0..*],
+		massLimit : MassValue) {
+			
+		sum(partMasses) <= massLimit
+	}
+	
+	block Vehicle {
+		constraint massConstraint : MassConstraint (
+			partMasses = {chassisMass, engine::mass, transmission::mass},
+			massLimit = 2500@[kg]
+		);
+		
+		value chassisMass : MassValue;
+		
+		value engine : Engine {
+			value mass : MassValue;
+		}
+		
+		value transmission : Engine {
+			value mass : MassValue;
+		}
+	}
+}