XML based Mission Profile Format (MPFO-XML)¶

This chapter describes the XML based implementation of the Mission Profile Format (MPFO).

Files and Folders¶

Format Definition¶

The XML Schema files for MPFO-XML and its validation files can be found at that folder location: <MPFO install>

File	Description
mpfo.xsd	MPFO-XML main definitions (XML Schema file)
mpfo_math.xsd	MPFO-XML math descriptions (XML Schema file); file is included in mpfo.xsd
mpfo.nvdl	Validation file based on Namespace-based Validation Dispatching Language (NVDL) for MPFO-XML Strict Content MathML
mpfo.sch	Validation file based on Schematron for MPFO-XML Strict Content MathML
mpfo_math.rnc	Validation file based on RELAX NG compact schema for Strict Content MathML

External Definitions (Templates)¶

The external standard include files can be found at that folder location: <MPFO install>/include/

File	Description
stdlib.xml	MPFO-XML standard library with basic primitive declarations
LV124.xml	MPFO-XML standard load definitions for LV124/VW80000. See also [LV124]

External Format Dependencies¶

The MPFO-XML format depends on several external XML Schema files for math, meta model, requirements, signature and encryption definitions.

List of Dependencies¶

Folder location: <MPFO install>/external-xsd/<dependency>

Dependency	Description
mathml/mathml3.xsd	MathML3 XML Schema root file
pmml/pmml-4-3.xsd	PMML XML Schema file
reqif/reqif.xsd	REQ-IF XML Schema root file
xhtml/*	XHTML XML Schema files
xml/xml.xsd	XML base Schema file
xmlsig-core/xmldsig-core-schema.xsd	XML-SIG XML Schema file
xmlenc-core/xenc-schema.xsd	XML-ENC XML Schema file

Modifications¶

This directory contains external XML Schema files used by MPFO-XML. This file lists all changes that were made to these schema files in order to fix problems or warnings when used by MPFO-XML.

Schema Location Changes

Most of the XML Schema files in this directory reference other namespaces using an URI as schema location. This triggers warnings during validation, because namespaces are imported or included multiple times with different schema locations. Therefore, we changed references to external schemas to point to schemas in this directory.

REQ-IF

reqif/reqif.xsd:

Imports XML namespace from external-xsd/xml/xml.xsd (r122)
Imports XHTML namespace from external-xsd/reqif/driver.csd (which redirects to external-xsd/xhtml) (r122)

reqif/driver.xsd

Imports XML namespace from external-xsd/xml/xml.xsd (r122)
Includes XHTML from external-xsd/xhtml/ (r122)

XHTML

xhtml/*.xsd

Imports XML namespace from xml/xml.xsd (r242)

XML Encryption

xmlenc-core/xenc-schema.xsd

Imports XML Signature (XMLDSig) namespace from external-xsd/xmldsig-core/xmldsig-core-schema.xsd (r122)

Formatting Changes

Revision 149 changes the formatting of:

external-xsd/mathml/mathml3*.*

external-xsd/reqif/driver.xsd

external-xsd/reqif/reqif.xsd

external-xsd/xhtml/*.xsd

external-xsd/xml/xml.xsd

external-xsd/xmldsig-core/xmldsig-core-schema.xsd

external-xsd/xmlenc-core/xenc-schema.xsd

Document Validation¶

Validation on Command Line

The validity of a XML based mission profile document in MPFO-XML format can be checked manually as follows:

Check the XML mission profile document’s base contents with xmllint or another XML Schema capable validation tool:

xmllint --noout --xinclude --nsclean --encode utf-8 --schema mpfo.xsd <MPFO-XML document>

Check the parts defined as Strict Content MathML using NVDL and Jing:

java -jar <path to jing.jar> mpfo.nvdl <MPFO-XML document>

Check the structure of number, vector and matrix definitions using Schematron and Jing:
```
java -jar <path to jing.jar> mpfo.sch <MPFO-XML document>
```

Validation with Script in MPFO Environment

The MPFO environment also offers a MPFO-XML script and Jing that can be used to validate MPFO-XML documents with the steps described in Section “Validation on Command Line”:

<MPFO installation>/bin/validate_mpfo-xml.csh <MPFO-XML document>

Validation with XML Authoring Tool

Most XML document authoring tools, such as Oxygen XML Editor or XMLSpy XML Editor, offer convenient validation and debugging capabilities based on XML Schema, ReleaxNG, Schematron and NVDL. Please consult the XML editor-specific documentation for more details on XML file validation.

The following picture shows a validation scenario for Oxygen XML Editor.

Formal XML Schema Description¶

See MPFO-XML Schema documentation.

The following picture shows how to generate this documentation in Oxygen XML Editor using the command Tools → Generate Documentation → XML Schema Documentation… (Ctrl+Alt+S).

Unit Tests¶

Note

This content of this chapter is not relevant to end users since it documents measures for quality assurance.

The MPFO environment offers several unit tests to test various features and aspects of MPFO-XML documents. The unit tests can be executed as follows:

cd <MPFO installation>/test
make test

MathML Editor¶

The math primitives supported by MPFO-XML are based on Strict Content MathML, which by itself represents a sub-set of MathML. The following Strict Content MathML editor can be used to simplify and speed-up the manual creation of the corresponding XML code.

Strict Content MathML Editor

Format Description¶

MPFo Mission Profile Definition¶

Description¶

The mission profile of a component is organized in a XML document structure. The MPFo element defines the primary root element, which contains all relevant definitions for document revisions, ports, loads, actions, activities, scenarios and requirements. It also supports the load-time include of externally defined MPFO-XML based mission profile information, which may include definitions of standard loads, standards ports etc.

Definition of ‘MPFo’ Element¶

The MPFo element is formally defined here: MPFo

All MPFo sub-elements can be encrypted using the W3C XML-encryption mechanism [XML-SEC]. The element attribute ‘Revision’ should be defined in that case due to the then inaccessible revision information in the DocumentDefinition element.

Examples¶

Example 1: Basic structure of a MPFO-XML document with external includes

<?xml version="1.0" encoding="UTF-8"?>
<MPFo xmlns:m="http://www.w3.org/1998/Math/MathML"
    xmlns="http://www.mpfo.org/mpfo-0.6"
    xmlns:mml="http://www.w3.org/1998/Math/MathML"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.mpfo.org/mpfo-0.6/mpfo.xsd"
    Id="ID.Component.R1"
    MPFoVersion="0.6"
    ShortDescription="Example: Simple two-port electrical resistor R1 that is operated with a DC current for 55h at 298K (25C) and 350h at 423K (150C)">

    <!-- Long description of mission profile document. -->
    <Description>
        ...
    </Description>

    <!-- External MPFO-XML definitions via XML XInclude mechanism. -->
    <Include>
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="./include/stdlib.xml"/>
    </Include>

    <!-- Definition of mission profile document revisions. -->
    <DocumentDefinition>
        ...
    </DocumentDefinition>

    <!-- Definition of component port structure. -->
    <PortDefinition>
        ...
    </PortDefinition>

    <!-- Definition of the component loads, such as the environmental and functional loads. -->
    <LoadDefinition>
        ...
    </LoadDefinition>

    <!-- Combination of environmental loads with functional loads at component ports for a specific action. -->
    <ActionDefinition>
        ...
    </ActionDefinition>

    <!-- Definition of the component activities, i.e., a series of linked actions and/or parallel activity streams. -->
    <ActivityDefinition>
        ...
    </ActivityDefinition>

    <!-- Definition of the component application scenarios. -->
    <ScenarioDefinition>
        ...
    </ScenarioDefinition>

    <!-- Definition of mission profile related requirements. -->
    <RequirementDefinition>
        ...
    </RequirementDefinition>
</MPFo>

Example 2: Encrypted MPFO-XML document

Todo

To be added!

External Definition¶

Description¶

The ExternalDefiniton element defines an alternative root element for MPFO-XML documents. It allows the definition of mission profile information that is either independent of a component or which contains reusable and/or standardized information. This element is used by the XML XInlude mechanism of MPFO-XML documents to allow the validation of externally defined MPFO-XML data (e.g., stdlib.xml or LV124.xml). The usability of MPFO-XML documents is greatly improved by the ExternalDefiniton and Include elements since standard definitions, such as standard loads or functions, can be defined in a reusable and modular fashion.

Definition of ‘ExternalDefinition’ Element¶

The ExternalDefinition element is formally defined here: ExternalDefinition

Parsing Directives and Checks on Application Level¶

By itself, MPFO-XML documents with a root element ExternalDefiniton represent valid XML documents. They can be validated with XML tools as described in section Document Validation.

The ExternalDefiniton element and its contents shall be ignored (with a warning) during the processing of MPFO-XML documents since they do not represent valid and self-contained MPFO-XML documents on their own.

Examples¶

Example 1: Excerpt from the ./include/LV124.xml MPOF-XML file which uses *ExternalDefinition* as (alternative) root element

<?xml version="1.0" encoding="UTF-8"?>
<ExternalDefinition xmlns="http://www.mpfo.org/mpfo-0.6"
    Id="ID.ExternalDefinition.LV124"
    MPFoVersion="0.6"
    xmlns:mml="http://www.w3.org/1998/Math/MathML">
    <LoadDefinition>
        <Loads>
            <!-- Load E-01: Long-term Overvoltage -->
            <Load Id="ID.Load-LV124-E-01">
                <LoadQuantity Symbol="U">
                    <SymbolicFunction Id="ID.SymbolicFunction-LV124-E-01">
                        <!-- Function: U(t) with parameters Umax (V), Umin (V), tr (s), tf (s), t1 (s) -->
                        <SymbolicFunctionTemplate Id="ID.SymbolicFunctionTemplate-LV124-E-01" Symbol="U">
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                                </mml:math>
                            </Unit>
                            <Arguments>
                                <ArgumentWithUnit Symbol="t">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ArgumentWithUnit>
                            </Arguments>

                            ...

                        </SymbolicFunctionTemplate>
                    </SymbolicFunction>
                </LoadQuantity>
            </Load>
        </Loads>
    </LoadDefinition>
</ExternalDefinition>

Example 2: Include of externally defined MPFO-XML data in a mission profile document

<MPFo xmlns:m="http://www.w3.org/1998/Math/MathML"
    xmlns="http://www.mpfo.org/mpfo-0.6"
    xmlns:mml="http://www.w3.org/1998/Math/MathML"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.mpfo.org/mpfo-0.6 ../../../../mpfo.xsd"
    Id="ID.Component.R1"
    MPFoVersion="0.6"
    ShortDescription="Example: Simple two-port electrical resistor R1 that is operated with a DC current for 55h at 298K (25C) and 350h at 423K (150C)">

    <!-- Include external definitions -->
    <Include>
        <!-- Include external MPFO standard definitions -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="./include/stdlib.xml"/>
        <!-- Include external load definitions from LV124 -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="./include/LV124.xml"/>
    </Include>
    ...
</MPFo>

Example 3: MPFO-XML document with encrypted contents

Attention

To be added!

Include Definition¶

Description¶

The MPFO-XML format allows the inclusion of externally defined MPFO-XML elements via the XML XInlude mechanism to improve the general usability and ease of use of MPFO-XML documents. The usability is hereby improved by the possibility to re-use standard definitions for e.g. loads, functions and various other elements.

External MPFO-XML data must be defined by using the alternative ExternalDefinition XML root element.

Definition of Include Element¶

The ‘Include’ top-level element allows the optional import of externally defined MPFO-XML elements via the standard XML XInclude mechanism. It is possible to include several MPFO-XML files with external definitions. In that case, all externally defined elements must have unique element IDs.

In contrast to the MPFO-XML primary root element Component, the Include element does not allow the definition of the DocumentDefinition element.

Parsing Directives and Checks on Application Level¶

The external elements are mapped to the ‘http://www.mpfo.org/mpfo-0.6’ XML namespace.

Examples¶

See ExternalDefinition element examples Examples.

Document Definition¶

Description¶

A typical component has several development revisions during its development and product life cycle. In addition, a corresponding MPFO-XML document may also have several revisions by itself for its own reasons.

A MPFO-XML document must have at least one Document element defined for the current document revision, but it may also have more than one Document element defined to keep its revision history. The Document element contains all information related to a document revision.

A Document element will receive a unique ID as well as creation and modification information. The element can also refer to a previous revision of itself, which can be used to build a revision history tree. Detailed revision author and export tool information can be added to support traceability.

Any Document element can be electronically signed individually using the W3C XML-signature mechanism [XML-SIG]. The contents of the DocumentDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Definition of ‘DocumentDefinition’ Element¶

The DocumentDefinition element is formally defined here: DocumentDefinition

The contents of the DocumentDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC]. The element attribute ‘Revision’ should be defined for the MPFo root node element in case the contents of the DocumentDefinition element is encrypted.

Definition of ‘Document’ Element¶

The Document element is defined here: Document

Any Document element can be signed electronically using the W3C XML-signature mechanism [XML-SIG].

Examples¶

Example 1: Document element definitions for two MPFO-XML document revisions

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...

    <!-- Definition of mission profile document revisions -->
    <DocumentDefinition>
        <Documents>
            <!-- Initial MP document revision -->
            <Document Id="ID.MP.Doc.01" Revision="1">
                <Description>Initial mission profile document</Description>
                <Creator Name="Klaus Schulze" Organization="Example Company" Email="Klaus.Schulze@example.com" ToolName="MPFW" ToolVersion="1.2" CreationTimeStamp="2018-01-01T08:00:00.0Z"/>
            </Document>
            <!-- Second MP document revision -->
            <Document Id="ID.MP.Doc.02" ShortDescription="First update version" Revision="2" ModificationTimeStamp="2018-05-31T18:13:51.0" PredecessorDocumentRef="ID.MP.Doc.01">
                <Description>Updated mission profile document</Description>
                <Creator Name="Max Mustermann" Organization="Example Company" Email="Max.Mustermann@example.com" ToolName="MPFW" ToolVersion="1.2" CreationTimeStamp="2018-05-04T10:00:00.0Z"/>
            </Document>
        </Documents>
    </DocumentDefinition>

    ...
</MPFo>

Example 2: Digitally signed document revision

Todo

To be added.

Port Definition¶

Description¶

The structure of components and their interactions with the environment are defined by component ports. Ports hereby represent a generic concept, i.e. a port may (among others) represent an electrical connection, the components mounting location or a connector to exchange any type of material. The port concept in MPFO-XML was inspired by the port concept in SysML [SysML]. This makes it easier in the future to derive a MPFO-XML representation from a SysML model. However, due to its limited application space the MPFO-XML port concept only supports static ports and flow ports. A port may have an unlimited number nested sub-ports. Several ports can be combined to port sets.

The consideration of components in MPFO-XML assumes that a component is a black box, i.e., the content of a component is unknown. The implementation details of a component are therefore not definable. While component ports are independent from each other, ports may have an indirect relationship that is defined via load references.

All functional and environmental loads defined in the element Load Definition are assigned to either ports or to port sets in the element Action Definition.

Definition of ‘PortDefinition’ Element¶

The PortDefinition element is formally defined here: PortDefinition

The contents of the PortDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Definition of ‘Port’ Element¶

The Port element is formally defined here: Port

The port type definition is mandatory.

Definition of ‘PortSet’ Element¶

The Port element is formally defined here: PortSet

Several ports can be combined into port sets. An individual port may be referenced in more than one port set. Port sets can be used to assign commonly shared loads to several ports at once. Port sets have their own ID and can therefore be referenced via an IDREF.

Note

The Action element Action Definition may also be used to define action specific port sets.

Examples¶

Example 1: Minimal port definition

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...
    <!-- Definition of components port structure. -->
    <PortDefinition>
        <!-- Minimal port definition -->
        <Ports>
            <Port Id="ID.PORT.00"/>
            <!-- Port definition with all attributes defined -->
            <Port Id="ID.PORT.01" Name="P1" Type="static" ShortDescription="Test port 1"/>
            <!-- Port definition with some attributes defined -->
            <Port Id="ID.PORT.02" Type="input" ShortDescription="Test port 2"/>
            <!-- Port definition with nested sub-ports and various attributes defined -->
            <Port Id="ID.PORT.03" Name="P3" Type="output" >
                <NestedPort Id="ID.PORT.03.1" Name="P3_1" ShortDescription="Test port 3, sub-port 1">
                <NestedPort Id="ID.PORT.03.2" ShortDescription="Test port 3, sub-port 2">
            </Port>
        </Ports>
    </PortDefinition>
    ...
</MPFo>

Example 2: Component port definition with 2 electrical resistor ports

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...
    <!-- Component port definition: 2 electrical resistor ports (N1, N2) -->
    <PortDefinition>
        <Ports>
            <Port Id="ID.Port.N1" Name="N1" ShortDescription="Electrical device instance terminal N1" Type="inout"/>
            <Port Id="ID.Port.N2" Name="N2" ShortDescription="Electrical device instance terminal N2" Type="inout"/>
        </Ports>
    </PortDefinition>
    ...
</MPFo>

Load Definition¶

Description¶

The term “Load” describes an individual

Environmental load or a

Functional load

that applies to a component within an operating mode. Loads can be of acoustic, fluid, mechanical, thermal, electrical, radiation or chemical type [ZVEI:RobVal]. For instance, a mechanical load is an externally applied and internally generated force that acts on a system or device. The application of loads results in stress and strain responses within the structures and materials of the system or device.

A load distribution is a statistically described load level over time, cycles, temperature, voltage, radiation, chemical, climatic conditions, or other load types [ZVEI:RobVal].

Definition of ‘LoadDefinition’ Element¶

The contents of the LoadDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Definition of ‘Load’ Element¶

A specific load can be defined in three different ways via the Load element:

Load quantity (LoadQuantity element),

Derived from external raw data (RawData element) via CSV sub-element, via JSON or via MetaModel element,

Load reference to another load (LoadRef element).

Loads defined by Load Quantities¶

A LoadQuantity element may consist of either a

Single quantity, defined by number and a unit (e.g., 5 meter, 298 degree K, 0.1 Ampere),

Dense vector, matrix, or sparse vector and matrix quantities,

N-dimensional function that relates several quantity parameters directly (e.g., voltage over time relation).

Furthermore, all single single, vector or matrix quantities can also be defined as

Quantities with interval values,

Quantities with values having relative or absolute variations,

Quantities with interval values and whose values have relative or absolute variations.

See Section Math Primitives for details and more examples.

Loads defined by Raw Data¶

Loads can be defined by externally provided data, such as a text based CSV or JSON file or as file containing a Meta Model using the RawData element.

CSV File

The MPFO-XML format supports the CSV file format in the CSV sub-element. MPFO-XML allows the direct inclusion of a CVS based file or the indirect inclusion via the standard XML xinclude mechanism. The parsing, checking of structural validity and conversion to MPFO-XML quantities of embedded or included CSV data most be done at application level.

...

<!-- Component load definitions -->
<LoadDefinition>
    <Loads>
        <!-- Load definition via external CSV data -->
        <Load Id="ID.Load.0" ShortDescription="External CSV data">
            <RawData>
                <CSV>
                    <!-- Include external CSV file data -->
                    <InlineData>
                       <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="example_data.csv"/>
                    </InlineData>
                    <!-- Define unit mapping -->
                    <ColumnUnits ElementCount="3">
                        <DefaultElement>
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                                </mml:math>
                            </Unit>
                        </DefaultElement>
                        <Elements>
                            <Element Index="1">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">meter</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                            <Element Index="3">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">kilogram</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                        </Elements>
                    </ColumnUnits>
                </CSV>
            </RawData>
        </Load>
    </Loads>
</LoadDefinition>

...

JSON File

The MPFO-XML format supports the JSON file format in the JSON sub-element. MPFO-XML allows the direct inclusion of a JSON based file or the indirect inclusion via the standard XML xinclude mechanism. The parsing, checking of structural validity and conversion to MPFO-XML quantities of embedded or included JSON data most be done at application level.

...

<!-- Component load definitions -->
<LoadDefinition>
    <Loads>
        <!-- Load definition via external JSON data -->
        <Load Id="ID.Load.0" ShortDescription="External JSON data">
            <RawData>
                <JSON>
                    <!-- Include external JSON file data -->
                    <InlineData>
                       <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="example_data.json"/>
                    </InlineData>
                    <!-- Define unit mapping -->
                    <ColumnUnits ElementCount="3">
                        <DefaultElement>
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                                </mml:math>
                            </Unit>
                        </DefaultElement>
                        <Elements>
                            <Element Index="1">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">meter</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                            <Element Index="3">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">kilogram</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                        </Elements>
                    </ColumnUnits>
                </JSON>
            </RawData>
        </Load>
    </Loads>
</LoadDefinition>

...

Meta Model File

The MPFO-XML format supports the XML based PMML [PMML] format as meta model format in the MetaModel sub-element. MPFO-XML allows the direct inclusion of a PMML based file or the indirect inclusion via the standard XML xinclude mechanism. The structural validity of the embedded or included PMML XML data is automatically validated during MPFO-XML file validation (see Document Validation). However, the parsing and conversion to MPFO-XML quantities of embedded or included PMML data most be done at application level.

...

<!-- Component load definitions -->
<LoadDefinition>
    <Loads>
        <!-- Load definition via external PMML data -->
        <Load Id="ID.Load.0" ShortDescription="PMML">
            <RawData>
                <MetaModel Type="pmml">
                    <!-- Include external PMML definitions -->
                    <InlineData>
                       <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="PMML_Model.xml"/>
                    </InlineData>
                    <!-- Define unit mapping -->
                    <ColumnUnits ElementCount="3">
                        <DefaultElement>
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                                </mml:math>
                            </Unit>
                        </DefaultElement>
                        <Elements>
                            <Element Index="1">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">meter</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                            <Element Index="3">
                                <Unit>
                                    <mml:math>
                                        <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                                    </mml:math>
                                </Unit>
                            </Element>
                        </Elements>
                    </ColumnUnits>
                </MetaModel>
            </RawData>
        </Load>
    </Loads>
</LoadDefinition>

...

Loads defined by Reference¶

Loads can be defined as load reference (via element ID) to another existing load via the LoadRef element. References to other load references are not permitted to avoid cyclic dependency problems.

The referenced load will be imported and and optionally adjusted. The MPFO-XML standard template library ./include/stdlib.xml hereby provides several formula definitions for function adjustments:

Scaling (ID: ID.STD.FormulaTemplate.Scale),

Offset (ID: ID.STD.FormulaTemplate.Offset),

Scale and offset (ID: ID.STD.FormulaTemplate.ScaleThenOffset),

Offset and scale (ID: ID.STD.FormulaTemplate.OffsetThenScale),

Negation (ID: ID.STD.FormulaTemplate.Negation).

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    <!-- External MPFO-XML definitions -->
    <Include>
        <!-- Include external MPFO standard definitions -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="./include/stdlib.xml"/>
    </Include>

    ...

    <!-- Component load definitions -->
    <LoadDefinition>
        <Loads>
            <!-- Definition of the resistor input current as DC current i = 0.1234 A -->
            <Load Id="ID.Load.0" ShortDescription="Input current I0">
                <LoadQuantity Id="ID.QLoad.0" Symbol="I0">
                    <Quantity>
                        <SNumber>0.1234</SNumber>
                        <Unit>
                            <mml:math>
                                <mml:csymbol cd="SI_NamedDerivedUnits1">ampere</mml:csymbol>
                            </mml:math>
                        </Unit>
                    </Quantity>
                </LoadQuantity>
            </Load>
            ...
            <!-- Definition of the resistor output current as DC current i = -0.1234 A as negation of load ID.Load.0 -->
            <Load Id="ID.Load.1" ShortDescription="Output current I1">
                <LoadRef ReferenceLoadRef="ID.Load.0">
                    <TransformationFunction>
                        <!-- Formula ID.STD.Formula.Negation is defined in ./include/stdlib.xml -->
                        <FormulaRef Ref="ID.STD.Formula.Negation"/>
                    </TransformationFunction>
                </LoadRef>
            </Load>
        </Loads>
    </LoadDefinition>

    ...

</MPFo>

Definition of ‘LoadSet’ Element¶

Several load definitions can be combined into load sets via the LoadSet element. Load sets can be used to assign commonly shared but time-sequence independent loads to several ports at once (See Action Definition). Load sets have their own ID and can therefore be referenced via an IDREF. An individual load may be referenced in more than one load set.

Individual loads collected in a load set are typically independent from each other, i.e., a load does not have an impact on another load. For example, the voltages of an ESD event applied to a circuit port do not relate to a specific ambient temperature. In case a load does have an impact on another load but that impact was not defined before (e.g. via LoadQuantities) the loads should be aligned to share the same reference frame. For example, in case transient voltages and currents at a circuit port are collected and defined as different loads, then the alignment can transform the relationships from v(t) and i(t) to i,v(t).

Note

The Action element Action Definition may also be used to define load sets that are action specific.

Examples¶

Example 1: Load definition for two-port resistor example

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
     <!-- External MPFO-XML definitions -->
    <Include>
        <!-- Include external MPFO standard definitions -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="../../include/stdlib.xml"/>
        <!-- Include the LV124 load definitions -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="../../include/LV124.xml"/>
    </Include>

   ...

    <!-- Component load definitions -->
    <LoadDefinition>
        <Loads>
            <!-- Definition of the resistor input current as DC current i = 123.4 mA -->
            <Load Id="ID.Load.0" ShortDescription="Input current I0">
                <LoadQuantity Id="ID.QLoad.0" Symbol="I0">
                    <Quantity>
                        <SNumber>0.1234</SNumber>
                        <Unit>
                            <mml:math>
                                <mml:csymbol cd="SI_NamedDerivedUnits1">ampere</mml:csymbol>
                            </mml:math>
                        </Unit>
                    </Quantity>
                </LoadQuantity>
            </Load>

            <!-- Definition of the resistor output current as DC current i = -123.4 mA -->
            <Load Id="ID.Load.1" ShortDescription="Output current I1">
                <LoadRef OriginalLoadRef="ID.Load.0">
                    <TransformationFunction>
                        <Formula>
                            <FormulaTemplate Symbol="neg">
                                <Arguments>
                                    <Argument Symbol="i"/>
                                </Arguments>
                                <mml:math>
                                    <mml:apply>
                                        <mml:csymbol cd="arith1">unary_minus</mml:csymbol>
                                        <mml:ci>i</mml:ci>
                                    </mml:apply>
                                </mml:math>
                            </FormulaTemplate>
                        </Formula>
                    </TransformationFunction>
                </LoadRef>
            </Load>

            <!-- Environment temperature T1 = 298 K present for a certain period of time -->
            <Load Id="ID.Load.Env.0" ShortDescription="Environment temperature T1 = 298 K for 55 h">
                <LoadQuantity Id="ID.QLoad.Env.0" Symbol="T1">
                    <SymbolicFunction>
                        <!-- Re-usable function template that defines a piecewise function to define a time interval later -->
                        <SymbolicFunctionTemplate Id="ID.Function-constant-temperature"  Symbol="T">
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_NamedDerivedUnits1">kelvin</mml:csymbol>
                                </mml:math>
                            </Unit>
                            <Arguments>
                                <ArgumentWithUnit Symbol="t">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_BaseUnits1">hour</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ArgumentWithUnit>
                            </Arguments>
                            <Parameters>
                                <ParameterWithUnit Symbol="T1" TeX="T_1">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_NamedDerivedUnits1">kelvin</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ParameterWithUnit>
                                <ParameterWithUnit Symbol="t1" TeX="t_1">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_BaseUnits1">hour</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ParameterWithUnit>
                            </Parameters>
                            <mml:math>
                                <mml:apply>
                                    <!-- define a piecewise linear function between 0 <= t <= t1 where t1 will be defined later -->
                                    <mml:csymbol cd="piece1">piecewise</mml:csymbol>
                                    <mml:apply>
                                        <mml:csymbol cd="piece1">piece</mml:csymbol>
                                        <mml:ci>T1</mml:ci>
                                        <mml:apply>
                                            <mml:csymbol cd="logic1">and</mml:csymbol>
                                            <mml:apply>
                                                <mml:csymbol cd="relation1">geq</mml:csymbol>
                                                <mml:ci>t</mml:ci>
                                                <mml:cn type="real">0</mml:cn>
                                            </mml:apply>
                                            <mml:apply>
                                                <mml:csymbol cd="relation1">leq</mml:csymbol>
                                                <mml:ci>t</mml:ci>
                                                <mml:ci>t1</mml:ci>
                                            </mml:apply>
                                        </mml:apply>
                                    </mml:apply>
                                </mml:apply>
                            </mml:math>
                        </SymbolicFunctionTemplate>

                        <!-- Assign values to the function template parameters -->
                        <ParameterValues>
                            <!-- Limit the duration to 55 h -->
                            <ParameterValueMagnitude Symbol="t1">
                                <SNumber>55</SNumber>
                            </ParameterValueMagnitude>
                            <!-- Set temperature to 298 K -->
                            <ParameterValueMagnitude Symbol="T1">
                                <SNumber>298</SNumber>
                            </ParameterValueMagnitude>
                        </ParameterValues>
                    </SymbolicFunction>
                </LoadQuantity>
            </Load>

            <!-- Environment temperature T2 = 423 K present for 350 h -->
            <Load Id="ID.Load.Env.1" ShortDescription="Environment temperature T2=423K">
                <LoadQuantity Id="ID.QLoad.Env.1" Symbol="T2">
                    <SymbolicFunction>
                        <!-- Fortunately, we can also re-use previously defined function templates -->
                        <SymbolicFunctionTemplateRef Ref="ID.Function-constant-temperature"/>

                        <!-- Assign values to the function template parameters -->
                        <ParameterValues>
                            <!-- Limit the duration to 350 hours -->
                            <ParameterValueMagnitude Symbol="t1">
                                <SNumber>350</SNumber>
                            </ParameterValueMagnitude>
                            <!-- Set temperature to 423K -->
                            <ParameterValueMagnitude Symbol="T1">
                                <SNumber>423</SNumber>
                            </ParameterValueMagnitude>
                        </ParameterValues>
                    </SymbolicFunction>
                </LoadQuantity>
            </Load>
        </Loads>
    </LoadDefinition>

    ...

</MPFo>

Action Definition¶

Description¶

The term Action is derived from the SysML item “Action” [SysML] where it specifies a distinguishable part of a sequence or cycle occurring over time. In the context of MPFO-XML, an Action defines an operating phase of a component completely by (1) combining port specific environmental loads and functional loads and (2) assigning these loads to component ports. By definition, actions are considered as independent from each other. Contrary to SysML, actions will not have the ability to receive external react triggers. The sequence of several actions is defined within the ActivityDefinition element (see Activity Definition).

Definition of ‘ActionDefinition’ Element¶

The ActionDefinition element holds one or more Action elements. The contents of the ActivityDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Definition of ‘Action’ Element¶

The Action element combines port specific environmental loads and functional loads of an operating phase and assigns these loads to component ports and/or port sets. If necessary, load sets and/or port sets can be defined that are local to the current Action element. See examples below.

Definition of ‘Assignment’ Element¶

The load assignment to component ports and/or port sets is done in the Assignment element. See examples below.

Examples¶

Example 1: Action Definition

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...
   <!-- Assign loads to ports -->
    <ActionDefinition>
        <Actions>
            <!-- Operating phase 1 (loads are assigned directly to the electrical ports for simplicity reasons) -->
            <Action Id="ID.Action.0" ShortDescription="Operating phase 1: Resistor operation at 298 K for 55 h">
                <Assignments>
                    <!-- Assign loads to port N1 -->
                    <Assignment Id="ID.Action.0.Assignment.N1">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N1"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.0"/>
                            <LoadRef Ref="ID.Load.Env.0"/>
                        </LoadRefs>
                    </Assignment>
                    <!-- Assign loads to port N2 -->
                    <Assignment Id="ID.Action.0.Assignment.N2">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N2"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.1"/>
                            <LoadRef Ref="ID.Load.Env.0"/>
                        </LoadRefs>
                    </Assignment>
                </Assignments>
            </Action>

            <!-- Operating phase 2 (loads are assigned directly to the electrical ports for simplicity reasons) -->
            <Action Id="ID.Action.1" ShortDescription="Operating phase 2: Resistor operation at 423 K for 350 h">
                <Assignments>
                    <!-- Assign loads to port N1 -->
                    <Assignment Id="ID.Action.1.Assignment.N1">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N1"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.0"/>
                            <LoadRef Ref="ID.Load.Env.1"/>
                        </LoadRefs>
                    </Assignment>
                    <!-- Assign loads to port N2 -->
                    <Assignment Id="ID.Action.1.Assignment.N2">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N2"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.1"/>
                            <LoadRef Ref="ID.Load.Env.1"/>
                        </LoadRefs>
                    </Assignment>
                </Assignments>
            </Action>
        </Actions>
    </ActionDefinition>
    ...
</MPFo>

Activity Definition¶

Description¶

The term Activity is derived from the SysML item “Activity” [SysML] where it specifies a transformation of inputs to outputs through a controlled sequence of actions. In the context of MPFO-XML, an Activity defines the sequence of linked actions and/or parallel activity sequences (see also Action Definition). Activities link several operating phases (i.e., Actions) to a sequence or flow.

Definition of ‘ActivityDefinition’ Element¶

The ActivityDefinition element holds one or more Activity elements.

In case the ActivityDefinition element is not defined in the MPFO-XML document, it is assumed that all defined actions are to be considered independently of their real sequence.

The contents of the ActivityDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Definition of ‘Activity’ Element¶

The Activity element references a single action.

Definition of ‘ActivityFlow’ Element¶

The ActivityFlow element defines a sequence of actions by defining a list of previous Action ID references of an Action element in the PreviousAction sub-element.

The creation of an action sequence is accomplished by the following rules:

If element attribute PreviousActionRef is undefined for an Activity element, the action referenced will then be linked to the implicitly existing START ID action element reference.

If an action is not referenced as predecessor of another action:

If the action itself is referencing another action, then it represents the end of an action sequence. It is then linked to the implicitly existing END ID action element reference.

If the action itself is not referencing another action, then it represents the start and end of an independent action sequence. It is then linked to the implicitly existing START ID and END ID action element references.

This back-reference approach allows the creation of action sequences. Action sequences can be split at an action A if at least two succeeding actions reference to action A. Two or more action sequences can be merged at an action A if action A references actions of preceding action sequences. The latter approach would also allow the creation of action sequence cycles.

Examples¶

Example 1: Activity Definition

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...
    <!-- Component activity definition: sequence of operating phases -->
    <ActivityDefinition>
        <!-- Define activities -->
        <Activities>
            <!-- Operating phase 1 -->
            <Activity Id="ID.Activity.0">
                <ActionSetRef Ref="ID.ActionSet.0"/>
            </Activity>
            <!-- Start operating phase 2 after operating phase 1 -->
            <Activity Id="ID.Activity.1">
                <ActionSetRef Ref="ID.ActionSet.1"/>
            </Activity>
        </Activities>
        <!-- Consider operating phase 2 to start after operating phase 1 -->
        <ActivityFlows>
            <ActivityFlow Id="ID.Activity.Flow.0">
                <ActivityRefs>
                    <ActivityRef Ref="ID.Activity.0"/>
                    <ActivityRef Ref="ID.Activity.1"/>
                </ActivityRefs>
            </ActivityFlow>
        </ActivityFlows>
        <!-- Define a activity flow set -->
        <ActivityFlowSets>
            <ActivityFlowSet Id="ID.Activity.FlowSet.0">
                <References>
                    <ActivityFlowRef Ref="ID.Activity.Flow.0"/>
                </References>
            </ActivityFlowSet>
        </ActivityFlowSets>
    </ActivityDefinition>
    ...
</MPFo>

Scenario Definition¶

Description¶

Scenarios combine activity flows to describe various application use cases.

Examples¶

Example 1: Scenario Definition

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">
    ...
    <!-- Component activity definition: sequence of operating phases -->
    <ActivityDefinition>
        <!-- Define activities -->
        <Activities>
            <!-- Operating phase 1 -->
            <Activity Id="ID.Activity.0">
                <ActionSetRef Ref="ID.ActionSet.0"/>
            </Activity>
            <!-- Start operating phase 2 after operating phase 1 -->
            <Activity Id="ID.Activity.1">
                <ActionSetRef Ref="ID.ActionSet.1"/>
            </Activity>
        </Activities>
        <!-- Consider operating phase 2 to start after operating phase 1 -->
        <ActivityFlows>
            <ActivityFlow Id="ID.Activity.Flow.0">
                <ActivityRefs>
                    <ActivityRef Ref="ID.Activity.0"/>
                    <ActivityRef Ref="ID.Activity.1"/>
                </ActivityRefs>
            </ActivityFlow>
        </ActivityFlows>
        <!-- Define a activity flow set -->
        <ActivityFlowSets>
            <ActivityFlowSet Id="ID.Activity.FlowSet.0">
                <References>
                    <ActivityFlowRef Ref="ID.Activity.Flow.0"/>
                </References>
            </ActivityFlowSet>
        </ActivityFlowSets>
    </ActivityDefinition>

    <!-- Define an activity scenario for the component and apply/use it -->
    <ScenarioDefinition>
        <!-- Define an application scenario with one activity flow -->
        <Scenarios>
            <Scenario Id="ID.Scenario.0">
                <ActivityFlowSetRefs>
                    <ActivityFlowSetRef Ref="ID.Activity.FlowSet.0"/>
                </ActivityFlowSetRefs>
            </Scenario>
        </Scenarios>
        <!-- Apply the scenarios -->
        <Application Id="ID.Scenario.Application">
            <ScenarioRefs>
                <ScenarioRef Ref="ID.Scenario.0"/>
            </ScenarioRefs>
        </Application>
    </ScenarioDefinition>
    ...
</MPFo>

Requirement Definition¶

Description¶

Container for mission profile and component related requirements. The contents of the RequirementDefinition element are ignored during the processing of MPFO-XML documents.

Definition of ‘RequirementDefinition’ Element¶

The RequirementDefinition element is formally defined here: RequirementDefinition

The only supported requirements format is currently the XML based REQ-IF foramt [REQ-IF]. The contents of the RequirementDefinition element can be encrypted using the W3C XML-encryption mechanism [XML-SEC].

Parsing Directives and Checks on Application Level¶

The contents of the RequirementDefinition element are ignored during the processing of MPFO-XML documents since the mission profile framework (MPFW) does not yet directly support the processing of REQ-IF documents.

Examples¶

Example 1: MPFO-XML document stub with include of externally defined requirements in REQ-IF format

<!-- Component definition as MPFO-XML mission profile document. -->
<MPFo Id="ID.COMPONENT.0">

    ...

    <!-- Definition of mission profile related requirements. -->
    <RequirementDefinition Id="ID.Requirement.1" Format="REQ-IF">
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="reqif_example_2.reqif"/>
    </RequirementDefinition>
</MPFo>

Example 2: MPFO-XML document stub with embedded and encrypted requirements in REQ-IF format

Todo

To be added!

Math Primitives Definition¶

Common Attributes¶

Formal definition (auto-generated documentation based on XSD file).

All mathematical and physical elements have the following attributes in common:

Id [xsd:ID] (optional) – Unique identifier of the element; used to reference elements
Label [xsd:string] (optional) – Element label
Description [xsd:string] (optional) – Element description

Strings¶

Formal definition (auto-generated documentation based on XSD file).

Strings are sequences of zero or more characters including tab, carriage return, line feed and unicode characters. See the XML Schema string datatype definition for more information.

Example:

“Pin 1”

<String>Pin 1</String>

Validation:

This type is validated using the XML Schema file.

Numbers¶

Simple Numbers¶

Formal definition (auto-generated documentation based on XSD file).

Decimal numbers can be defined using <SNumber>. See the XML Schema decimal datatype definition for more information.

Example:

\[1.2\]

<SNumber>1.2</SNumber>

Validation:

This type is validated using the XML Schema file.

MathML Numbers¶

Formal definition (auto-generated documentation based on XSD file).

Other types of numbers can be represented using Strict Content MathML and OpenMath.

Note

Strict Content MathML elements are validated using the official RelaxNG schema via mpfo.nvdl. The content of <MNumber> elements is validated using the Schematron schema mpfo.sch.

Integers¶

An integer is represented by an optional sign followed by a string of one or more decimal digits (Source).

Example:

\[5\]

<MNumber>
    <mml:math>
        <mml:cn type="integer">5</mml:cn>
    </mml:math>
</MNumber>

Validation:

Attention

The content of <mml:cn> elements is currently not validated.

Rational Numbers¶

A rational number can be expressed as a quotient of two integers (Source).

Example:

\[\frac{4}{5}\]

<MNumber>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="nums1">rational</mml:csymbol>
            <mml:cn type="integer">4</mml:cn>
            <mml:cn type="integer">5</mml:cn>
        </mml:apply>
    </mml:math>
</MNumber>

Validation:

This type is validated using the Schematron schema mpfo.sch which checks the structure of <mml:*> elements and that the second integer (denominator) is not zero.

Attention

The content of <mml:cn> elements is currently not validated (besides the mentioned test for zero).

Real Numbers¶

A real number consists of an optional sign (“+” or “-“) followed by a string of digits possibly separated into an integer and a fractional part by a decimal point (Source).

Example:

\[0.3\]

<MNumber>
    <mml:math>
        <mml:cn type="real">0.3</mml:cn>
    </mml:math>
</MNumber>

Validation:

Attention

The content of <mml:cn> elements is currently not validated.

Double-Precision Floating-Point Numbers¶

MPFO allows the definition of floating-point numbers according to standard IEEE 754. This includes a subset of real numbers, \(-0\), \(+\infty\), \(-\infty\), and values for “not a number” (NaN) (Source 1, Source 2).

Example:

\[-1\cdot 10^4\]

<MNumber>
    <mml:math>
        <mml:cn type="double">-1E4</mml:cn>
    </mml:math>
</MNumber>

Other examples for valid numbers include: 1267.43233E12, 12.78e-2, 12, -0, 0, INF

The 64 bits of a double-precision floating-point number as prescribed by IEEE 754 may also be written as 16 digit hexadecimal number (Source).

Example:

\[\text{NaN}\]

<MNumber>
    <mml:math>
        <mml:cn type="hexdouble">0x7F800000</mml:cn>
    </mml:math>
</MNumber>

Validation:

Attention

The content of <mml:cn> elements is currently not validated.

Complex Numbers¶

A complex number is represented by two real numbers: the real part and the imaginary part (Source).

Example:

\[3.2+1.6i\]

<MNumber>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="complex1">complex_cartesian</mml:csymbol>
            <mml:cn type="real">3.2</mml:cn>
            <mml:cn type="real">1.6</mml:cn>
        </mml:apply>
    </mml:math>
</MNumber>

Validation:

Attention

The content of <mml:cn> elements is currently not validated.

Tolerances¶

Formal definition (auto-generated documentation based on XSD file).

Tolerances define the acceptable deviation from a nominal value and comprise a lower and upper bound. Each bound may be an absolute value or relative to the nominal value.

Every <Tolerance> element must contain one <LowerBound> and one <UpperBound> element. They have one mandatory attribute BoundType which is either “absolute” or “relative” and contain either one <SNumber> or one <MNumber> element.

Example:

\[\pm 0.1\]

<Tolerance>
    <LowerBound BoundType="absolute">
        <SNumber>0.1</SNumber>
    </LowerBound>
    <UpperBound BoundType="absolute">
        <SNumber>0.1</SNumber>
    </UpperBound>
</Tolerance>

Example:

\[^{+5\%}_{-0\%}\]

<Tolerance>
    <LowerBound BoundType="relative">
        <SNumber>0</SNumber>
    </LowerBound>
    <UpperBound BoundType="relative">
        <SNumber>0.05</SNumber>
    </UpperBound>
</Tolerance>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Toleranced Numbers¶

Formal definition (auto-generated documentation based on XSD file).

A toleranced number consists of a number and a tolerance. The number can be specified using <SNumber> or <MNumber> (see Simple Numbers and MathML Numbers for details).

Example:

\[1.5\pm 0.1\]

<TolerancedNumber>
    <SNumber>1.5</SNumber>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
</TolerancedNumber>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Units¶

Formal definition (auto-generated documentation based on XSD file).

Units are represented using Strict Content MathML and OpenMath.

Note

Strict Content MathML elements are validated using the official RelaxNG schema via mpfo.nvdl.

Attention

Content dictionaries and their entries are currently not validated.

Simple Units¶

Simple units comprise a single unit from one of the OpenMath content dictionaries without a prefix.

Example:

meter (m)

<Unit>
    <mml:math>
        <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
    </mml:math>
</Unit>

Prefixes¶

Unit prefixes are defined by applying the prefix operator from the units_ops1 content dictionary to a prefix from the units_siprefix1 content dictionary and a simple unit.

Supported prefixes: atto, centi, deci, deka, exa, femto, giga, hecto, kilo, mega, micro, milli, nano, peta, pico, tera, yocto, yotta, zepto, zetta

Example:

kilometre (km)

<Unit>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="units_ops1">prefix</mml:csymbol>
            <mml:csymbol cd="units_siprefix1">kilo</mml:csymbol>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:apply>
    </mml:math>
</Unit>

Compound Units¶

Compound units are formed by powers, products or quotients of simple units. The arith1 content dictionary contains the relevant arithmetic functions.

Example:

newton metre (N m)

<Unit>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="arith1">times</mml:csymbol>
            <mml:csymbol cd="SI_NamedDerivedUnits1">newton</mml:csymbol>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:apply>
    </mml:math>
</Unit>

Example:

cubic metre (m³)

<Unit>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="arith1">power</mml:csymbol>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            <mml:cn type="integer">3</mml:cn>
        </mml:apply>
    </mml:math>
</Unit>

Example:

litre per 100 km (l/100 km)

<Unit>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="arith1">divide</mml:csymbol>
            <mml:csymbol cd="SIUsed_OffSystemUnits1">litre</mml:csymbol>
            <mml:apply>
                <mml:csymbol cd="arith1">times</mml:csymbol>
                <mml:cn type="integer">100</mml:cn>
                <mml:apply>
                    <mml:csymbol cd="units_ops1">prefix</mml:csymbol>
                    <mml:csymbol cd="units_siprefix1">kilo</mml:csymbol>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:apply>
            </mml:apply>
        </mml:apply>
    </mml:math>
</Unit>

Supported Units¶

OpenMath defines units in multiple content dictionaries.

OpenMath content dictionaries related to units.¶
Content dictionary	Selection of supported units
SI_BaseUnits1	ampere, candela, kelvin, kilogram, metre, mole, one (dimensionless), second
SI_NamedDerivedUnits1	becquerel, coulomb, degree celsius, farad, gram, gray, henry, hertz, joule, katal, lumen, lux, newton, ohm, pascal, radian, siemens, sievert, steradian, tesla, volt, watt, weber
SIUsed_OffSystemUnits1	bel, day, degree of arc, hour, litre, minute, minute of arc, neper, second of arc, tonne

Quantities¶

Formal definition (auto-generated documentation based on XSD file).

A quantity consists of a number and a unit.

Example:

4.4 litre per 100 km (4.4 l/100 km)

<Quantity>
    <SNumber>4.4</SNumber>
    <Unit>
        <mml:math>
            <mml:apply>
                <mml:csymbol cd="arith1">divide</mml:csymbol>
                <mml:csymbol cd="SIUsed_OffSystemUnits1">litre</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">times</mml:csymbol>
                    <mml:cn type="integer">100</mml:cn>
                    <mml:apply>
                        <mml:csymbol cd="units_ops1">prefix</mml:csymbol>
                        <mml:csymbol cd="units_siprefix1">kilo</mml:csymbol>
                        <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
        </mml:math>
    </Unit>
</Quantity>

Validation:

This type is validated using the XML Schema file.

Attention

See Numbers and Units for details about validation of <SNumber>, <MNumber>, and <Unit> elements.

Toleranced Quantities¶

Formal definition (auto-generated documentation based on XSD file).

A toleranced quantity consists of a number, a tolerance and a unit.

Example:

(4.4 \(\pm\) 1.0) litre per 100 km ((4.4 \(\pm\) 1.0) l/100 km)

<TolerancedQuantity>
    <SNumber>4.4</SNumber>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>1.0</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>1.0</SNumber>
        </UpperBound>
    </Tolerance>
    <Unit>
        <mml:math>
            <mml:apply>
                <mml:csymbol cd="arith1">divide</mml:csymbol>
                <mml:csymbol cd="SIUsed_OffSystemUnits1">litre</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">times</mml:csymbol>
                    <mml:cn type="integer">100</mml:cn>
                    <mml:apply>
                        <mml:csymbol cd="units_ops1">prefix</mml:csymbol>
                        <mml:csymbol cd="units_siprefix1">kilo</mml:csymbol>
                        <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
        </mml:math>
    </Unit>
</TolerancedQuantity>

Validation:

This type is validated using the XML Schema file.

Attention

See Numbers, Tolerances, and Units for details about validation of <SNumber>, <MNumber>, <Tolerance>, and <Unit> elements.

Intervals¶

An interval defines a set of numbers or quantities between a lower endpoint and an upper endpoint. Every <*Interval> element must contain one <LowerBound> and one <UpperBound> element. They have one mandatory attribute BoundType which is either “open” (interval does not include the endpoint) or “closed” (interval includes the endpoint).

Number Intervals¶

Formal definition (auto-generated documentation based on XSD file).

Number intervals have endpoints that are either <SNumber> or <MNumber> elements.

Example:

(1.0, 10.0) (open interval that does not include its endpoints)

<NumberInterval>
    <LowerBound BoundType="open">
        <SNumber>1.0</SNumber>
    </LowerBound>
    <UpperBound BoundType="open">
        <SNumber>10.0</SNumber>
    </UpperBound>
</NumberInterval>

Example:

[1.0, 10.0] (closed interval that does include its endpoints)

<NumberInterval>
    <LowerBound BoundType="closed">
        <SNumber>1.0</SNumber>
    </LowerBound>
    <UpperBound BoundType="closed">
        <SNumber>10.0</SNumber>
    </UpperBound>
</NumberInterval>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Toleranced Number Intervals¶

Formal definition (auto-generated documentation based on XSD file).

Toleranced number intervals have endpoints that are <TolerancedNumber> elements.

Example:

\[\left[1.0\pm 0.1, 10.0\pm 0.1\right] \text{(closed interval that does include its endpoints)}\]

<TolerancedNumberInterval>
    <LowerBound BoundType="closed">
        <TolerancedNumber>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
        </TolerancedNumber>
    </LowerBound>
    <UpperBound BoundType="closed">
        <TolerancedNumber>
            <SNumber>10.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
        </TolerancedNumber>
    </UpperBound>
</TolerancedNumberInterval>

This type is validated using the XML Schema file.

Attention

See Toleranced Numbers for details about <TolerancedNumber> element validation.

Quantity Intervals¶

Formal definition (auto-generated documentation based on XSD file).

Quantity intervals have endpoints that are <Quantity> elements.

Example:

\[\left[1.0\,\text{m}, 10.0\,\text{m}\right] \text{(closed interval that does include its endpoints)}\]

<QuantityInterval>
    <LowerBound BoundType="closed">
        <Quantity>
            <SNumber>1.0</SNumber>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </Quantity>
    </LowerBound>
    <UpperBound BoundType="closed">
        <Quantity>
            <SNumber>10.0</SNumber>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </Quantity>
    </UpperBound>
</QuantityInterval>

This type is validated using the XML Schema file.

Attention

See Quantities for details about <Quantity> element validation.

Toleranced Quantity Intervals¶

Formal definition (auto-generated documentation based on XSD file).

Toleranced quantity intervals have endpoints that are <TolerancedQuantity> elements.

\[\left[(1.0\pm 0.1)\,\text{m}, (10.0\pm 0.1)\,\text{m}\right] \text{(closed interval that does include its endpoints)}\]

<TolerancedQuantityInterval>
    <LowerBound BoundType="closed">
        <TolerancedQuantity>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </TolerancedQuantity>
    </LowerBound>
    <UpperBound BoundType="closed">
        <TolerancedQuantity>
            <SNumber>10.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </TolerancedQuantity>
    </UpperBound>
</TolerancedQuantityInterval>

This type is validated using the XML Schema file.

Attention

See Toleranced Quantities for details about <TolerancedQuantity> element validation.

Vectors¶

Vectors are ordered lists of elements.

String Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A string vector consists of one or more Strings.

Example:

\[\begin{split}\begin{pmatrix}\text{"Pin 1"} \\ \text{"Pin 2"} \\ \text{"Pin 3"}\end{pmatrix}\end{split}\]

<StringVector>
    <String>Pin 1</String>
    <String>Pin 2</String>
    <String>Pin 3</String>
</StringVector>

Validation:

This type is validated using the XML Schema file.

Number Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A number vector consists of one or more Numbers. It may contain both, <SNumber> and <MNumber> elements.

Example:

\[\begin{split}\begin{pmatrix}1.0 \\ 1.5 \\ 2.0\end{pmatrix}\end{split}\]

<NumberVector>
    <SNumber>1.0</SNumber>
    <SNumber>1.5</SNumber>
    <SNumber>2.0</SNumber>
</NumberVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Number Interval Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A number interval vector consists of one or more Number Intervals.

Example:

\[\begin{split}\begin{pmatrix}(0.0, 1.0) \\ (0.0, 1.5) \\ (0.0, 2.0)\end{pmatrix}\end{split}\]

<NumberIntervalVector>
    <NumberInterval>
        <LowerBound BoundType="closed">
            <SNumber>0.0</SNumber>
        </LowerBound>
        <UpperBound BoundType="closed">
            <SNumber>1.0</SNumber>
        </UpperBound>
    </NumberInterval>
    <NumberInterval>
        <LowerBound BoundType="closed">
            <SNumber>0.0</SNumber>
        </LowerBound>
        <UpperBound BoundType="closed">
            <SNumber>1.5</SNumber>
        </UpperBound>
    </NumberInterval>
    <NumberInterval>
        <LowerBound BoundType="closed">
            <SNumber>0.0</SNumber>
        </LowerBound>
        <UpperBound BoundType="closed">
            <SNumber>2.0</SNumber>
        </UpperBound>
    </NumberInterval>
</NumberIntervalVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Number Intervals for details about <NumberInterval> element validation.

Tolerance Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A tolerance vector consists of one or more Tolerances.

Example:

\[\begin{split}\begin{pmatrix}\pm 0.1 \\ \pm 0.15 \\ \pm 0.2\end{pmatrix}\end{split}\]

<ToleranceVector>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.15</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.15</SNumber>
        </UpperBound>
    </Tolerance>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.2</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.2</SNumber>
        </UpperBound>
    </Tolerance>
</ToleranceVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Tolerances for details about <Tolerance> element validation.

Toleranced Number Vectors¶

Formal definition (auto-generated documentation based on XSD file).

Vectors of toleranced numbers comprise a number vector (or sparse number vector) and a tolerance vector (or sparse tolerance vector). If all tolerances are equal, a single tolerance may be used instead of a vector.

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 \\ 1.5\pm 0.15 \\ 2.0\pm 0.2\end{pmatrix}\end{split}\]

<TolerancedNumberVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <ToleranceVector>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </UpperBound>
        </Tolerance>
    </ToleranceVector>
</TolerancedNumberVector>

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 \\ 1.5\pm 0.1 \\ 2.0\pm 0.1\end{pmatrix}\end{split}\]

<TolerancedNumberVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
</TolerancedNumberVector>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberVector> and <ToleranceVector> have the same number of child elements.

Attention

See Number Vectors, Tolerance Vectors, and Tolerances for details about <NumberVector>, <ToleranceVector>, and <Tolerance> element validation.

Unit Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A unit vector consists of one or more Units.

Example:

\[\begin{split}\begin{pmatrix}\text{m} \\ \text{s} \\ \text{g}\end{pmatrix}\end{split}\]

<UnitVector>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:math>
    </Unit>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
        </mml:math>
    </Unit>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
        </mml:math>
    </Unit>
</UnitVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Units for details about <Unit> element validation.

Quantity Vectors¶

Formal definition (auto-generated documentation based on XSD file).

Quantity vectors comprise a number vector (or sparse number vector) and a unit vector (or sparse unit vector). If all quantities have the same unit, a single unit may be used instead of a vector.

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} \\ 1.5\,\text{s} \\ 2.0\,\text{g}\end{pmatrix}\end{split}\]

<QuantityVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <UnitVector>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
            </mml:math>
        </Unit>
    </UnitVector>
</QuantityVector>

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} \\ 1.5\,\text{m} \\ 2.0\,\text{m}\end{pmatrix}\end{split}\]

<QuantityVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:math>
    </Unit>
</QuantityVector>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberVector> and <UnitVector> have the same number of child elements.

Attention

See Number Vectors, Unit Vectors, and Units for details about <NumberVector>, <UnitVector>, and <Unit> element validation.

Toleranced Quantity Vectors¶

Formal definition (auto-generated documentation based on XSD file).

Vectors of toleranced quantities comprise a number vector (or sparse number vector), a tolerance vector (or sparse tolerance vector), and a unit vector (or sparse unit vector). If all quantities have the same tolerance/unit, a single tolerance/unit may be used instead of a vector.

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} \\ (1.5\pm 0.15)\,\text{s} \\ (2.0\pm 0.2)\,\text{g}\end{pmatrix}\end{split}\]

<TolerancedQuantityVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <ToleranceVector>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </UpperBound>
        </Tolerance>
    </ToleranceVector>
    <UnitVector>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
            </mml:math>
        </Unit>
    </UnitVector>
</TolerancedQuantityVector>

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} \\ (1.5\pm 0.1)\,\text{m} \\ (2.0\pm 0.1)\,\text{m}\end{pmatrix}\end{split}\]

<TolerancedQuantityVector>
    <NumberVector>
        <SNumber>1.0</SNumber>
        <SNumber>1.5</SNumber>
        <SNumber>2.0</SNumber>
    </NumberVector>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:math>
    </Unit>
</TolerancedQuantityVector>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberVector>, <ToleranceVector>, and <UnitVector> have the same number of child elements.

Attention

See Number Vectors, Tolerance Vectors, Unit Vectors, Tolerances, and Units for details about <NumberVector>, <ToleranceVector>, <UnitVector>, <Tolerance> and <Unit> element validation.

Sparse Vectors¶

Just like normal vectors, sparse vectors are ordered list of elements. In a sparse vector, most elements have the same value. Therefore, for each sparse vector, a default value is specified, as well as all elements that are not equal to this default value.

All types of sparse vectors share the same structure:

Attributes:
- ElementCount [xsd:positiveInteger] – number of elements in the sparse vector
DefaultElement – default element
- element (by value or by reference)
Elements
- Element (1..∞):
  
  Attributes:
  
  Index [xsd:positiveInteger] – one-based index of the element
  
  element (by value or by reference)

Sparse String Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse string vector consists of one or more Strings.

Example:

\[\begin{split}\begin{pmatrix}\text{"Vdd"} \\ \text{"Vdd"} \\ \text{"Vss"}\end{pmatrix}\end{split}\]

<StringSparseVector ElementCount="3">
    <DefaultElement>
        <String>Vdd</String>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <String>Vss</String>
        </Element>
    </Elements>
</StringSparseVector>

Validation:

This type is validated using the XML Schema file.

Sparse Number Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse number vector consists of one or more Numbers. It may contain both, <SNumber> and <MNumber> elements.

Example:

\[\begin{split}\begin{pmatrix}1.0 \\ 1.0 \\ 2.0\end{pmatrix}\end{split}\]

<NumberSparseVector ElementCount="3">
    <DefaultElement>
        <SNumber>1.0</SNumber>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <SNumber>2.0</SNumber>
        </Element>
    </Elements>
</NumberSparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Sparse Tolerance Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse tolerance vector consists of one or more Tolerances.

Example:

\[\begin{split}\begin{pmatrix}\pm 0.1 \\ \pm 0.1 \\ \pm 0.2\end{pmatrix}\end{split}\]

<ToleranceSparseVector ElementCount="3">
    <DefaultElement>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </UpperBound>
        </Tolerance>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
        </Element>
    </Elements>
</ToleranceSparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Tolerances for details about <Tolerance> element validation.

Sparse Toleranced Number Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse toleranced number vector consists of one or more Toleranced Numbers.

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 \\ 1.0\pm 0.1 \\ 2.0\pm 0.2\end{pmatrix}\end{split}\]

<TolerancedNumberSparseVector ElementCount="3">
    <DefaultElement>
        <TolerancedNumber>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
        </TolerancedNumber>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <TolerancedNumber>
                <SNumber>2.0</SNumber>
                <Tolerance>
                    <LowerBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </UpperBound>
                </Tolerance>
            </TolerancedNumber>
        </Element>
    </Elements>
</TolerancedNumberSparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Toleranced Numbers for details about <TolerancedNumber> element validation.

Sparse Unit Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse unit vector consists of one or more Units.

Example:

\[\begin{split}\begin{pmatrix}\text{m} \\ \text{m} \\ \text{g}\end{pmatrix}\end{split}\]

<UnitSparseVector ElementCount="3">
    <DefaultElement>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            </mml:math>
        </Unit>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                </mml:math>
            </Unit>
        </Element>
    </Elements>
</UnitSparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Units for details about <Unit> element validation.

Sparse Quantity Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse quantity vector consists of one or more Quantities.

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} \\ 1.0\,\text{m} \\ 2.0\,\text{g}\end{pmatrix}\end{split}\]

<QuantitySparseVector ElementCount="3">
    <DefaultElement>
        <Quantity>
            <SNumber>1.0</SNumber>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </Quantity>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <Quantity>
                <SNumber>2.0</SNumber>
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                    </mml:math>
                </Unit>
            </Quantity>
        </Element>
    </Elements>
</QuantitySparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Quantities for details about <Quantity> element validation.

Sparse Toleranced Quantity Vectors¶

Formal definition (auto-generated documentation based on XSD file).

A sparse vector of toleranced quantities consists of Toleranced Quantities.

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} \\ (1.0\pm 0.1)\,\text{m} \\ (2.0\pm 0.2)\,\text{g}\end{pmatrix}\end{split}\]

<TolerancedQuantitySparseVector ElementCount="3">
    <DefaultElement>
        <TolerancedQuantity>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </TolerancedQuantity>
    </DefaultElement>
    <Elements>
        <Element Index="3">
            <TolerancedQuantity>
                <SNumber>2.0</SNumber>
                <Tolerance>
                    <LowerBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </UpperBound>
                </Tolerance>
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                    </mml:math>
                </Unit>
            </TolerancedQuantity>
        </Element>
    </Elements>
</TolerancedQuantitySparseVector>

Validation:

This type is validated using the XML Schema file.

Attention

See Toleranced Quantities for details about <TolerancedQuantity> element validation.

Matrices¶

Matrices are 2-dimensional arrays of elements. They consist of one or more matrix rows, each of which contains one or more elements.

Note

The Schematron schema file checks that all rows of a matrix have the same number of child elements.

String Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A string matrix consists of one or more rows of Strings.

Example:

\[\begin{split}\begin{pmatrix}\text{"Pin 11"} & \text{"Pin 12"} \\ \text{"Pin 21"} & \text{"Pin 22"} \\ \text{"Pin 31"} & \text{"Pin 32"} \end{pmatrix}\end{split}\]

<StringMatrix>
    <StringMatrixRow>
        <String>Pin 11</String>
        <String>Pin 12</String>
    </StringMatrixRow>
    <StringMatrixRow>
        <String>Pin 21</String>
        <String>Pin 22</String>
    </StringMatrixRow>
    <StringMatrixRow>
        <String>Pin 31</String>
        <String>Pin 32</String>
    </StringMatrixRow>
</StringMatrix>

Validation:

This type is validated using the XML Schema file.

Number Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A number matrix consists of one or more rows of Numbers. Each row may contain both, <SNumber> and <MNumber> elements.

Example:

\[\begin{split}\begin{pmatrix}1.0 & 2.0 \\ 1.5 & 3.0 \\ 2.0 & 4.0 \end{pmatrix}\end{split}\]

<NumberMatrix>
    <NumberMatrixRow>
        <SNumber>1.0</SNumber>
        <SNumber>2.0</SNumber>
    </NumberMatrixRow>
    <NumberMatrixRow>
        <SNumber>1.5</SNumber>
        <SNumber>3.0</SNumber>
    </NumberMatrixRow>
    <NumberMatrixRow>
        <SNumber>2.0</SNumber>
        <SNumber>4.0</SNumber>
    </NumberMatrixRow>
</NumberMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Tolerance Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A tolerance matrix consists of one or more rows of Tolerances.

Example:

\[\begin{split}\begin{pmatrix}\pm 0.1 & \pm 0.2 \\ \pm 0.15 & \pm 0.3 \\ \pm 0.2 & \pm 0.4 \end{pmatrix}\end{split}\]

<ToleranceMatrix>
    <ToleranceMatrixRow>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </UpperBound>
        </Tolerance>
    </ToleranceMatrixRow>
    <ToleranceMatrixRow>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.15</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.3</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.3</SNumber>
            </UpperBound>
        </Tolerance>
    </ToleranceMatrixRow>
    <ToleranceMatrixRow>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.2</SNumber>
            </UpperBound>
        </Tolerance>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.4</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.4</SNumber>
            </UpperBound>
        </Tolerance>
    </ToleranceMatrixRow>
</ToleranceMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Tolerances for details about <Tolerance> element validation.

Toleranced Number Matrices¶

Formal definition (auto-generated documentation based on XSD file).

Matrices of toleranced numbers comprise a number matrix (or sparse number matrix) and a tolerance matrix (or sparse tolerance matrix). If all tolerances are equal, a single tolerance may be used instead of a matrix.

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 & 2.0\pm 0.2\\ 1.5\pm 0.15 & 3.0\pm 0.3 \\ 2.0\pm 0.2 & 4.0\pm 0.4 \end{pmatrix}\end{split}\]

<TolerancedNumberMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <ToleranceMatrix>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.15</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.15</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.3</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.3</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.4</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.4</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
    </ToleranceMatrix>
</TolerancedNumberMatrix>

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 & 2.0\pm 0.1 \\ 1.5\pm 0.1 & 3.0\pm 0.1 \\ 2.0\pm 0.1 & 4.0\pm 0.1\end{pmatrix}\end{split}\]

<TolerancedNumberMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
</TolerancedNumberMatrix>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberMatrix> and <ToleranceMatrix> have the same dimension.

Attention

See Number Matrices, Tolerance Matrices, and Tolerances for details about <NumberMatrix>, <ToleranceMatrix>, and <Tolerance> element validation.

Unit Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A unit matrix consists of one or more rows of Units.

Example:

\[\begin{split}\begin{pmatrix}\text{m} & \text{A} \\ \text{s} & \text{V} \\ \text{g} & \text{F} \end{pmatrix}\end{split}\]

<UnitMatrix>
    <UnitMatrixRow>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">ampere</mml:csymbol>
            </mml:math>
        </Unit>
    </UnitMatrixRow>
    <UnitMatrixRow>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
            </mml:math>
        </Unit>
    </UnitMatrixRow>
    <UnitMatrixRow>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
            </mml:math>
        </Unit>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">farad</mml:csymbol>
            </mml:math>
        </Unit>
    </UnitMatrixRow>
</UnitMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Units for details about <Unit> element validation.

Quantity Matrices¶

Formal definition (auto-generated documentation based on XSD file).

Quantity matrices comprise a number matrix (or sparse number matrix) and a unit matrix (or sparse unit matrix). If all quantities have the same unit, a single unit may be used instead of a matrix.

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} & 2.0\,\text{A} \\ 1.5\,\text{s} & 3.0\,\text{V} \\ 2.0\,\text{g} & 4.0\,\text{F}\end{pmatrix}\end{split}\]

<QuantityMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <UnitMatrix>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">ampere</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">farad</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
    </UnitMatrix>
</QuantityMatrix>

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} & 2.0\,\text{m} \\ 1.5\,\text{m} & 3.0\,\text{m} \\ 2.0\,\text{m} & 4.0\,\text{m}\end{pmatrix}\end{split}\]

<QuantityMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:math>
    </Unit>
</QuantityMatrix>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberMatrix> and <UnitMatrix> have the same dimension.

Attention

See Number Matrices, Unit Matrices, and Units for details about <NumberMatrix>, <UnitMatrix>, and <Unit> element validation.

Toleranced Quantity Matrices¶

Formal definition (auto-generated documentation based on XSD file).

Matrices of toleranced quantities comprise a number matrix (or sparse number matrix), a tolerance matrix (or sparse tolerance matrix), and a unit matrix (or sparse unit matrix). If all quantities have the same tolerance/unit, a single tolerance/unit may be used instead of a matrix.

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} & (2.0\pm 0.2)\,\text{A} \\ (1.5\pm 0.15)\,\text{s} & (3.0\pm 0.3)\,\text{V} \\ (2.0\pm 0.2)\,\text{g} & (4.0\pm 0.4)\,\text{F}\end{pmatrix}\end{split}\]

<TolerancedQuantityMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <ToleranceMatrix>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.15</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.15</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.3</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.3</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
        <ToleranceMatrixRow>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.4</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.4</SNumber>
                </UpperBound>
            </Tolerance>
        </ToleranceMatrixRow>
    </ToleranceMatrix>
    <UnitMatrix>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">ampere</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
        <UnitMatrixRow>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                </mml:math>
            </Unit>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">farad</mml:csymbol>
                </mml:math>
            </Unit>
        </UnitMatrixRow>
    </UnitMatrix>
</TolerancedQuantityMatrix>

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} & (2.0\pm 0.1)\,\text{m} \\ (1.5\pm 0.1)\,\text{m} & (3.0\pm 0.1)\,\text{m} \\ (2.0\pm 0.1)\,\text{m} & (4.0\pm 0.1)\,\text{m}\end{pmatrix}\end{split}\]

<TolerancedQuantityMatrix>
    <NumberMatrix>
        <NumberMatrixRow>
            <SNumber>1.0</SNumber>
            <SNumber>2.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>1.5</SNumber>
            <SNumber>3.0</SNumber>
        </NumberMatrixRow>
        <NumberMatrixRow>
            <SNumber>2.0</SNumber>
            <SNumber>4.0</SNumber>
        </NumberMatrixRow>
    </NumberMatrix>
    <Tolerance>
        <LowerBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </LowerBound>
        <UpperBound BoundType="absolute">
            <SNumber>0.1</SNumber>
        </UpperBound>
    </Tolerance>
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
        </mml:math>
    </Unit>
</TolerancedQuantityMatrix>

Validation:

This type is validated using the XML Schema file. The Schematron schema file checks that <NumberMatrix>, <ToleranceMatrix>, and <UnitMatrix> have the same dimension.

Attention

See Number Matrices, Tolerance Matrices, Unit Matrices, Tolerances, and Units for details about <NumberMatrix>, <ToleranceMatrix>, <UnitMatrix>, <Tolerance> and <Unit> element validation.

Sparse Matrices¶

Just like normal matrices, sparse matrices are 2-dimensional arrays of elements. In a sparse matrix, most elements have the same value. Therefore, for each sparse matrix, a default value is specified, as well as all elements that are not equal to this default value.

All types of sparse matrices share the same structure:

Attributes:
- RowCount [xsd:positiveInteger] – number of rows in the sparse matrix
- ColumnCount [xsd:positiveInteger] – number of columns in the sparse matrix
DefaultElement – default element
- element (by value or by reference)
Elements
- Element (1..∞):
  
  Attributes:
  
  RowIndex [xsd:positiveInteger] – one-based row index of the element
  
  ColumnIndex [xsd:positiveInteger] – one-based column index of the element
  
  element (by value or by reference)

Sparse String Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse string matrix consists of one or more rows of Strings.

Example:

\[\begin{split}\begin{pmatrix}\text{"Vdd"} & \text{"Vdd"} \\ \text{"Vdd"} & \text{"Vdd"} \\ \text{"Vss"} & \text{"Vdd"} \end{pmatrix}\end{split}\]

<StringSparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <String>Vdd</String>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <String>Vss</String>
        </Element>
    </Elements>
</StringSparseMatrix>

Validation:

This type is validated using the XML Schema file.

Sparse Number Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse number matrix consists of one or more rows of Numbers. Each row may contain both, <SNumber> and <MNumber> elements.

Example:

\[\begin{split}\begin{pmatrix}1.0 & 1.0 \\ 1.0 & 1.0 \\ 2.0 & 1.0 \end{pmatrix}\end{split}\]

<NumberSparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <SNumber>1.0</SNumber>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <SNumber>2.0</SNumber>
        </Element>
    </Elements>
</NumberSparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Simple Numbers and MathML Numbers for details about <SNumber> and <MNumber> element validation.

Sparse Tolerance Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse tolerance matrix consists of one or more rows of Tolerances.

Example:

\[\begin{split}\begin{pmatrix}\pm 0.1 & \pm 0.1 \\ \pm 0.1 & \pm 0.1 \\ \pm 0.2 & \pm 0.1 \end{pmatrix}\end{split}\]

<ToleranceSparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <Tolerance>
            <LowerBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </LowerBound>
            <UpperBound BoundType="absolute">
                <SNumber>0.1</SNumber>
            </UpperBound>
        </Tolerance>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.2</SNumber>
                </UpperBound>
            </Tolerance>
        </Element>
    </Elements>
</ToleranceSparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Tolerances for details about <Tolerance> element validation.

Sparse Toleranced Number Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse toleranced number matrix consists of one or more rows of Toleranced Numbers.

Example:

\[\begin{split}\begin{pmatrix}1.0\pm 0.1 & 1.0\pm 0.1 \\ 1.0\pm 0.1 & 1.0\pm 0.1 \\ 2.0\pm 0.2 & 1.0\pm 0.1 \end{pmatrix}\end{split}\]

<TolerancedNumberSparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <TolerancedNumber>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
        </TolerancedNumber>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <TolerancedNumber>
                <SNumber>2.0</SNumber>
                <Tolerance>
                    <LowerBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </UpperBound>
                </Tolerance>
            </TolerancedNumber>
        </Element>
    </Elements>
</TolerancedNumberSparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Toleranced Numbers for details about <TolerancedNumber> element validation.

Sparse Unit Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse unit matrix consists of one or more rows of Units.

Example:

\[\begin{split}\begin{pmatrix}\text{m} & \text{m} \\ \text{m} & \text{m} \\ \text{g} & \text{m} \end{pmatrix}\end{split}\]

<UnitSparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
            </mml:math>
        </Unit>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                </mml:math>
            </Unit>
        </Element>
    </Elements>
</UnitSparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Units for details about <Unit> element validation.

Sparse Quantity Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse quantity matrix consists of one or more rows of Quantities.

Example:

\[\begin{split}\begin{pmatrix}1.0\,\text{m} & 1.0\,\text{m} \\ 1.0\,\text{m} & 1.0\,\text{m} \\ 2.0\,\text{g} & 1.0\,\text{m} \end{pmatrix}\end{split}\]

<QuantitySparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <Quantity>
            <SNumber>1.0</SNumber>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </Quantity>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <Quantity>
                <SNumber>2.0</SNumber>
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                    </mml:math>
                </Unit>
            </Quantity>
        </Element>
    </Elements>
</QuantitySparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Quantities for details about <Quantity> element validation.

Sparse Toleranced Quantity Matrices¶

Formal definition (auto-generated documentation based on XSD file).

A sparse toleranced quantity matrix consists of one or more rows of Toleranced Quantities.

Example:

\[\begin{split}\begin{pmatrix}(1.0\pm 0.1)\,\text{m} & (1.0\pm 0.1)\,\text{m} \\ (1.0\pm 0.1)\,\text{m} & (1.0\pm 0.1)\,\text{m} \\ (2.0\pm 0.2)\,\text{g} & (1.0\pm 0.1)\,\text{m} \end{pmatrix}\end{split}\]

<TolerancedQuantitySparseMatrix RowCount="3" ColumnCount="2">
    <DefaultElement>
        <TolerancedQuantity>
            <SNumber>1.0</SNumber>
            <Tolerance>
                <LowerBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </LowerBound>
                <UpperBound BoundType="absolute">
                    <SNumber>0.1</SNumber>
                </UpperBound>
            </Tolerance>
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">metre</mml:csymbol>
                </mml:math>
            </Unit>
        </TolerancedQuantity>
    </DefaultElement>
    <Elements>
        <Element RowIndex="3" ColumnIndex="1">
            <TolerancedQuantity>
                <SNumber>2.0</SNumber>
                <Tolerance>
                    <LowerBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="absolute">
                        <SNumber>0.2</SNumber>
                    </UpperBound>
                </Tolerance>
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">gram</mml:csymbol>
                    </mml:math>
                </Unit>
            </TolerancedQuantity>
        </Element>
    </Elements>
</TolerancedQuantitySparseMatrix>

Validation:

This type is validated using the XML Schema file.

Attention

See Toleranced Quantities for details about <TolerancedQuantity> element validation.

Formula Templates¶

Formal definition (auto-generated documentation based on XSD file).

Formula templates are parameterized mathematical expressions, i.e. their value depends not only on their arguments, but also on additional parameters. However, they do not specify the units of the formula’s value or its arguments. Therefore, they represent a purely symbolic mathematical expression, without indicating its domain or codomain. They are described by a symbol, a list of arguments, a list of parameters, and their mathematical expression. Only the symbol must be specified for all arguments.

Attributes:
- Symbol [xsd:string] – Formula symbol
- TeX [xsd:string] (optional) – LaTeX formula symbol
Arguments (optional):
- Argument (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – argument symbol
  
  TeX [xsd:string] (optional) – LaTeX argument symbol
Parameters (optional):
- Parameter (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – parameter symbol
  
  TeX [xsd:string] (optional) – LaTeX parameter symbol
math – Strict Content MathML description of the formula that may use previously defined arguments and parameters.

Example:

Expression: \(U(t)\)

Parameters: \(U_0\), \(s\)

\[U(t) = U_0 + s \cdot t\]

<FormulaTemplate Symbol="U">
    <Arguments>
        <Argument Symbol="t"/>
    </Arguments>
    <Parameters>
        <Parameter Symbol="U0" TeX="U_0"/>
        <Parameter Symbol="s"/>
    </Parameters>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="arith1">plus</mml:csymbol>
            <mml:ci>U0</mml:ci>
            <mml:apply>
                <mml:csymbol cd="arith1">times</mml:csymbol>
                <mml:ci>s</mml:ci>
                <mml:ci>t</mml:ci>
            </mml:apply>
        </mml:apply>
    </mml:math>
</FormulaTemplate>

Validation:

This type is validated using the XML Schema file.

Note

Strict Content MathML formula descriptions in <mml:math> elements are validated using the official RelaxNG schema via mpfo.nvdl.

Attention

It is not validated whether parameter symbols are unique in a formula template.

Formulas¶

Formal definition (auto-generated documentation based on XSD file).

Formulas describe mathematical expressions whose value depends only on their arguments, i.e. that have no additional parameters. However, they do not specify the units of the formula’s value or its arguments. Therefore, they represent a purely symbolic mathematical expression, without indicating its domain or codomain. They are described by a formula template (that may depend on parameters) and a list of values for all template parameters. Parameter values are defined as quantities that include the value’s magnitude (as numerical value) and unit.

FormulaTemplate – Formula template on which the formula is based
ParameterValues (optional):
- ParameterValue (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – parameter symbol; used to identify the associated parameter of the formula template
  
  *Quantity* – Quantity value of the parameter (including the value’s magnitude and unit); can be a quantity, quantity interval, quantity vector, sparse quantity vector, quantity matrix, sparse quantity matrix, toleranced quantity, toleranced quantity interval, toleranced quantity vector, sparse toleranced quantity vector, toleranced quantity matrix, sparse toleranced quantity matrix or function.
  
  Attention
  
  When using a function as a quantity value, its argument list must be identical to the argument list of the formula template. This is currently not validated.

Example:

Expression: \(U(t)\)

Parameters: \(U_0 = 3.3\,\text{V}\), \(s = 2\,\frac{\text{V}}{\text{s}}\)

\[U(t) = U_0 + s \cdot t \quad\text{with } U_0 = 3.3\,\text{V}, s = 2\,\frac{\text{V}}{\text{s}}\]

<Formula>
    <FormulaTemplate Symbol="U">
        <Arguments>
            <Argument Symbol="t"/>
        </Arguments>
        <Parameters>
            <Parameter Symbol="U0" TeX="U_0"/>
            <Parameter Symbol="s"/>
        </Parameters>
        <mml:math>
            <mml:apply>
                <mml:csymbol cd="arith1">plus</mml:csymbol>
                <mml:ci>U0</mml:ci>
                <mml:apply>
                    <mml:csymbol cd="arith1">times</mml:csymbol>
                    <mml:ci>s</mml:ci>
                    <mml:ci>t</mml:ci>
                </mml:apply>
            </mml:apply>
        </mml:math>
    </FormulaTemplate>
    <ParameterValues>
        <ParameterValue Symbol="U0">
            <Quantity>
                <SNumber>3.3</SNumber>
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                    </mml:math>
                </Unit>
            </Quantity>
        </ParameterValue>
        <ParameterValue Symbol="s">
            <Quantity>
                <SNumber>2.0</SNumber>
                <Unit>
                    <mml:math>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                            <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                        </mml:apply>
                    </mml:math>
                </Unit>
            </Quantity>
        </ParameterValue>
    </ParameterValues>
</Formula>

Validation:

This type is validated using the XML Schema file.

Attention

See Formula Templates for details about validation of <FormulaTemplate> elements.
See Quantities, Quantity Intervals, Quantity Vectors, Sparse Quantity Vectors, Quantity Matrices, Sparse Quantity Matrices, Toleranced Quantities, Toleranced Quantity Intervals, Toleranced Quantity Vectors, Sparse Toleranced Quantity Vectors, Toleranced Quantity Matrices, Sparse Toleranced Quantity Matrices and Functions for details about validation of <ParameterValue> elements.

Attention

It is not validated whether parameters with the specified symbols exist in the formula template.
It is not validated whether values for all parameters of the formula template have been specified.

Functions¶

Functions map each element of a set \(X\) to a unique element of a set \(Y\). The first set is the functions domain and the second set is its codomain.

Currently, we support two types of functions: symbolic functions and table functions. Symbolic functions are defined in terms of a mathematical expression. Table functions are specified by their value table that includes all points for which the function is defined. Therefore, they are useful for the definition of, e.g., histograms.

For both types of functions, the domain and codomain are implicitly defined by the given units of the function’s value and its arguments.

Symbolic Function Templates¶

Formal definition (auto-generated documentation based on XSD file).

Symbolic function templates are parameterized mathematical functions, i.e. their value depends not only on their arguments, but also on additional parameters. They are described by a symbol, a unit, a list of arguments, a list of parameters, and their mathematical expression. For all arguments and parameters, the corresponding unit must be specified.

Attributes:
- Symbol [xsd:string] – Function symbol
- TeX [xsd:string] (optional) – LaTeX function symbol
Unit – Unit of the resulting quantity; can be a unit, unit vector, sparse unit vector, unit matrix, or sparse unit matrix
Arguments (optional):
- ArgumentWithUnit (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – argument symbol
  
  TeX [xsd:string] (optional) – LaTeX argument symbol
  
  Unit – Unit of the argument; can be a unit, unit vector, sparse unit vector, unit matrix, or sparse unit matrix
Parameters (optional):
- ParameterWithUnit (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – parameter symbol
  
  TeX [xsd:string] (optional) – LaTeX parameter symbol
  
  Unit – Unit of the parameter; can be a unit, unit vector, sparse unit vector, unit matrix, or sparse unit matrix
math – Strict Content MathML description of the function that may use previously defined arguments and parameters.

Example 1:

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in s

Parameters: \(U_0\) in V

\[U(t) = U_0\]

<SymbolicFunctionTemplate Symbol="U">
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
        </mml:math>
    </Unit>
    <Arguments>
        <ArgumentWithUnit Symbol="t">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
        </ArgumentWithUnit>
    </Arguments>
    <Parameters>
        <ParameterWithUnit Symbol="U0" TeX="U_0">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
    </Parameters>
    <mml:math>
        <mml:ci>U0</mml:ci>
    </mml:math>
</SymbolicFunctionTemplate>

Example 2:

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in s

Parameters: \(U_0\) in V, \(f\) in Hz

\[U(t) = U_0\cdot \sin\left(2\pi f\right)\]

<SymbolicFunctionTemplate Symbol="U">
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
        </mml:math>
    </Unit>
    <Arguments>
        <ArgumentWithUnit Symbol="t">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
        </ArgumentWithUnit>
    </Arguments>
    <Parameters>
        <ParameterWithUnit Symbol="U0" TeX="U_0">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="f">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">hertz</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
    </Parameters>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="arith1">times</mml:csymbol>
            <mml:ci>U0</mml:ci>
            <mml:apply>
                <mml:csymbol cd="transc1">sin</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">times</mml:csymbol>
                    <mml:cn type="integer">2</mml:cn>
                    <mml:csymbol cd="nums1">pi</mml:csymbol>
                    <mml:ci>f</mml:ci>
                </mml:apply>
            </mml:apply>
        </mml:apply>
    </mml:math>
</SymbolicFunctionTemplate>

Example 3: Test pulse E-01 (long-term overvoltage) from LV124 / VW80000

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in s

Parameters: \(U_\text{max}\) in V, \(U_\text{min}\) in V, \(t_\text{r}\) in s, \(t_\text{f}\) in s, \(t_1\) in s

\[\begin{split}U(t) = \begin{cases} \frac{U_\text{max}-U_\text{min}}{t_\text{r}} \cdot t + U_\text{min} & \left[0,t_\text{r}\right] \\ U_\text{max} & \left(t_\text{r},t_\text{r}+t_1 \right] \\ \frac{U_\text{min}-U_\text{max}}{t_\text{f}} \cdot \left(t-t_\text{r}-t_1\right)+U_\text{max} & \left(t_\text{r}+t_1, t_\text{r}+t_1+t_\text{f}\right] \end{cases}\end{split}\]

<SymbolicFunctionTemplate Symbol="U">
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
        </mml:math>
    </Unit>
    <Arguments>
        <ArgumentWithUnit Symbol="t">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
        </ArgumentWithUnit>
    </Arguments>
    <Parameters>
        <ParameterWithUnit Symbol="Umax" TeX="U_\text{max}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="Umin" TeX="U_\text{min}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="tr" TeX="t_\text{r}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">seconds</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="tf" TeX="t_\text{f}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">seconds</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="t1" TeX="t_1">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">seconds</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
    </Parameters>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="piece1">piecewise</mml:csymbol>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <!-- ((Umax - Umin) / tr) * t + Umin -->
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:apply>
                                <mml:csymbol cd="arith1">minus</mml:csymbol>
                                <mml:ci>Umax</mml:ci>
                                <mml:ci>Umin</mml:ci>
                            </mml:apply>
                            <mml:ci>tr</mml:ci>
                        </mml:apply>
                        <mml:ci>t</mml:ci>
                    </mml:apply>
                    <mml:ci>Umin</mml:ci>
                </mml:apply>
                <!-- 0 <= t <= tr -->
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">geq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:cn type="real">0</mml:cn>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:ci>tr</mml:ci>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <!-- Umax -->
                <mml:ci>Umax</mml:ci>
                <!-- tr < t <= tr+t1 -->
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:ci>tr</mml:ci>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:ci>tr</mml:ci>
                            <mml:ci>t1</mml:ci>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <!-- ((Umin - Umax) / tf) * (t - tr - t1) + Umax-->
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:apply>
                                <mml:csymbol cd="arith1">minus</mml:csymbol>
                                <mml:ci>Umin</mml:ci>
                                <mml:ci>Umax</mml:ci>
                            </mml:apply>
                            <mml:ci>tf</mml:ci>
                        </mml:apply>
                        <mml:apply>
                            <mml:csymbol cd="arith1">minus</mml:csymbol>
                            <mml:ci>t</mml:ci>
                            <mml:ci>tr</mml:ci>
                            <mml:ci>t1</mml:ci>
                        </mml:apply>
                    </mml:apply>
                    <mml:ci>Umax</mml:ci>
                </mml:apply>
                <!-- tr+t1 < t <= tr+t1+tf  -->
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:ci>tr</mml:ci>
                            <mml:ci>t1</mml:ci>
                        </mml:apply>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:ci>tr</mml:ci>
                            <mml:ci>t1</mml:ci>
                            <mml:ci>tf</mml:ci>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
        </mml:apply>
    </mml:math>
</SymbolicFunctionTemplate>

Example 4: Test pule E-06 (superimposed AC voltage) from LV124 / VW80000

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in s

Parameters: \(U_\text{max}\) in V, \(U_\text{pp}\) in V, \(f_\text{min}\) in Hz, \(f_\text{max}\) in Hz, \(t_1\) in s

\[\begin{split}U(t) = \begin{cases} \left(U_\text{max}-\frac{U_\text{pp}}{2}\right) + \frac{U_\text{pp}}{2} \cdot \sin\left(2\pi\cdot\exp\left(\ln\left(\frac{f_\text{max}}{f_\text{min}}\right) \cdot \frac{2}{t_1} \cdot t + \ln\left(f_\text{min}\right) \right) \right) & \left[0,\frac{t_1}{2}\right] \\ \left(U_\text{max}-\frac{U_\text{pp}}{2}\right) + \frac{U_\text{pp}}{2} \cdot \sin\left(-2\pi\cdot\exp\left(\ln\left(\frac{f_\text{min}}{f_\text{max}}\right) \cdot \frac{2}{t_1} \cdot \left(t-\frac{t_1}{2}\right) + \ln\left(f_\text{max}\right) \right) \right) & \left(\frac{t_1}{2},t_1\right] \end{cases}\end{split}\]

<SymbolicFunctionTemplate Symbol="U">
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
        </mml:math>
    </Unit>
    <Arguments>
        <ArgumentWithUnit Symbol="t">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                </mml:math>
            </Unit>
        </ArgumentWithUnit>
    </Arguments>
    <Parameters>
        <ParameterWithUnit Symbol="Umax" TeX="U_\text{max}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="Upp" TeX="U_\text{pp}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="fmin" TeX="f_\text{min}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">hertz</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="fmax" TeX="f_\text{max}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">hertz</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="t1" TeX="t_1">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_BaseUnits1">seconds</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
    </Parameters>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="piece1">piecewise</mml:csymbol>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">minus</mml:csymbol>
                        <mml:ci>Umax</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>Upp</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>Upp</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                        <mml:apply>
                            <mml:csymbol cd="transc1">sin</mml:csymbol>
                            <mml:apply>
                                <mml:csymbol cd="arith1">times</mml:csymbol>
                                <mml:cn type="integer">2</mml:cn>
                                <mml:csymbol cd="nums1">pi</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="transc1">exp</mml:csymbol>
                                    <mml:apply>
                                        <mml:csymbol cd="arith1">plus</mml:csymbol>
                                        <mml:apply>
                                            <mml:csymbol cd="arith1">times</mml:csymbol>
                                            <mml:apply>
                                                <mml:csymbol cd="transc1">ln</mml:csymbol>
                                                <mml:apply>
                                                    <mml:csymbol cd="arith1">divide</mml:csymbol>
                                                    <mml:ci>fmax</mml:ci>
                                                    <mml:ci>fmin</mml:ci>
                                                </mml:apply>
                                            </mml:apply>
                                            <mml:apply>
                                                <mml:csymbol cd="arith1">divide</mml:csymbol>
                                                <mml:cn type="integer">2</mml:cn>
                                                <mml:ci>t1</mml:ci>
                                            </mml:apply>
                                            <mml:ci>t</mml:ci>
                                        </mml:apply>
                                        <mml:apply>
                                            <mml:csymbol cd="transc1">ln</mml:csymbol>
                                            <mml:ci>fmin</mml:ci>
                                        </mml:apply>
                                    </mml:apply><!-- plus -->
                                </mml:apply><!-- exp -->
                            </mml:apply><!-- times -->
                        </mml:apply><!-- sin -->
                    </mml:apply><!-- times -->
                </mml:apply><!-- plus -->
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">geq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:cn type="real">0</mml:cn>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>t1</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">minus</mml:csymbol>
                        <mml:ci>Umax</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>Upp</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>Upp</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                        <mml:apply>
                            <mml:csymbol cd="transc1">sin</mml:csymbol>
                            <mml:apply>
                                <mml:csymbol cd="arith1">times</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="arith1">unary_minus</mml:csymbol>
                                    <mml:cn type="integer">2</mml:cn>
                                </mml:apply>
                                <mml:csymbol cd="nums1">pi</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="transc1">exp</mml:csymbol>
                                    <mml:apply>
                                        <mml:csymbol cd="arith1">plus</mml:csymbol>
                                        <mml:apply>
                                            <mml:csymbol cd="arith1">times</mml:csymbol>
                                            <mml:apply>
                                                <mml:csymbol cd="transc1">ln</mml:csymbol>
                                                <mml:apply>
                                                    <mml:csymbol cd="arith1">divide</mml:csymbol>
                                                    <mml:ci>fmin</mml:ci>
                                                    <mml:ci>fmax</mml:ci>
                                                </mml:apply>
                                            </mml:apply>
                                            <mml:apply>
                                                <mml:csymbol cd="arith1">divide</mml:csymbol>
                                                <mml:cn type="integer">2</mml:cn>
                                                <mml:ci>t1</mml:ci>
                                            </mml:apply>
                                            <mml:apply>
                                                <mml:csymbol cd="arith1">minus</mml:csymbol>
                                                <mml:ci>t</mml:ci>
                                                <mml:apply>
                                                    <mml:csymbol cd="arith1">divide</mml:csymbol>
                                                    <mml:ci>t1</mml:ci>
                                                    <mml:cn type="integer">2</mml:cn>
                                                </mml:apply>
                                            </mml:apply>
                                        </mml:apply>
                                        <mml:apply>
                                            <mml:csymbol cd="transc1">ln</mml:csymbol>
                                            <mml:ci>fmax</mml:ci>
                                        </mml:apply>
                                    </mml:apply><!-- plus -->
                                </mml:apply><!-- exp -->
                            </mml:apply><!-- times -->
                        </mml:apply><!-- sin -->
                    </mml:apply><!-- times -->
                </mml:apply><!-- plus -->
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:ci>t</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:ci>t1</mml:ci>
                            <mml:cn type="integer">2</mml:cn>
                        </mml:apply>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:ci>t1</mml:ci>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
        </mml:apply>
    </mml:math>
</SymbolicFunctionTemplate>

Example 5: Test pulse E-07 (gradual lowering and raising of the supply voltage) from LV124 / VW80000

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in min

Parameters: \(U_\text{start}\) in V, \(m\) in V/min, \(U_1\) in V, \(t_1\) in min, \(U_\text{min}\) in V, \(U_2\) in V, \(t_2\) in min, \(U_\text{end}\) in V

\[\begin{split}U(t) = \begin{cases} -mt+U_\text{start} & \left[0,\frac{1}{m}\left(U_\text{start}-U_1\right)\right] \\ U_1 & \left(\frac{1}{m}\left(U_\text{start}-U_1\right), \frac{1}{m}\left(U_\text{start}-U_1\right)+t_1\right] \\ -m\left(t-t_1\right)+U_\text{start} & \left(\frac{1}{m}\left(U_\text{start}-U_1\right)+t_1, \frac{1}{m}\left(U_\text{start}-U_\text{min}\right)+t_1\right] \\ m\left(t-t_1\right)-U_\text{start}+2U_\text{min} & \left(\frac{1}{m}\left(U_\text{start}-U_\text{min}\right)+t_1, \frac{1}{m}\left(U_\text{start}+U_2-2U_\text{min}\right)+t_1 \right] \\ U_2 & \left(\frac{1}{m}\left(U_\text{start}+U_2-2U_\text{min}\right)+t_1, \frac{1}{m}\left(U_\text{start}+U_2-2U_\text{min}\right)+t_1+t_2 \right] \\ m\left(t-t_1-t_2\right)-U_\text{start}+2U_\text{min} & \left(\frac{1}{m}\left(U_\text{start}+U_2-2U_\text{min}\right)+t_1+t_2, \frac{1}{m}\left(U_\text{start}+U_\text{end}-2U_\text{min}\right)+t_1+t_2 \right] \end{cases}\end{split}\]

<SymbolicFunctionTemplate Symbol="U">
    <Unit>
        <mml:math>
            <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
        </mml:math>
    </Unit>
    <Arguments>
        <ArgumentWithUnit Symbol="t">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SIUsed_OffSystemUnits1">minute</mml:csymbol>
                </mml:math>
            </Unit>
        </ArgumentWithUnit>
    </Arguments>
    <Parameters>
        <ParameterWithUnit Symbol="Ustart" TeX="U_\text{start}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="m">
            <Unit>
                <mml:math>
                    <mml:apply>
                        <mml:csymbol cd="arith1">divide</mml:csymbol>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                        <mml:csymbol cd="SIUsed_OffSystemUnits1">minute</mml:csymbol>
                    </mml:apply>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="U1" TeX="U_1">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="t1" TeX="t_1">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SIUsed_OffSystemUnits1">minute</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="Umin" TeX="U_\text{min}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="U2" TeX="U_2">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="t2" TeX="t_2">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SIUsed_OffSystemUnits1">minute</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
        <ParameterWithUnit Symbol="Uend" TeX="U_\text{end}">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                </mml:math>
            </Unit>
        </ParameterWithUnit>
    </Parameters>
    <mml:math>
        <mml:apply>
            <mml:csymbol cd="piece1">piecewise</mml:csymbol>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">unary_minus</mml:csymbol>
                            <mml:ci>m</mml:ci>
                        </mml:apply>
                        <mml:ci>t</mml:ci>
                    </mml:apply>
                    <mml:ci>Ustart</mml:ci>
                </mml:apply>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">geq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:cn type="real">0</mml:cn>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i1end">
                            <mml:csymbol cd="arith1">divide</mml:csymbol>
                            <mml:apply>
                                <mml:csymbol cd="arith1">minus</mml:csymbol>
                                <mml:ci>Ustart</mml:ci>
                                <mml:ci>U1</mml:ci>
                            </mml:apply>
                            <mml:ci>m</mml:ci>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:ci>U1</mml:ci>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:share href="#i1end"/>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i2end">
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:share href="#i1end"/>
                            <mml:ci>t1</mml:ci>
                        </mml:apply>

                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:apply>
                            <mml:csymbol cd="arith1">unary_minus</mml:csymbol>
                            <mml:ci>m</mml:ci>
                        </mml:apply>
                        <mml:apply>
                            <mml:csymbol cd="arith1">minus</mml:csymbol>
                            <mml:ci>t</mml:ci>
                            <mml:share href="#i2end"/>
                        </mml:apply>
                    </mml:apply>
                    <mml:ci>U1</mml:ci>
                </mml:apply>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:share href="#i2end"/>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i3end">
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:share href="#i2end"/>
                            <mml:apply>
                                <mml:csymbol cd="arith1">divide</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="arith1">minus</mml:csymbol>
                                    <mml:ci>U1</mml:ci>
                                    <mml:ci>Umin</mml:ci>
                                </mml:apply>
                                <mml:ci>m</mml:ci>
                            </mml:apply>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:ci>m</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">minus</mml:csymbol>
                            <mml:ci>t</mml:ci>
                            <mml:share href="#i3end"/>
                        </mml:apply>
                    </mml:apply>
                    <mml:ci>Umin</mml:ci>
                </mml:apply>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:share href="#i3end"/>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i4end">
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:share href="#i3end"/>
                            <mml:apply>
                                <mml:csymbol cd="arith1">divide</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="arith1">minus</mml:csymbol>
                                    <mml:ci>U2</mml:ci>
                                    <mml:ci>Umin</mml:ci>
                                </mml:apply>
                                <mml:ci>m</mml:ci>
                            </mml:apply>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:ci>U2</mml:ci>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:share href="#i4end"/>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i5end">
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:share href="#i4end"/>
                            <mml:ci>t2</mml:ci>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
            <mml:apply>
                <mml:csymbol cd="piece1">piece</mml:csymbol>
                <mml:apply>
                    <mml:csymbol cd="arith1">plus</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="arith1">times</mml:csymbol>
                        <mml:ci>m</mml:ci>
                        <mml:apply>
                            <mml:csymbol cd="arith1">minus</mml:csymbol>
                            <mml:ci>t</mml:ci>
                            <mml:share href="#i5end"/>
                        </mml:apply>
                    </mml:apply>
                    <mml:ci>U2</mml:ci>
                </mml:apply>
                <mml:apply>
                    <mml:csymbol cd="logic1">and</mml:csymbol>
                    <mml:apply>
                        <mml:csymbol cd="relation1">gt</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:share href="#i5end"/>
                    </mml:apply>
                    <mml:apply>
                        <mml:csymbol cd="relation1">leq</mml:csymbol>
                        <mml:ci>t</mml:ci>
                        <mml:apply id="i6end">
                            <mml:csymbol cd="arith1">plus</mml:csymbol>
                            <mml:share href="#i5end"/>
                            <mml:apply>
                                <mml:csymbol cd="arith1">divide</mml:csymbol>
                                <mml:apply>
                                    <mml:csymbol cd="arith1">minus</mml:csymbol>
                                    <mml:ci>Uend</mml:ci>
                                    <mml:ci>U2</mml:ci>
                                </mml:apply>
                                <mml:ci>m</mml:ci>
                            </mml:apply>
                        </mml:apply>
                    </mml:apply>
                </mml:apply>
            </mml:apply>
        </mml:apply>
    </mml:math>
</SymbolicFunctionTemplate>

Validation:

This type is validated using the XML Schema file.

Note

Strict Content MathML function descriptions in <mml:math> elements are validated using the official RelaxNG schema via mpfo.nvdl.

Attention

See Units, Unit Vectors, Sparse Unit Vectors, Unit Matrices and Sparse Unit Matrices for details about validation of <Unit>, <UnitVector>, <UnitSparseVector>, <UnitMatrix> and <UnitSparseMatrix> elements.

Symbolic Functions¶

Formal definition (auto-generated documentation based on XSD file).

Symbolic functions describe symbolic mathematical functions whose value depends only on their arguments, i.e. that have no additional parameters. They are described by a symbolic function template (that may depend on parameters) and a list of values for all template parameters. The domain and codomain of a symbolic function are implicitly specified by the units of the function value and its arguments as defined by the template.

SymbolicFunctionTemplate – Template on which the function is based
ParameterValues (optional):
- ParameterValueMagnitude (1..∞):
  
  Attributes:
  
  Symbol [xsd:string] – parameter symbol; used to identify the associated parameter of the symbolic function template
  
  *Number* – Numeric value (magnitude) of the parameter (the symbolic function template defines the unit); can be a number, number interval, number interval vector, number vector, sparse number vector, number matrix, sparse number matrix, toleranced number, toleranced number interval, toleranced number vector, sparse toleranced number vector, toleranced number matrix or sparse toleranced number matrix.

Example:

Function: \(U(t)\) with \(\{U\}\) in V, \(\{t\}\) in s

Parameters: \(U_0\) in V with \(U_0=3.3\,\text{V}\)

\[U(t) = U_0 \text{ with } U_0 = 3.3\,\text{V}\]

<SymbolicFunction>
    <SymbolicFunctionTemplate Symbol="U">
        <Unit>
            <mml:math>
                <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
            </mml:math>
        </Unit>
        <Arguments>
            <ArgumentWithUnit Symbol="t">
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_BaseUnits1">second</mml:csymbol>
                    </mml:math>
                </Unit>
            </ArgumentWithUnit>
        </Arguments>
        <Parameters>
            <ParameterWithUnit Symbol="U0" TeX="U_0">
                <Unit>
                    <mml:math>
                        <mml:csymbol cd="SI_NamedDerivedUnits1">volt</mml:csymbol>
                    </mml:math>
                </Unit>
            </ParameterWithUnit>
        </Parameters>
        <mml:math>
            <mml:ci>U0</mml:ci>
        </mml:math>
    </SymbolicFunctionTemplate>
    <ParameterValues>
        <ParameterValueMagnitude Symbol="U0">
            <SNumber>3.3</SNumber>
        </ParameterValueMagnitude>
    </ParameterValues>
</SymbolicFunction>

Validation:

This type is validated using the XML Schema file.

Attention

See Symbolic Function Templates for details about validation of <SymbolicFunctionTemplate> elements.
See Units, Unit Vectors, Sparse Unit Vectors, Unit Matrices and Sparse Unit Matrices for details about validation of <Unit>, <UnitVector>, <UnitSparseVector>, <UnitMatrix> and <UnitSparseMatrix> elements.
See Numbers, Number Intervals, Number Interval Vectors, Number Vectors, Sparse Number Vectors, Number Matrices, Sparse Number Matrices, Toleranced Numbers, Toleranced Number Intervals, Toleranced Number Vectors, Sparse Toleranced Number Vectors, Toleranced Number Matrices and Sparse Toleranced Number Matrices for details about validation of <ParameterValueMagnitude> elements.

Attention

It is not validated whether parameters with the specified symbols exist in the symbolic function template.
It is not validated whether values for all parameters of the symbolic function template have been specified.

Table Functions¶

Formal definition (auto-generated documentation based on XSD file).

Table functions describe mathematical functions in terms of their value table that includes all points for which the function is defined. They are useful for defining histograms. The domain and codomain of a table function are implicitly specified by the units of the function value and its arguments.

Attributes:
- Symbol [xsd:string] – Function symbol
- TeX [xsd:string] (optional) – LaTeX function symbol
Value:
- Unit (only if the following vector is not a string vector) – Unit of the function value
- *Vector* – Vector of function values; can be a string vector, sparse string vector, number vector, sparse number vector, number interval vector, toleranced number vector, or sparse toleranced number vector.
Arguments:
- Argument (1..∞)
  
  Attributes:
  
  Symbol [xsd:string] – Function symbol
  
  TeX [xsd:string] (optional) – LaTeX function symbol
  
  Unit (only if the following vector is not a string vector) – Unit of the function argument
  
  *Vector* – Vector of function argument values; can be a string vector, sparse string vector, number vector, sparse number vector, number interval vector, toleranced number vector, or sparse toleranced number vector.

The given unit applies to all elements of the corresponding vector. All vectors must have the same number of elements.

Example:

A histogram is given by the following table:

Active operation (running engine)¶
Temperature	Duration
-40°C … 10°C	170 h
10°C … 45°C	500 h
45°C … 105°C	2000 h

<TableFunction Symbol="t">
    <Value>
        <Unit>
            <mml:math>
                <mml:csymbol cd="SIUsed_OffSystemUnits1">hour</mml:csymbol>
            </mml:math>
        </Unit>
        <NumberVector>
            <SNumber>170</SNumber>
            <SNumber>500</SNumber>
            <SNumber>2000</SNumber>
        </NumberVector>
    </Value>
    <Arguments>
        <Argument Symbol="I">
            <Unit>
                <mml:math>
                    <mml:csymbol cd="SI_NamedDerivedUnits1">degree-Celsius</mml:csymbol>
                </mml:math>
            </Unit>
            <NumberIntervalVector>
                <NumberInterval>
                    <LowerBound BoundType="closed">
                        <SNumber>-40</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="closed">
                        <SNumber>10</SNumber>
                    </UpperBound>
                </NumberInterval>
                <NumberInterval>
                    <LowerBound BoundType="closed">
                        <SNumber>10</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="closed">
                        <SNumber>45</SNumber>
                    </UpperBound>
                </NumberInterval>
                <NumberInterval>
                    <LowerBound BoundType="closed">
                        <SNumber>45</SNumber>
                    </LowerBound>
                    <UpperBound BoundType="closed">
                        <SNumber>105</SNumber>
                    </UpperBound>
                </NumberInterval>
            </NumberIntervalVector>
        </Argument>
    </Arguments>
</TableFunction>

Validation:

This type is validated using the XML Schema file.

Attention

See Units for details about validation of <Unit> elements.
See String Vectors, Sparse String Vectors, Number Vectors, Sparse Number Vectors, Number Interval Vectors, Toleranced Number Vectors, and Sparse Toleranced Number Vectors for details about validation of <Value> and <Argument> elements.

Attention

It is not validated whether all vectors have the same number of elements.

References¶

To avoid the need for a repeated definition of the same element, already defined elements can be referenced. For this purpose, a unique “Id” attribute can be specified for all elements. Later, these elements can be referenced using special reference elements that have the same name with the ending “Ref”. For example, <String> elements are referenced using <StringRef> elements. These reference elements have a single attribute “Ref” whose value is the Id of the referenced element. Wherever a certain element is expected, a corresponding reference can be used.

Example:

<String Id="my-string-01">Hello World</String>
<StringRef Ref="my-string-01"/>

Validation:

All <*Ref> elements are validated using the XML Schema file. Schematron rules ensure that all IDs refer to the correct element type, e.g., only IDs of <String> elements can be referenced by <StringRef> elements.

Examples¶

Example 1 - Two-port electrical resistor in two operating phases¶

Overview

Example 1: Two-port electrical resistor R1 that is operated for several hours in two operating phases at different temperatures.

MPFO-XML Source Code

<?xml version="1.0" encoding="UTF-8"?>
<MPFo xmlns:m="http://www.w3.org/1998/Math/MathML"
    xmlns="http://www.mpfo.org/mpfo-0.6"
    xmlns:mml="http://www.w3.org/1998/Math/MathML"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.mpfo.org/mpfo-0.6/mpfo.xsd"
    Id="ID.Component.R1" 
    MPFoVersion="0.6">
    
    <Description>Example: Simple two-port electrical resistor R1 that is operated with a DC current for 55h at 298K (25C) and 350h at 423K (150C)</Description>
    
    <!-- External MPFO-XML definitions --> 
    <Include>
        <!-- Include external MPFO standard definitions -->
        <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="../../../../include/stdlib.xml"/>
    </Include>
    
    <!-- MPFO-XML document definition -->
    <DocumentDefinition>
        <Documents>
            <!-- Initial document revision --> 
            <Document Id="ID.Doc.0" ShortDescription="Initial version of mission profile document for MPFO-XML example 001" 
                 ModificationTimeStamp="2018-05-04T18:13:51.0" Revision="1">
                <Description>This is document revision 1.0.</Description>
                <Creator Name="Max Mustermann" Organization="mpfo.org" ToolName="MPFW" ToolVersion="1.0" CreationTimeStamp="2018-05-04T18:13:51.0"/>
            </Document>
        </Documents>
    </DocumentDefinition>
    
    <!-- Component port definition: 2 electrical resistor ports (N1, N2) -->
    <PortDefinition>
        <Ports>
            <Port Id="ID.Port.N1" Name="N1" ShortDescription="Electrical device instance terminal N1" Type="inout"/>
            <Port Id="ID.Port.N2" Name="N2" ShortDescription="Electrical device instance terminal N2" Type="inout"/>
        </Ports>
    </PortDefinition>
    
    <!-- Component load definitions -->
    <LoadDefinition>
        <Loads>
            <!-- Definition of the resistor input current as DC current i = 123.4 mA -->
            <Load Id="ID.Load.0" ShortDescription="Input current I0">
                <LoadQuantity Id="ID.QLoad.0" Symbol="I0">
                    <Quantity>
                        <SNumber>0.1234</SNumber>
                        <Unit>
                            <mml:math>
                                <mml:csymbol cd="SI_NamedDerivedUnits1">ampere</mml:csymbol>
                            </mml:math>
                        </Unit>
                    </Quantity>
                </LoadQuantity>
            </Load>
            
            <!-- Definition of the resistor output current as DC current i = -123.4 mA as transformed reference to the load "ID.Load.0" -->
            <Load Id="ID.Load.1" ShortDescription="Output current I1">
                <LoadRef ReferenceLoadRef="ID.Load.0">
                    <TransformationFunction>
                        <FormulaRef Ref="ID.STD.Formula.Negation"/>
                    </TransformationFunction>
                </LoadRef>        
            </Load>
            
            <!-- Environment temperature T1 = 298 K present for a certain period of time -->
            <Load Id="ID.Load.Env.0" ShortDescription="Environment temperature T1 = 298 K for 55 h">
                <LoadQuantity Id="ID.QLoad.Env.0" Symbol="T1">
                    <SymbolicFunction>
                        <!-- Re-usable function template that defines a piecewise function to define a time interval later -->
                        <SymbolicFunctionTemplate Id="ID.Function-constant-temperature"  Symbol="T">
                            <Unit>
                                <mml:math>
                                    <mml:csymbol cd="SI_NamedDerivedUnits1">kelvin</mml:csymbol>
                                </mml:math>
                            </Unit>
                            <Arguments>
                                <ArgumentWithUnit Symbol="t">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_BaseUnits1">hour</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ArgumentWithUnit>
                            </Arguments>
                            <Parameters>
                                <ParameterWithUnit Symbol="T1" TeX="T_1">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_NamedDerivedUnits1">kelvin</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ParameterWithUnit>
                                <ParameterWithUnit Symbol="t1" TeX="t_1">
                                    <Unit>
                                        <mml:math>
                                            <mml:csymbol cd="SI_BaseUnits1">hour</mml:csymbol>
                                        </mml:math>
                                    </Unit>
                                </ParameterWithUnit>
                            </Parameters>
                            <mml:math>
                                <mml:apply>
                                    <!-- define a piecewise linear function between 0 <= t <= t1 where t1 will be defined later -->
                                    <mml:csymbol cd="piece1">piecewise</mml:csymbol>
                                    <mml:apply>
                                        <mml:csymbol cd="piece1">piece</mml:csymbol>
                                        <mml:ci>T1</mml:ci>
                                        <mml:apply>
                                            <mml:csymbol cd="logic1">and</mml:csymbol>
                                            <mml:apply>
                                                <mml:csymbol cd="relation1">geq</mml:csymbol>
                                                <mml:ci>t</mml:ci>
                                                <mml:cn type="real">0</mml:cn>
                                            </mml:apply>
                                            <mml:apply>
                                                <mml:csymbol cd="relation1">leq</mml:csymbol>
                                                <mml:ci>t</mml:ci>
                                                <mml:ci>t1</mml:ci>
                                            </mml:apply>
                                        </mml:apply>
                                    </mml:apply>
                                </mml:apply>
                            </mml:math>
                        </SymbolicFunctionTemplate>
                        
                        <!-- Assign values to the formula parameters --> 
                        <ParameterValues>
                            <!-- Limit the duration to 55 h -->
                            <ParameterValueMagnitude Symbol="t1">
                                <SNumber>55</SNumber>
                            </ParameterValueMagnitude>
                            <!-- Set temperature to 298 K --> 
                            <ParameterValueMagnitude Symbol="T1">
                                <SNumber>298</SNumber>
                            </ParameterValueMagnitude>
                        </ParameterValues>
                    </SymbolicFunction>
                </LoadQuantity>
            </Load>
            
            <!-- Environment temperature T2 = 423 K present for 350 h -->
            <Load Id="ID.Load.Env.1" ShortDescription="Environment temperature T2=423K">
                <LoadQuantity Id="ID.QLoad.Env.1" Symbol="T2">
                    <SymbolicFunction>
                        <!-- Fortunately, we can also re-use previously defined function templates -->
                        <SymbolicFunctionTemplateRef Ref="ID.Function-constant-temperature"/>
                        
                        <!-- Assign values to the formula parameters --> 
                        <ParameterValues>
                            <!-- Limit the duration to 350 hours -->
                            <ParameterValueMagnitude Symbol="t1">
                                <SNumber>350</SNumber>
                            </ParameterValueMagnitude>
                            <!-- Set temperature to 423K --> 
                            <ParameterValueMagnitude Symbol="T1">
                                <SNumber>423</SNumber>
                            </ParameterValueMagnitude>
                        </ParameterValues>
                    </SymbolicFunction>
                </LoadQuantity>
            </Load>
        </Loads>
    </LoadDefinition>
    
    <!-- Assign loads to ports -->
    <ActionDefinition>
        <Actions>
            <!-- Operating phase 1 (loads are assigned directly to the electrical ports for simplicity reasons) -->
            <Action Id="ID.Action.0" ShortDescription="Operating phase 1: Resistor operation at 298 K for 55 h">
                <Assignments>
                    <!-- Assign loads to port N1 -->
                    <Assignment Id="ID.Action.0.Assignment.N1">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N1"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.0"/>
                            <LoadRef Ref="ID.Load.Env.0"/>
                        </LoadRefs>
                    </Assignment>
                    <!-- Assign loads to port N2 -->
                    <Assignment Id="ID.Action.0.Assignment.N2">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N2"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.1"/>
                            <LoadRef Ref="ID.Load.Env.0"/>
                        </LoadRefs>
                    </Assignment>
                </Assignments>
            </Action>
            
            <!-- Operating phase 2 (loads are assigned directly to the electrical ports for simplicity reasons) --> 
            <Action Id="ID.Action.1" ShortDescription="Operating phase 2: Resistor operation at 423 K for 350 h">
                <Assignments>
                    <!-- Assign loads to port N1 -->
                    <Assignment Id="ID.Action.1.Assignment.N1">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N1"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.0"/>
                            <LoadRef Ref="ID.Load.Env.1"/>
                        </LoadRefs>
                    </Assignment>
                    <!-- Assign loads to port N2 -->
                    <Assignment Id="ID.Action.1.Assignment.N2">
                        <PortRefs>
                            <PortRef Ref="ID.Port.N2"/>
                        </PortRefs>
                        <LoadRefs>
                            <LoadRef Ref="ID.Load.1"/>
                            <LoadRef Ref="ID.Load.Env.1"/>
                        </LoadRefs>
                    </Assignment>
                </Assignments>
            </Action>
        </Actions>
        <ActionSets>
            <ActionSet Id="ID.ActionSet.0">
                <References>
                    <ActionRef Ref="ID.Action.0"/>
                </References>
            </ActionSet>
            <ActionSet Id="ID.ActionSet.1">
                <References>
                    <ActionRef Ref="ID.Action.1"/>
                </References>
            </ActionSet>
        </ActionSets>
    </ActionDefinition> 
    
    <!-- Component activity definition: sequence of operating phases -->
    <ActivityDefinition>
        <!-- Define activities -->
        <Activities>
            <!-- Operating phase 1 -->
            <Activity Id="ID.Activity.0">
                <ActionSetRef Ref="ID.ActionSet.0"/>
            </Activity> 
            <!-- Start operating phase 2 after operating phase 1 -->
            <Activity Id="ID.Activity.1">
                <ActionSetRef Ref="ID.ActionSet.1"/>
            </Activity>
        </Activities>
        <!-- Consider operating phase 2 to start after operating phase 1 -->
        <ActivityFlows>
            <ActivityFlow Id="ID.Activity.Flow.0">
                <ActivityRefs>
                    <ActivityRef Ref="ID.Activity.0"/>
                    <ActivityRef Ref="ID.Activity.1"/>
                </ActivityRefs>
            </ActivityFlow>
        </ActivityFlows>
        <!-- Define a activity flow set -->
        <ActivityFlowSets>
            <ActivityFlowSet Id="ID.Activity.FlowSet.0">
                <References>
                    <ActivityFlowRef Ref="ID.Activity.Flow.0"/>
                </References>
            </ActivityFlowSet>
        </ActivityFlowSets>
    </ActivityDefinition>
    
    <!-- Define an activity scenario for the component and apply/use it -->
    <ScenarioDefinition>
        <!-- Define an application scenario with one activity flow -->
        <Scenarios>
            <Scenario Id="ID.Scenario.0">
                <ActivityFlowSetRefs>
                    <ActivityFlowSetRef Ref="ID.Activity.FlowSet.0"/>
                </ActivityFlowSetRefs>
            </Scenario>
        </Scenarios>
        <!-- Apply the scenarios --> 
        <Application Id="ID.Scenario.Application">
            <ScenarioRefs>
                <ScenarioRef Ref="ID.Scenario.0"/>
            </ScenarioRefs>
        </Application>
    </ScenarioDefinition>
</MPFo>