CIM RDF Schema Domain Models¶

// Create a new schema class
var acLineSegment = new RdfSchemaClass(
    uri: "#ACLineSegment",
    name: "ACLineSegment",
    label: "AC Line Segment")
    .WithComment("A wire or combination of wires, with consistent electrical characteristics...")
    .WithSuperClass("#Conductor")
    .WithPackage("#Package_WiresProfile")
    .WithStereotype(RdfSchemaStereotype.Concrete);

// Add properties to the class
var resistanceProperty = new RdfSchemaProperty(
    uri: "#ACLineSegment.r",
    name: "r",
    label: "Resistance",
    domainUri: "#ACLineSegment")
    .WithComment("Positive sequence series resistance of the entire line section")
    .WithDataType("#Resistance")
    .WithMultiplicity(RdfSchemaMultiplicity.ExactlyOne)
    .WithStereotype(RdfSchemaStereotype.Attribute);

acLineSegment.AddProperty(resistanceProperty);

// Check class characteristics
Console.WriteLine($"Is Concrete: {acLineSegment.IsConcrete}");
Console.WriteLine($"Is Top Level: {acLineSegment.IsTopLevel}");
Console.WriteLine($"Properties Count: {acLineSegment.Properties.Count}");

// Create an attribute property (has dataType)
var voltageProperty = new RdfSchemaProperty(
    uri: "#Terminal.voltage",
    name: "voltage",
    label: "Voltage",
    domainUri: "#Terminal")
    .WithDataType("#Voltage")
    .WithMultiplicity(RdfSchemaMultiplicity.ZeroOrOne)
    .WithStereotype(RdfSchemaStereotype.Attribute);

Console.WriteLine($"Is Attribute: {voltageProperty.IsAttribute}");
Console.WriteLine($"Is Nullable: {voltageProperty.IsNullable}");

// Create an association property (has range to another class)
var terminalEquipmentProperty = new RdfSchemaProperty(
    uri: "#Terminal.ConductingEquipment",
    name: "ConductingEquipment",
    label: "Conducting Equipment",
    domainUri: "#Terminal")
    .WithRange("#ConductingEquipment")
    .WithMultiplicity(RdfSchemaMultiplicity.ExactlyOne)
    .WithInverseRoleName("#ConductingEquipment.Terminals")
    .WithAssociationUsed(true);

Console.WriteLine($"Is Association: {terminalEquipmentProperty.IsAssociation}");
Console.WriteLine($"Has Inverse: {!string.IsNullOrEmpty(terminalEquipmentProperty.InverseRoleNameUri)}");

// Create a fixed-value property (read-only)
var fixedMultiplierProperty = new RdfSchemaProperty(
    uri: "#ActivePower.multiplier",
    name: "multiplier",
    label: "Multiplier",
    domainUri: "#ActivePower")
    .WithDataType("#UnitMultiplier")
    .WithFixedValue("M")
    .WithMultiplicity(RdfSchemaMultiplicity.ExactlyOne);

Console.WriteLine($"Is Read-Only: {fixedMultiplierProperty.IsReadOnly}");
Console.WriteLine($"Fixed Value: {fixedMultiplierProperty.FixedValue}");

// Create an enumeration class
var phaseCode = new RdfSchemaClass(
    uri: "#PhaseCode",
    name: "PhaseCode",
    label: "Phase Code")
    .WithComment("Enumeration of phase identifiers")
    .WithStereotype(RdfSchemaStereotype.Enumeration);

// Add enumeration values
var enumValues = new[]
{
    new RdfSchemaEnumValue("#PhaseCode.A", "A", "Phase A", "#PhaseCode")
        .WithComment("Phase A"),
    new RdfSchemaEnumValue("#PhaseCode.B", "B", "Phase B", "#PhaseCode")
        .WithComment("Phase B"),
    new RdfSchemaEnumValue("#PhaseCode.C", "C", "Phase C", "#PhaseCode")
        .WithComment("Phase C"),
    new RdfSchemaEnumValue("#PhaseCode.ABC", "ABC", "Phases ABC", "#PhaseCode")
        .WithComment("Three-phase")
};

foreach (var enumValue in enumValues)
{
    phaseCode.AddEnumValue(enumValue);
}

Console.WriteLine($"Is Enumeration: {phaseCode.IsEnumeration}");
Console.WriteLine($"Enum Values: {phaseCode.EnumValues.Count}");

// Access enum values
foreach (var value in phaseCode.EnumValues)
{
    Console.WriteLine($"  {value.Name}: {value.Label}");
}

// Assume we have a parsed profile
RdfSchemaProfile profile = /* ... */;

// Get all concrete classes
var concreteClasses = profile.GetConcreteClasses();
Console.WriteLine($"Concrete classes: {concreteClasses.Count()}");

// Get all enumerations
var enums = profile.GetEnumerations();
foreach (var enumClass in enums)
{
    Console.WriteLine($"Enum: {enumClass.Name}");
    foreach (var value in enumClass.EnumValues)
    {
        Console.WriteLine($"  - {value.Name}");
    }
}

// Get classes by package
var equipmentClasses = profile.GetClassesByPackage("#Package_CoreEquipmentProfile");
Console.WriteLine($"Equipment classes: {equipmentClasses.Count()}");

// Find a specific class
var terminal = profile.GetClassByName("Terminal");
if (terminal != null)
{
    Console.WriteLine($"Found: {terminal.Label}");
    Console.WriteLine($"  Super Class: {terminal.SuperClassUri}");
    Console.WriteLine($"  Properties: {terminal.Properties.Count}");
}

// Get all datatypes
var datatypes = profile.GetCimDatatypes();
foreach (var datatype in datatypes)
{
    Console.WriteLine($"Datatype: {datatype.Name}");
}

// Get all abstract classes
var abstractClasses = profile.GetAbstractClasses();
Console.WriteLine($"Abstract classes: {abstractClasses.Count()}");

// Get the complete inheritance chain for a class
var inheritanceChain = profile.GetInheritanceChain("#ACLineSegment");
Console.WriteLine("Inheritance chain:");
foreach (var ancestor in inheritanceChain)
{
    Console.WriteLine($"  {ancestor.Name}");
}

// Get all properties including inherited ones
var allProperties = profile.GetAllPropertiesForClass("#ACLineSegment");
Console.WriteLine($"\nAll properties (including inherited): {allProperties.Count()}");
foreach (var property in allProperties)
{
    var typeInfo = property.IsAttribute 
        ? $"Attribute: {property.DataTypeUri}" 
        : $"Association: {property.RangeUri}";
    Console.WriteLine($"  {property.Name} ({typeInfo})");
}

// Get direct subclasses
var subclasses = profile.GetSubclasses("#Conductor");
Console.WriteLine($"\nDirect subclasses of Conductor:");
foreach (var subclass in subclasses)
{
    Console.WriteLine($"  {subclass.Name}");
}

// Check if a class is at the top of its hierarchy
var identifiedObject = profile.GetClassByName("IdentifiedObject");
if (identifiedObject != null)
{
    Console.WriteLine($"\nIs top-level class: {identifiedObject.IsTopLevel}");
}

// Create packages
var corePackage = new RdfSchemaPackage(
    uri: "#Package_Core",
    label: "Core Package")
    .WithComment("Core package contains fundamental types");

var equipmentPackage = new RdfSchemaPackage(
    uri: "#Package_Equipment",
    label: "Equipment Package")
    .WithComment("Equipment package contains electrical equipment models");

// Build a profile
var version = new Cgmes3SchemaVersion()
    .WithVersion("3.0.0")
    .WithShortName("EQ")
    .WithDescription("Equipment Profile");

var profile = new RdfSchemaProfile(version)
    .AddPackage(corePackage)
    .AddPackage(equipmentPackage);

// Add classes to the profile
profile.AddClass(identifiedObject)
    .AddClass(acLineSegment)
    .AddClass(terminal);

Console.WriteLine($"Profile: {profile.Version.ShortName}");
Console.WriteLine($"Classes: {profile.Classes.Count}");
Console.WriteLine($"Packages: {profile.Packages.Count}");

var class1 = new RdfSchemaClass("#Terminal", "Terminal", "Terminal");
var class2 = new RdfSchemaClass("#Terminal", "Terminal", "Terminal");

// Value equality - these are considered equal
Assert.True(class1.Equals(class2));

var property = new RdfSchemaProperty("#Terminal.voltage", "voltage", "Voltage", "#Terminal")
    .WithDataType("#Voltage")
    .WithMultiplicity(RdfSchemaMultiplicity.ZeroOrOne)
    .WithStereotype(RdfSchemaStereotype.Attribute)
    .WithComment("The terminal voltage");

var schemaClass = new RdfSchemaClass("#ACLineSegment", "ACLineSegment", "AC Line Segment")
    .WithSuperClass("#Conductor")
    .WithPackage("#Package_Wires")
    .WithStereotype(RdfSchemaStereotype.Concrete)
    .AddProperty(property);

// RdfSchemaClass
bool isEnum = schemaClass.IsEnumeration;      // Stereotype == Enumeration
bool isPrimitive = schemaClass.IsPrimitive;   // Stereotype == Primitive
bool isConcrete = schemaClass.IsConcrete;     // Stereotype == Concrete || contains "concrete"
bool isAbstract = schemaClass.IsAbstract;     // Not concrete, enum, primitive, or datatype
bool isTopLevel = schemaClass.IsTopLevel;     // No super class defined

// RdfSchemaProperty
bool isAttribute = property.IsAttribute;      // Has DataTypeUri
bool isAssociation = property.IsAssociation;  // Has RangeUri
bool isReadOnly = property.IsReadOnly;        // Has FixedValue
bool isNullable = property.IsNullable;        // Multiplicity allows zero

// Query by type
var enums = profile.GetEnumerations();
var concreteClasses = profile.GetConcreteClasses();
var primitives = profile.GetPrimitives();

// Query by identifier
var terminal = profile.GetClassByUri("#Terminal");
var terminalByName = profile.GetClassByName("Terminal");

// Query by relationship
var subclasses = profile.GetSubclasses("#IdentifiedObject");
var classesInPackage = profile.GetClassesByPackage("#Package_Core");

// Inheritance queries
var chain = profile.GetInheritanceChain("#ACLineSegment");
var allProps = profile.GetAllPropertiesForClass("#ACLineSegment");

// Stereotype classification
switch (schemaClass.Stereotype)
{
    case RdfSchemaStereotype.Concrete:
        // Can be instantiated
        break;
    case RdfSchemaStereotype.Enumeration:
        // Has enum values
        break;
    case RdfSchemaStereotype.Primitive:
        // Basic data type
        break;
    case RdfSchemaStereotype.CimDatatype:
        // CIM-specific type with unit
        break;
}

// Multiplicity-based logic
var isRequired = property.Multiplicity == RdfSchemaMultiplicity.ExactlyOne ||
                 property.Multiplicity == RdfSchemaMultiplicity.OneOrMore;

var isCollection = property.Multiplicity == RdfSchemaMultiplicity.ZeroOrMore ||
                   property.Multiplicity == RdfSchemaMultiplicity.OneOrMore;