Chapter 13. Modeling System Variants with Variation Points

A system design model may include variation points, which allow specifying variants of a system.

In SysML2, a variation is a type that classifies a fixed number of instances, which are its variants. All features declared within the body of a variation definition (or a variation feature) are declared as variant features by placing the keyword variant at the beginning of their declarations. The semantics of variations restricts the allowable instances of a variation to values of its owned variant features.

For instance, we can define an EngineVariant part type that admits of the two engine variants fourCylEngine and sixCylEngine as a variation in the following way:

part def Cylinder;
part def Engine {
  part cylinder[2..*] : Cylinder;
}
variation part def EngineVariant :> Engine {
  variant part fourCylEngine : Engine {
    part redefines cylinder[4];
  }
  variant part sixCylEngine : Engine {
    part redefines cylinder[6];
  }
}

The variation EngineVariant can then be used for defining a variation point property in an abstract CarVariant part type definition:

part def Transmission;
abstract part def CarVariant {
  part engine : EngineVariant;  // variation point property
  part transmission : Transmission;
}

In addition to the engine, also the transmission can be turned into a variation point by defining the variants manualTransmission and automaticTransmission. In the following example code, these variants are defined by embedding them in a variation property definition:

part def Transmission;
abstract part def CarVariant {
  // variation point property
  part engine : EngineVariant;
  // variation part property with embedded variant definitions
  variation part transmission : Transmission {
    variant part manualTransmission : Transmission;
    variant part automaticTransmission : Transmission;
  }
}

An abstract part type defined with variation points, like CarVariant, subsumes a number of concrete part types obtained by choosing an admissible combination of variants for each variation point. The set of admissible combinations can be constrained like in the following example, where 4-cylinder cars can only have a manual transmission:

part def Transmission;
abstract part def CarVariant {
  // variation point property
  part engine : EngineVariant;
  // variation point property with embedded variant definitions
  variation part transmission : Transmission {
    variant part manualTransmission : Transmission;
    variant part automaticTransmission : Transmission;
  }
  assert constraint {
    engine == EngineVariant::fourCylEngine implies
     transmission == transmission::manualTransmission
  }
}

This constrained CarVariant part type subsumes three concrete part types:

part def Car4Cyl :> CarVariant {
  part redefines engine = engine::fourCylEngine;
  part redefines transmission = transmission::manualTransmission;
}
part def Car6CylManual :> CarVariant {
  part redefines engine = engine::sixCylEngine;
  part redefines transmission = transmission::manualTransmission;
}
part def Car6CylAuto :> CarVariant {
  part redefines engine = engine::sixCylEngine;
  part redefines transmission = transmission::automaticTransmission;
}