SemanticSTEP defines a way to map ISO 10303 (STEP) data to ontologies using OWL/RDF. The result is a set of specialized SemanticSTEP Express schemas for the core parts of STEP standard and a corresponding set of ontologies, which are derived from these Express schemas.
The following SemanticSTEP ontologies are available:
To create SemanticSTEP Express schemas, a special schema - OwlRdfSchema is used. It describes the common functionality defined in RDF, RDF/S and OWL in Express, therefore allowing subsequent SemanticSTEP Express schemas to be based on it.
The purpose of the OwlRdfSchema is to provide basic functionality defined in RDF, RDF/S and OWL in the form of an Express Schema, so that other specializing schemas can take advantage of it. This allows the development of software applications using "traditional" Express tools such as JSDAI and then conversion of the data to/from OWL/RDF on a pure syntactic level.
OwlRdfSchema - Click to enlarge
From a STEP point's of view the main difference between STEP and SemanticSTEP is that entity instances may either have a URI so that they can be accessed from the outside and linked with other data or they have no URI and thus can only be referenced locally. In the OwlRdfSchema this is covered by AnonymousThing for blank nodes and IdentifiedThing for nodes with a URI. Making entities a subtype of IdentifiedThing enforces the definition of a URI for the thing. Subtypes of AnonymousThing should not have a URI and if provided it has no additional meaning for the purpose of SemanticSTEP and all external references to it will be ignored.
Resources are IdentifiedThings with a URI that is either a URL or a SHA1-URN. In the case that the URI is a URL this should specify the location from where the resource can be accessed with a HTTP get method. In the case of a SHA1-URN this should uniquely identify the resource without specifying from where it is available. See the implementation of "git" on further details about the usage of SHA1 for resources. Here an example of a SHA1-URN:
urn:sha1:YNCKHTQCWBTRNJIV4WNAE52SJUQCZO5C
The usage of SHA1-URNs can turn the Semantic Web into a Content-Addressable one. Resources can be replicated anywhere (e.g. on the local computer, a local server or a server for long term archiving) and the client can always verify if a particular resource fits with the provided URN.
Some resources are NamedGraphs, containing OWL/RDF statements and optionally including other NamedGraphs. The calculation of the SHA-1 for an OWL/RDF resource should be calculated in such a form that the arrangement of statements and the actual representation of blank nodes is not relevant for the result of the SHA-1 identification. The first aspect might be achieved by using a verbose sorted representation of the OWL/RDF graph instead of a compact representation. Details to be provided in D3.4.
A key concept for the implementation and understanding of SemanticSTEP is that a NamedGraph contains only statements about things, but it does not contain the things itself. There may be other NamedGraphs containing further or even contradicting statements. Because of this, NamedGraphs can be referenced by statements in other NamedGraphs for e.g. certification and approval purpose. In addition a statement within a named graph can directly refer to it's containing NamedGraph.
To be able to distinguish for the receiver of data whether an IdentifiedThing is a resource or not only resources should have an id of type URL or SHA-1 URN. For all other IdentifiedThings URNs should be used that are not SHA1-URNs. Possible examples for application data are UUID-URNs in the form
urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66
An advantage to use UUID-URNs is that the ID does not claim any particular ownership of the one using the URN the first time. For the purpose of product data exchange this seems to be rather important because it allows e.g. that a designer is creating some data and identifies the objects in it. Later the data is passed over to some subcontractor and then further to a main contractor and finally to an OEM and from there to some end-customer. In such scenarios it is not desired that the object identification is "owned" by the original designer.
The kind of statements that are of primary interest for the SemanticWeb are DatatypeProperty and ObjectProperty as defined in RDF. For the purpose of the SemanticSTEP the domain is a Thing and the typeIdentification is identified by a PropertyType, which is a sub-sub type of IdentifiedThing.
Within the SemanticSTEP many specializations of DatatypeProperty and ObjectProperty are defined and further specializations may be included in application data. The specializations differ only on the constraints for the domain, type and range values. The type attribute must indicate the particular type of property. It may be either pre-defined in one of the SemanticSTEP schemas or provided within the application data..
The type of a Property is given by subtypes of PropertyType, either a DatatypePropertyType or a ObjectPropertyType. An ObjectPropertyType is either a FunctionalPropertyType, a InverseFunctionalPropertyType, a InversePropertyType, a SymmetricPropertyType or a TransitivePropertyType. These subtypes correspond to the specify property characteristics defined in OWL.
Property statements can be used in two different ways within SemanticSTEP. Either the typeIdentification is explicitly given by application data or it is fixed and defined as part of the SemanticSTEP. In the latter case the name of the entity specialization of DatatypeProperty and ObjectProperty is converted into a URI to be used for the type.
The STEP Integrated Resources provide for most string attributes only a single value, assuming that all data is recorded in a single language. Only with AP214 the concept of multi linguism was introduced and later wrapped up in an application module. Because it was not possible to change the Integrated Resources, some complicated data-structure on top of the existing data models had to be developed to provide the needed capability. In XML however, the used language can directly be specified together with the string value. This capability is made explicit for the SemanticSTEP by the entity StringWithLanguage and it's subtypes Label and Comment. All attributes of these types will be converted into corresponding statements.
SCHEMA OwlRdfSchema;
TYPE language_tag = STRING;
END_TYPE;
TYPE uri = STRING;
END_TYPE;
TYPE urn = uri;
END_TYPE;
TYPE sha1Urn = urn;
END_TYPE;
TYPE url = uri;
END_TYPE;
TYPE urlOrSha1Urn = SELECT
(sha1Urn, url);
END_TYPE;
TYPE namedGraphElement = EXTENSIBLE GENERIC_ENTITY SELECT
(Statement);
END_TYPE;
ENTITY ThingOrClass
ABSTRACT SUPERTYPE OF (ONEOF( Thing, Class));
END_ENTITY;
ENTITY Thing
ABSTRACT SUPERTYPE OF (ONEOF (AnonymousThing, IdentifiedThing))
SUBTYPE OF (ThingOrClass);
END_ENTITY;
ENTITY IdentifiedThing
ABSTRACT SUPERTYPE OF (ONEOF (Resource, PropertyType))
SUBTYPE OF (Thing);
globalUniqueIdentifier : uri;
END_ENTITY;
ENTITY AnonymousThing
ABSTRACT SUPERTYPE
SUBTYPE OF (Thing);
END_ENTITY;
ENTITY Class
SUBTYPE OF (ThingOrClass);
globalUniqueIdentifier : uri;
END_ENTITY;
ENTITY PropertyType
ABSTRACT SUPERTYPE OF (ONEOF (ObjectPropertyType, DatatypePropertyType))
SUBTYPE OF (IdentifiedThing);
END_ENTITY;
ENTITY ObjectPropertyType
SUPERTYPE OF (ONEOF (FunctionalPropertyType, InversePropertyType, SymmetricPropertyType, TransitivePropertyType, InverseFunctionalPropertyType))
SUBTYPE OF (PropertyType);
END_ENTITY;
ENTITY DatatypePropertyType
SUBTYPE OF (PropertyType);
END_ENTITY;
ENTITY FunctionalPropertyType
SUBTYPE OF (ObjectPropertyType);
END_ENTITY;
ENTITY InversePropertyType
SUBTYPE OF (ObjectPropertyType);
inverseOf : ObjectPropertyType;
END_ENTITY;
ENTITY SymmetricPropertyType
SUBTYPE OF (ObjectPropertyType);
END_ENTITY;
ENTITY TransitivePropertyType
SUBTYPE OF (ObjectPropertyType);
END_ENTITY;
ENTITY InverseFunctionalPropertyType
SUBTYPE OF (ObjectPropertyType);
END_ENTITY;
ENTITY Resource
SUBTYPE OF (IdentifiedThing);
SELF\IdentifiedThing.globalUniqueIdentifier : urlOrSha1Urn;
END_ENTITY;
ENTITY NamedGraph
SUBTYPE OF (Resource);
imports : OPTIONAL SET[1:?] OF NamedGraph;
content : SET [0:?] OF namedGraphElement;
END_ENTITY;
ENTITY Statement
ABSTRACT SUPERTYPE OF (Property);
END_ENTITY;
ENTITY Property
ABSTRACT SUPERTYPE OF (ONEOF (DatatypeProperty, ObjectProperty))
SUBTYPE OF (Statement);
domain : ThingOrClass;
typeIdentification : OPTIONAL PropertyType;
END_ENTITY;
ENTITY DatatypeProperty
ABSTRACT SUPERTYPE
SUBTYPE OF (Property);
SELF\Property.typeIdentification : OPTIONAL DatatypePropertyType;
range : GENERIC;
END_ENTITY;
ENTITY ObjectProperty
ABSTRACT SUPERTYPE OF (ONEOF (ofType, subClassOf))
SUBTYPE OF (Property);
SELF\Property.typeIdentification : OPTIONAL ObjectPropertyType;
range : ThingOrClass;
END_ENTITY;
ENTITY ofType
SUBTYPE OF (ObjectProperty);
SELF\Property.domain : Thing;
SELF\ObjectProperty.range : Class;
END_ENTITY;
ENTITY subClassOf
SUBTYPE OF (ObjectProperty);
SELF\Property.domain : Class;
SELF\ObjectProperty.range : Class;
DERIVE
SELF\Property.typeIdentification : TransitivePropertyType := ?;
END_ENTITY;
ENTITY StringWithLanguage
ABSTRACT SUPERTYPE OF (ONEOF(Label,Comment));
string_value : STRING;
lang : OPTIONAL language_tag;
END_ENTITY;
ENTITY Label
SUBTYPE OF (StringWithLanguage);
END_ENTITY;
ENTITY Comment
SUBTYPE OF (StringWithLanguage);
END_ENTITY;
SUBTYPE_CONSTRAINT thingOrClassTotalOver FOR ThingOrClass;
TOTAL_OVER (Thing, Class);
END_SUBTYPE_CONSTRAINT;
END_SCHEMA;
Download OwlRdfSchema as a separate Express schema (.exp) file:
