Naming Conventions

The IRI of an entity has two parts: the namespace and the local identifier. Within one RDF document the namespace might be associated by a shorter prefix. For instance the namespace IRI http://www.w3.org/2002/07/owl# is commonly associated with the prefix owl: and one can write owl:Class instead of the full IRI http://www.w3.org/2002/07/owl#Class.

Within the biomedical domain the local identifier is often an alphanumeric ID which is not human readable. The Allotrope Foundation Taxonomies follow this approach, e.g. a process is represented as af-p:AFP_0001617. To enhance readability within this document, the preferred label from the ontology or taxonomy is used for the corresponding entity. I.e., instead of af-p:AFP_0001617 the corresponding entity is named as af-p:process. If the namespace is clear by the context the prefix MAY be omitted and the entity is named simply process. If the label contains spaces, the entity MAY be surrounded by Guillemets to avoid ambiguities, e.g. «af-p:experimental method».

Namespaces

Within this specification, the following namespace prefix bindings are used:

Indication of Requirement Levels

Within this document the definitions of MUST, SHOULD and MAY are used as defined in [[!rfc2119]].

Number Formatting

Within this document, decimal numbers will use a dot "." as the decimal mark.

Primitive Data Types

Primitive data types encompass all valid primitive RDF types (for details see [[rdf11-concepts]] section on data types) such as xsd:integer, xsd:double, xsd:String etc. as well as rdfs:Resource.

Complex Data Types

Complex data types MAY be used when a single primitive data type is not sufficient to represent the values of one component. For instance, a measurement value with a unit or an error MAY be expressed by a complex data type.

ex:QuantityValueType  a sh:Shape ;
    sh:property [
      sh:predicate qudt:numericValue;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:Literal;
      sh:datatype xsd:double
    ];
    sh:property [
      sh:predicate qudt:unit;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:IRI;   	# the specified unit has to be an IRI
      sh:class qudt:Unit; 	# the unit must be an instance of qudt:Unit
    ];
    .
                

ex:MassValue a qudt:QuantityValue ;
    qudt:numericValue "15"^^xsd:double ;
    qudt:unit   qudt-unit:Gram .
                

ex:WeighingResultType  a sh:Shape ;
   sh:property [
      sh:predicate «af-x:tare weight»;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:Blank;             # the object of 'tare weight' MAY be a blank node
      sh:valueShape ex:MassValueType;   # use nested mass value shape
   ] ;
   sh:property [
      sh:predicate «af-x:net weight»;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:Blank;
      sh:valueShape ex:MassValueType;   # use nested mass value shape
   ] ;
    .

ex:MassValueType  a sh:Shape ;
    sh:property [
      sh:predicate qudt:numericValue;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:Literal;
      sh:datatype xsd:double
    ];
    sh:property [
      sh:predicate qudt:standardUncertainty;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:Literal;
      sh:datatype xsd:double
    ];
    sh:property [
      sh:predicate qudt:unit;
      sh:minCount 1;
      sh:maxCount 1;
      sh:nodeKind sh:IRI;
      sh:hasValue qudt-unit:Gram; 	# the unit MUST be qudt-unit:Gram
    ] .
                

ex:WeighingResult a af-r:Result ;
    «af-x:tare weight» [
        qudt:numericValue "25.3332"^^xsd:double ;
        qudt:standardUncertainty "0.2"^^xsd:double ;
        qudt-unit:Gram
    ] ;
    «af-x:net weight» [
        qudt:numericValue "20.219"^^xsd:double ;
        qudt:standardUncertainty "0.2"^^xsd:double ;
        qudt-unit:Gram
    ] ;
                

Nominal Scale

The nominal scale differentiates between items or subjects based only on their names or (meta-)categories and other qualitative classifications they belong to; thus dichotomous data involves the construction of classifications as well as the classification of items. In general, nominal scales are used always, when the values of a component can be tested only for equality (==, !=) but no 'natural' order can be defined. This is the case for example for measured colors ("red", "blue"...) or for the IRIs of measured samples (continued example):

ex:SampleDimension  a   qb:ComponentSpecification ,
                        adf-dc:Dimension,
                        adf-dc:NominalScale ;
                    qb:dimension «af-r:measured sample» .
				

Ordinal Scale

An ordinal scale is a scale which allows for rank order (1st, 2nd, 3rd, etc. or very good, good, average, bad) by which data can be sorted, but still does not allow for relative degree of difference between them. Ordinal scales are used for example for an index dimension that represents subsequent measurements or a peak list:

ex:IndexDimension a qb:ComponentSpecification ,
                    adf-dc:Dimension ,
                    adf-dc:OrdinalScale ;
                    qb:dimension «af-x:index» .
				

Cardinal Scale

A cardinal scale is a scale where the difference between two values can be measured and its meaning is independent of the absolute values. There are two types of cardinal scales, namely interval scale and ratio scale which are described next.

ex:TemperatureDimension a   qb:ComponentSpecification ,
                            adf-dc:Dimension ,
                            adf-dc:IntervalScale ;
                        qb:dimension «af-x:temperature» .
                    

ex:MassDimension    a   qb:ComponentSpecification ,
                        adf-dc:Dimension ,
                        adf-dc:RatioScale ;
                    qb:dimension «af-x:net weight» .
                    

Native Order

A native order is defined as the total order of real numbers or subsets thereof if a component specfication refers to xsd:integer, xsd:decimal, xsd:double, xsd:float. The native order for timestamps and durations (xsd:dateTime, xsd:date, xsd:duration) is in increasing time and the native order of booleans (xsd:boolean) is: false is less than true.

Regarding the example above, the ex:IndexDimension can be associated with a native order as follows:

ex:IndexDimension   a   adf-dc:Dimension, adf-dc:OrdinalScale;
                    adf-dc:orderedBy ex:nativeOrder .
                

The framework MUST support implementation of native orders for all primitive XSD data types.

Lexicographical Order

The lexicographical order is an order function which defines an order of elements by characters. It is defined for example for a component specification with component data type xsd:string.

# index dimension adaptation to the example above, if the integer property «af-x:index» would be replaced by a string identifier property
ex:obs123 a qb:Observation ;
    qb:dataSet ex:MassMeasurementResult ;
    dct:identifier "sample 4".

ex:IndexDimension a adf-dc:Dimension, adf-dc:OrdinalScale ;
    qb:dimension dct:identifier;
    adf-dc:orderedBy adf-dc:lexicographicalOrder .
                

Quantity Value Order

The quantity value order is an order function which is defined for instances of qudt:QuantityValue which describe values with the same underlying quantity kind. This ordering orders the quantitiy values by its numeric value normalized to the SI standard unit, e.g. all length quantity values are first converted internally into meter and then ordered by the normalized numeric value.

Regarding the example above, the ex:TimeDimension can be associated with a quantity value order as follows:

ex:TimeDimension adf-dc:orderedBy adf-dc:quantityValueOrder .
                

The properties defined in the property path MUST be specified by full URIs.

The framework MUST implement the actual comparison functions which tolerate quantity values with different units of the same quantity kind. E.g. a duration specified in minutes is comparable to a duration specified in seconds. The different factors are provided by [[!QUDT]].

Complex Value Order

A complex value order is an order function which is defined for component specifications with complex data types which are represented by shapes. It consists of a set of items each defining a property path of the shape, an order number and an (sub) order function for the respective values. Thus, a complex value order can be considered as a sorted list of orders specified for property path of a shape. A complex value order is a generalization of the quantity value order.

ex:MassMeasure adf-dc:orderedBy ex:complexResultOrder .

ex:complexResultOrder a adf-dc:ComplexValueOrder;
    adf-dc:hasItem [
        adf-dc:propertyPath "«af-x:net weight»/qudt:numericValue"; # points to a primitive value
        adf-dc:order 1;                             # the net weight numeric value is considered first
        adf-dc:orderedBy adf-dc:nativeOrder ;       # standard reference to native order
    ];
    adf-dc:hasItem [
        adf-dc:propertyPath "«af-x:tare weight»";   # points to a complex value
        adf-dc:order 2;                             # the tare weight is considered second within the complex result order
        adf-dc:orderedBy adf-dc:quantityValueOrder  # reference to an order function, which handles the complex data type.
    ].
                

The second item of ex:complexResultOrder shows how nesting works in order functions.

QB Slices

The RDF Data Cube Vocabulary [[!QB]] provides the concept of a slice. A slice denotes a subset of a data set, defined by fixing a subset of the dimensional values. That is a qb:Slice allows to restrict selected dimensions to some set of single values.

Data Selections

ADF-DCO introduces the concept of data selections. Data selections can be based on dimensions or measures.

If a selection is (solely) based on the dimensions of the cube, such a selection is called a data slab. The slices defined in QB are a special kind of slabs.

If a selection is based on the measures, it is a projection or a filter. If a subset of multiple measures is selected or parts of the datatypes of the measures are selected via property paths, then the selection is a data projection.

If the selection is based on the observed values, then it is a data filter. While filters and slabs look similar, there is an important difference between them: In the case of dimensions, it is required that each value of the dimension is distinct from another within the same dimension. No duplicate values are possible, otherwise the dimension could never identify the point in the cube. For measures this limitation does not exist.

A data selection is an n-dimensional subset of a data cube where the set of observations (i.e. the measures) are selected based on component selections on dimensions or measures. The following figure illustrates the adf-dc:DataSelection with related classes in QB:

For each dimension component of the data structure definition, the selection structure definition MUST specify a dimension selection. For each measure componenent of the data structure definition, that is part of the selection the selection structure definition MUST specify a measure selection. There MUST be at least one measure selection defined. A data selection allows defining different types of component selections on components such as point or range selections. If no point or range selection is specified, the component selection is assumed to be an unbounded selection, however the type of selection SHOULD be explicitly stated.
The different types of selections are described below.

The running example for the following subsections is a cell counter measurement result, expressed by a data cube with two dimension components (index and sample) and one measurement component (total cell count).

# An observation of the data cube
ex:obs13 a qb:Observation;
   qb:dataSet ex:CellCounterResultSet;
   «af-x:index» 3;
   «af-x:sample» ex:sample1;
   «af-x:total cell count» 98 .

# The data cube has a structure
ex:CellCounterResultSet a qb:DataSet, «af-x:cell counter measurement result»;
   qb:structure ex:CellCountStructure .

# The data structure definition specifies three components
ex:CellCountStructure a qb:DataStructureDefinition;
   qb:component ex:IndexDimension;
   qb:component ex:SampleDimension;
   qb:component ex:CellCountMeasure .

# dimension: index
ex:IndexDimension a qb:ComponentSpecification, adf-dc:Dimension, adf-dc:OrdinalScale ;
   qb:dimension «af-x:index»;
   qb:order 1;
   adf-dc:componentDataType xsd:integer .

# dimension: sample
ex:SampleDimension a qb:ComponentSpecification, adf-dc:Dimension, adf-dc:NominalScale ;
   qb:dimension «af-x:sample»;
   qb:order 2;
   adf-dc:componentDataType rdfs:Resource .

# measure: cell count
ex:CellCountMeasure a qb:ComponentSpecification, adf-dc:Measure, adf-dc:OrdinalScale ;
   qb:measure «af-x:total cell count»;
   adf-dc:componentDataType xsd:integer .
                

Component Selections

A component selection is a specification of a set of values of a single component specification of a data cube. The following figure illustrates the different subclasses of adf-dc:ComponentSelection that further define the kind of selection used:

Selections are either defined by list of items (point selection) or through range selections depending on the type of component specification. The other criterion is whether the selection is done on a dimension or on a measure. If the component selection is a selection on a measure it is a measure selection, if it is a selection on a dimension then it is a dimension selection. If a measure selection is not the unbounded selection, then the data selection acts as a filter on the data cube. If not all measures of the data structure definition are selected or the measure selection has defined property paths on the underlying datatype, the data selection acts as projection on the data cube. A data selection needs to specify for each dimension component exactly one component selection - so the data slab part MUST be always fully defined. Based on the data structure definition a adf-dc:DataSelection with a corresponding adf-dc:SelectionStructureDefinition is specified as follows:

# The data selection is a slab
ex:CellCounterSlab a adf-dc:DataSelection;
    adf-dc:dataSelectionOf ex:CellCounterResultSet ;
    qb:structure ex:CellCountSlabStructure .

# The selection structure definition specifies two component selections for the dimension components
# defining the slab and includes the measure component
ex:CellCountSlabStructure a adf-dc:SelectionStructureDefinition;
   adf-dc:selects ex:IndexDimensionSelection;
   adf-dc:selects ex:SampleDimensionSelection;
   adf-dc:selects ex:CellCountMeasureSelection;
                

The kind of scale of the dimension component determines which selections are allowed.

# The sample dimension selection is a point selection
ex:SampleDimensionSelection a adf-dc:PointSelection, adf-dc:DimensionSelection ;
    adf-dc:selectionOn ex:SampleDimension ;
    adf-dc:hasItem ex:sample1, ex:sample2, ex:sample10 .
                    

# The cell count measure selection is an unbounded selection
ex:CellCountMeasureSelection a adf-dc:UnboundedSelection, adf-dc:MeasureSelection ;
    adf-dc:selectionOn ex:CellCountMeasure ;
                    

# The index dimension selection defines a range
ex:IndexDimensionSelection a adf-dc:RangeSelection, adf-dc:DimensionSelection ;
    adf-dc:selectionOn ex:IndexDimension ;
    adf-dc:minimumValue 2;
    adf-dc:maximumValue 10;
                    

ex:TimeDimension    a   qb:ComponentSpecification,
                        adf-dc:Dimension,
                        adf-dc:IntervalScale ;
                    qb:dimension «af-x:total retention time»;
                    qb:order 1;
                    adf-dc:componentDataType ex:DurationType .
                    

ex:DurationType a sh:Shape ;
    sh:property [
          sh:predicate qudt:numericValue;
          sh:minCount 1;
          sh:maxCount 1;
          sh:nodeKind sh:Literal ;
          sh:datatype xsd:double ;
        ];
   sh:property [
          sh:predicate qudt:unit;
          sh:minCount 1;
          sh:maxCount 1;
          sh:nodeKind sh:IRI;
          sh:class qudt:TimeUnit  # i.e. allowed values are e.g. qudt-unit:Second etc.
        ];
        .
                    

ex:TimeDimensionSelection a adf-dc:RangeSelection, adf-dc:DimensionSelection ;
    adf-dc:selectionOn ex:TimeDimension ;
    # from 0.5 seconds
    adf-dc:minimum [
        a qudt:QuantityValue ;
        qudt:numericValue 0.5;
        qudt:unit qudt-unit:Second
    ];
    # up to half an hour
    adf-dc:maximum [
        a qudt:QuantityValue ;
        qudt:numericValue 30;
        qudt:unit qudt-unit:MinuteTime
    ];
                    

ex:TimeMeasure    a   qb:ComponentSpecification,
                        adf-dc:Measure,
                        adf-dc:IntervalScale ;
                    qb:dimension «af-x:total retention time»;
                    qb:order 1;
                    adf-dc:componentDataType ex:DurationType .

ex:TimeMeasureSelection a adf-dc:UnboundedSelection, adf-dc:MeasureSelection; # selection on measure, no filtering on data
                     adf-dc:selectionOn ex:TimeMeasure;
                     adf-dc:propertyPath "qudt:numericValue"; # projection on the numeric value part of the complex data type DurationType