#![allow(clippy::all, dead_code, unused)]
use cimdecoder::CimDataset;
use crate::Violation;
use crate::helpers::*;
pub fn validate_p61970_452_equipment_ap_con_complex_shacl(dataset: &CimDataset) -> Vec<Violation> {
let mut v = Vec::new();
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_required_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_has_value_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_required_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_has_value_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_ac_line_segment_x_min_excl(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_ac_line_segment_r_min_incl(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_conducting_equipment_base_voltage_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_current_transformer_equipment_equipment_container_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_current_transformer_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_potential_transformer_equipment_equipment_contain_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_potential_transformer_equipment_equipment_contain_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_post_line_sensor_equipment_equipment_container_re_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_post_line_sensor_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_surge_arrester_equipment_equipment_container_requ_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_surge_arrester_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_wave_trap_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_wave_trap_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_fault_indicator_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_fault_indicator_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_busbar_section_equipment_equipment_container_requ_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_busbar_section_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_clamp_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_clamp_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_equipment_equipment_container_has_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cut_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_cut_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_busbar_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_busbar_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_chopper_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_chopper_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_ground_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_ground_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_dc_line_segment_resistance_min_excl(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_series_device_equipment_equipment_container_re_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_series_device_equipment_equipment_container_ha_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_shunt_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_shunt_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_disconnector_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_disconnector_equipment_equipment_container_has_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_breaker_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_dc_breaker_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_day_type_identified_object_name_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_disconnector_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_disconnector_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_grounding_impedance_equipment_equipment_container_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_grounding_impedance_equipment_equipment_container_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_petersen_coil_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_petersen_coil_equipment_equipment_container_has_v_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_energy_source_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_energy_source_equipment_equipment_container_has_v_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_energy_consumer_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_energy_consumer_equipment_equipment_container_has_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_non_conform_load_equipment_equipment_container_re_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_non_conform_load_equipment_equipment_container_ha_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_conform_load_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_conform_load_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_equipment_equipment_cont_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_equipment_equipment_cont_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_equipment_equipment_c_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_equipment_equipment_c_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_external_network_injection_equipment_equipment_co_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_external_network_injection_equipment_equipment_co_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_static_var_compensator_equipment_equipment_contai_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_static_var_compensator_equipment_equipment_contai_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_equipment_equipment_container_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_equipment_equipment_container_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_asynchronous_machine_equipment_equipment_containe_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_asynchronous_machine_equipment_equipment_containe_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_conducting_equipment_base_volta_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_equipment_equipment_container_r_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_injection_equipment_equipment_containe_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_injection_equipment_equipment_containe_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_shunt_equipment_equipment_container_re_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_equivalent_shunt_equipment_equipment_container_ha_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_fuse_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_fuse_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_generating_unit_min_operating_p_l_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_equipment_equipment_contain_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_equipment_equipment_contain_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_equipment_equipment_conta_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_equipment_equipment_conta_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_equipment_equipment_conta_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_equipment_equipment_conta_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_equipment_equipment_contain_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_equipment_equipment_contain_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_equipment_equipment_containe_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_equipment_equipment_containe_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_equipment_equipment_container_req_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_equipment_equipment_container_has_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ground_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ground_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ground_disconnector_equipment_equipment_container_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_ground_disconnector_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_generating_unit_min_operati_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_hydro_pump_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_hydro_pump_equipment_equipment_container_has_value(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_jumper_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_jumper_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_junction_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_junction_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_linear_shunt_compensator_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_shunt_compensator_voltag_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_shunt_compensator_vol_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_point_nonlinear_shunt_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_generating_unit_min_opera_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_equipment_equipment_container_r_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_end_power_transformer_end_g_min_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_end_power_transformer_end_b_max_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_breaker_equipment_equipment_container_required(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_breaker_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_disconnecting_circuit_breaker_equipment_equipment_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_disconnecting_circuit_breaker_equipment_equipment_etc_2(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_load_break_switch_equipment_equipment_container_r_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_load_break_switch_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_regulating_control_regulating_cond_eq_regulating_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_conducting_equipment_base_volt_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_equipment_equipment_container_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_equipment_equipment_container_in(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_generating_unit_min_operati_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_synchronous_machine_min_q_les_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_generating_unit_min_opera_etc(dataset));
v.extend(check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_generating_unit_min_operatin_etc(dataset));
v
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CsConverter>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACDCConverter-containment".to_string(),
class: "CsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CsConverter>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACDCConverter-containment".to_string(),
class: "CsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_required_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CsConverter>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCConverterUnit.Substation-containment".to_string(),
class: "CsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The DCConverterUnit.Substation association is either missing or not pointing to a Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cs_converter_equipment_equipment_container_has_value_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CsConverter>() {
Some(o) => o, None => continue,
};
let ref0 = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
let entry0 = match dataset.entries.get(ref0) {
Some(e) => e, None => continue,
};
let hop1 = match entry0.element.as_any()
.downcast_ref::<cimstructs::DCConverterUnit>() {
Some(o) => o, None => continue,
};
let ref1 = match hop1.substation.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
let entry1 = match dataset.entries.get(ref1) {
Some(e) => e, None => continue,
};
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&entry1.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCConverterUnit.Substation-containment".to_string(),
class: "CsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The DCConverterUnit.Substation association is either missing or not pointing to a Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("VsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::VsConverter>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACDCConverter-containment".to_string(),
class: "VsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("VsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::VsConverter>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACDCConverter-containment".to_string(),
class: "VsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_required_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("VsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::VsConverter>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCConverterUnit.Substation-containment".to_string(),
class: "VsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The DCConverterUnit.Substation association is either missing or not pointing to a Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_vs_converter_equipment_equipment_container_has_value_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("VsConverter").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::VsConverter>() {
Some(o) => o, None => continue,
};
let ref0 = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
let entry0 = match dataset.entries.get(ref0) {
Some(e) => e, None => continue,
};
let hop1 = match entry0.element.as_any()
.downcast_ref::<cimstructs::DCConverterUnit>() {
Some(o) => o, None => continue,
};
let ref1 = match hop1.substation.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
let entry1 = match dataset.entries.get(ref1) {
Some(e) => e, None => continue,
};
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&entry1.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCConverterUnit.Substation-containment".to_string(),
class: "VsConverter".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The DCConverterUnit.Substation association is either missing or not pointing to a Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACDCConverter:containment".to_string(),
description: "For ACDCConverter (CsConverter, VsConverter) the association Equipment.EquipmentContainer is required and shall point to DCEquipmentContainer of type DCConverterUnit. In this case the association DCConverterUnit.Substation is required.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_ac_line_segment_x_min_excl(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ACLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ACLineSegment>() {
Some(o) => o, None => continue,
};
if obj.x.is_none() { continue; }
if obj.x.unwrap() <= 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACLineSegment.x-valueRange".to_string(),
class: "ACLineSegment".to_string(),
property: "ACLineSegment.x".to_string(),
message: "The value is negative or zero.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACLineSegment.x:valueRange".to_string(),
description: "The attribute shall be a positive value. As negative reactance values are not allowed for ACLineSegment-s it is recommended to model series compensators explicitly.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_ac_line_segment_r_min_incl(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ACLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ACLineSegment>() {
Some(o) => o, None => continue,
};
if obj.r.is_none() { continue; }
if obj.r.unwrap() < 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ACLineSegment.r-valueRange".to_string(),
class: "ACLineSegment".to_string(),
property: "ACLineSegment.r".to_string(),
message: "The value is negative.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ACLineSegment.r:valueRange".to_string(),
description: "ACLineSegment.r shall be a positive value or zero.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_conducting_equipment_base_voltage_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ACLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ACLineSegment>() {
Some(o) => o, None => continue,
};
if obj.base.base.base_voltage.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ConductingEquipment.BaseVoltage-whereRequired".to_string(),
class: "ACLineSegment".to_string(),
property: "ConductingEquipment.BaseVoltage".to_string(),
message: "The association ConductingEquipment.BaseVoltage is not provided.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ConductingEquipment.BaseVoltage:whereRequired".to_string(),
description: "The ConductingEquipment.BaseVoltage association is required for the following ConductingEquipment: ACLineSegment, EquivalentBranch and SeriesCompensator. For all other Equipment-s, not contained in a VoltageLevel, the association ConductingEquipment.BaseVoltage can be provided (as it is optional), however the association to BaseVoltage coming from the container or transformer ends takes precedence.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_current_transformer_equipment_equipment_container_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CurrentTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CurrentTransformer>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "CurrentTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_current_transformer_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("CurrentTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::CurrentTransformer>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "CurrentTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_potential_transformer_equipment_equipment_contain_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PotentialTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PotentialTransformer>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "PotentialTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_potential_transformer_equipment_equipment_contain_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PotentialTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PotentialTransformer>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "PotentialTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_post_line_sensor_equipment_equipment_container_re_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PostLineSensor").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PostLineSensor>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "PostLineSensor".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_post_line_sensor_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PostLineSensor").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PostLineSensor>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "PostLineSensor".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_surge_arrester_equipment_equipment_container_requ_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SurgeArrester").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SurgeArrester>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "SurgeArrester".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_surge_arrester_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SurgeArrester").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SurgeArrester>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "SurgeArrester".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_wave_trap_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("WaveTrap").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::WaveTrap>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "WaveTrap".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_wave_trap_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("WaveTrap").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::WaveTrap>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "WaveTrap".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_fault_indicator_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("FaultIndicator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::FaultIndicator>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "FaultIndicator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_fault_indicator_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("FaultIndicator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::FaultIndicator>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:AuxiliaryEquipment-containment".to_string(),
class: "FaultIndicator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:AuxilaryEquipment:containment".to_string(),
description: "For AuxilaryEquipment (CurrentTransformer, PotentialTransformer, PostLineSensor, SurgeArrester, WaveTrap, FaultIndicator) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_busbar_section_equipment_equipment_container_requ_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("BusbarSection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::BusbarSection>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:BusbarSection-containment".to_string(),
class: "BusbarSection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:BusbarSection:containment".to_string(),
description: "For BusbarSection the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel or Bay (when a disconnector is splitting a busbar section in two).".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_busbar_section_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("BusbarSection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::BusbarSection>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:BusbarSection-containment".to_string(),
class: "BusbarSection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:BusbarSection:containment".to_string(),
description: "For BusbarSection the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel or Bay (when a disconnector is splitting a busbar section in two).".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_clamp_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Clamp").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Clamp>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Clamp-containment".to_string(),
class: "Clamp".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Clamp:containment".to_string(),
description: "For Clamp the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_clamp_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Clamp").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Clamp>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Clamp-containment".to_string(),
class: "Clamp".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Clamp:containment".to_string(),
description: "For Clamp the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ACLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ACLineSegment>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Conductor-containment".to_string(),
class: "ACLineSegment".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Conductor:containment".to_string(),
description: "For Conductor (ACLineSegment) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ac_line_segment_equipment_equipment_container_has_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ACLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ACLineSegment>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Conductor-containment".to_string(),
class: "ACLineSegment".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Conductor:containment".to_string(),
description: "For Conductor (ACLineSegment) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cut_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Cut").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Cut>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Cut-containment".to_string(),
class: "Cut".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Cut:containment".to_string(),
description: "For Cut the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_cut_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Cut").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Cut>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Cut-containment".to_string(),
class: "Cut".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Cut:containment".to_string(),
description: "For Cut the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_busbar_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCBusbar").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCBusbar>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCBusbar-containment".to_string(),
class: "DCBusbar".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCBusbar:containment".to_string(),
description: "For DCBusbar the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_busbar_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCBusbar").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCBusbar>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCBusbar-containment".to_string(),
class: "DCBusbar".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCBusbar:containment".to_string(),
description: "For DCBusbar the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_chopper_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCChopper").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCChopper>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCChopper-containment".to_string(),
class: "DCChopper".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCChopper:containment".to_string(),
description: "For DCChopper the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_chopper_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCChopper").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCChopper>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCChopper-containment".to_string(),
class: "DCChopper".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCChopper:containment".to_string(),
description: "For DCChopper the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_ground_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCGround").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCGround>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCGround-containment".to_string(),
class: "DCGround".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCGround:containment".to_string(),
description: "For DCGround the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_ground_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCGround").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCGround>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCGround-containment".to_string(),
class: "DCGround".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCGround:containment".to_string(),
description: "For DCGround the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_dc_line_segment_resistance_min_excl(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCLineSegment>() {
Some(o) => o, None => continue,
};
if obj.resistance.is_none() { continue; }
if obj.resistance.unwrap() <= 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCLineSegment.resistance-valueRange".to_string(),
class: "DCLineSegment".to_string(),
property: "DCLineSegment.resistance".to_string(),
message: "The value is negative or zero.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCLineSegment.resistance:valueRange".to_string(),
description: "The attribute DCLineSegment.resistance shall be a positive value.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCLineSegment>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCLineSegment-containment".to_string(),
class: "DCLineSegment".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCLine or Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCLineSegment:containment".to_string(),
description: "For DCLineSegment the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCLine. In the case of modelling back to back configuration the association shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_line_segment_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCLineSegment").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCLineSegment>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCLine", "Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCLineSegment-containment".to_string(),
class: "DCLineSegment".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCLine or Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCLineSegment:containment".to_string(),
description: "For DCLineSegment the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCLine. In the case of modelling back to back configuration the association shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_series_device_equipment_equipment_container_re_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCSeriesDevice").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCSeriesDevice>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSeriesDevice-containment".to_string(),
class: "DCSeriesDevice".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSeriesDevice:containment".to_string(),
description: "For DCSeriesDevice the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_series_device_equipment_equipment_container_ha_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCSeriesDevice").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCSeriesDevice>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSeriesDevice-containment".to_string(),
class: "DCSeriesDevice".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSeriesDevice:containment".to_string(),
description: "For DCSeriesDevice the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_shunt_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCShunt").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCShunt>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCShunt-containment".to_string(),
class: "DCShunt".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCShunt:containment".to_string(),
description: "For DCShunt the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_shunt_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCShunt").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCShunt>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCShunt-containment".to_string(),
class: "DCShunt".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCShunt:containment".to_string(),
description: "For DCShunt the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_disconnector_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCDisconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCDisconnector>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSwitch-containment".to_string(),
class: "DCDisconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSwitch:containment".to_string(),
description: "For DCSwitch (DCDisconnector, DCBreaker) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_disconnector_equipment_equipment_container_has_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCDisconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCDisconnector>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSwitch-containment".to_string(),
class: "DCDisconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSwitch:containment".to_string(),
description: "For DCSwitch (DCDisconnector, DCBreaker) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_breaker_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCBreaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCBreaker>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSwitch-containment".to_string(),
class: "DCBreaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSwitch:containment".to_string(),
description: "For DCSwitch (DCDisconnector, DCBreaker) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_dc_breaker_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DCBreaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DCBreaker>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:DCSwitch-containment".to_string(),
class: "DCBreaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DCSwitch:containment".to_string(),
description: "For DCSwitch (DCDisconnector, DCBreaker) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_day_type_identified_object_name_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
const ALLOWED: &[&str] = &["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday", "Weekday", "Weekend", "All"];
for mrid in dataset.by_type.get("DayType").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DayType>() {
Some(o) => o, None => continue,
};
if obj.base.name.is_empty() { continue; }
if !ALLOWED.contains(&obj.base.name.as_str()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:IdentifiedObject.name-validValues".to_string(),
class: "DayType".to_string(),
property: "IdentifiedObject.name".to_string(),
message: "Not valid value. The value is not one of the following values: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday, Weekday, Weekend, All.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:DayType.name:validValues".to_string(),
description: "For DayType the name attribute indicates the days of the week that a given DayType represents. The name attribute is restricted to the following names: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday, Weekday, Weekend, All. If the name attribute is All, it represents all seven days of the week. If the name attribute is Weekday, it represents Monday through Friday. If the name attribute is Weekend, it represents Saturday and Sunday.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_disconnector_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Disconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Disconnector>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Disconnector-containment".to_string(),
class: "Disconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Disconnector:containment".to_string(),
description: "For Disconnector the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_disconnector_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Disconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Disconnector>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Disconnector-containment".to_string(),
class: "Disconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Disconnector:containment".to_string(),
description: "For Disconnector the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_grounding_impedance_equipment_equipment_container_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GroundingImpedance").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GroundingImpedance>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EarthFaultCompensator-containment".to_string(),
class: "GroundingImpedance".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EarthFaultCompensator:containment".to_string(),
description: "For EarthFaultCompensator (GroundingImpedance, PetersenCoil) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_grounding_impedance_equipment_equipment_container_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GroundingImpedance").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GroundingImpedance>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EarthFaultCompensator-containment".to_string(),
class: "GroundingImpedance".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EarthFaultCompensator:containment".to_string(),
description: "For EarthFaultCompensator (GroundingImpedance, PetersenCoil) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_petersen_coil_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PetersenCoil").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PetersenCoil>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EarthFaultCompensator-containment".to_string(),
class: "PetersenCoil".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EarthFaultCompensator:containment".to_string(),
description: "For EarthFaultCompensator (GroundingImpedance, PetersenCoil) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_petersen_coil_equipment_equipment_container_has_v_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PetersenCoil").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PetersenCoil>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EarthFaultCompensator-containment".to_string(),
class: "PetersenCoil".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EarthFaultCompensator:containment".to_string(),
description: "For EarthFaultCompensator (GroundingImpedance, PetersenCoil) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_energy_source_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EnergySource").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EnergySource>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "EnergySource".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_energy_source_equipment_equipment_container_has_v_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EnergySource").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EnergySource>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "EnergySource".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_energy_consumer_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EnergyConsumer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EnergyConsumer>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "EnergyConsumer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_energy_consumer_equipment_equipment_container_has_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EnergyConsumer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EnergyConsumer>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "EnergyConsumer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_non_conform_load_equipment_equipment_container_re_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonConformLoad").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonConformLoad>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "NonConformLoad".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_non_conform_load_equipment_equipment_container_ha_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonConformLoad").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonConformLoad>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "NonConformLoad".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_conform_load_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ConformLoad").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ConformLoad>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "ConformLoad".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_conform_load_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ConformLoad").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ConformLoad>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "ConformLoad".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_equipment_equipment_cont_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LinearShuntCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "LinearShuntCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_equipment_equipment_cont_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LinearShuntCompensator>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "LinearShuntCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_equipment_equipment_c_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonlinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonlinearShuntCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "NonlinearShuntCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_equipment_equipment_c_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonlinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonlinearShuntCompensator>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "NonlinearShuntCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_external_network_injection_equipment_equipment_co_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ExternalNetworkInjection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ExternalNetworkInjection>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "ExternalNetworkInjection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_external_network_injection_equipment_equipment_co_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ExternalNetworkInjection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ExternalNetworkInjection>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "ExternalNetworkInjection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_static_var_compensator_equipment_equipment_contai_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("StaticVarCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::StaticVarCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "StaticVarCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_static_var_compensator_equipment_equipment_contai_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("StaticVarCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::StaticVarCompensator>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "StaticVarCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_equipment_equipment_container_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SynchronousMachine").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SynchronousMachine>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "SynchronousMachine".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_equipment_equipment_container_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SynchronousMachine").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SynchronousMachine>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "SynchronousMachine".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_asynchronous_machine_equipment_equipment_containe_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("AsynchronousMachine").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::AsynchronousMachine>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "AsynchronousMachine".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_asynchronous_machine_equipment_equipment_containe_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("AsynchronousMachine").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::AsynchronousMachine>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EnergyConnection-containment".to_string(),
class: "AsynchronousMachine".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EnergyConnection:containment".to_string(),
description: "For EnergyConnection (EnergySource, EnergyConsumer, NonConformLoad, ConformLoad, LinearShuntCompensator, NonlinearShuntCompensator, ExternalNetworkInjection, StaticVarCompensator, SynchronousMachine, AsynchronousMachine) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_conducting_equipment_base_volta_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentBranch").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentBranch>() {
Some(o) => o, None => continue,
};
if obj.base.base.base_voltage.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ConductingEquipment.BaseVoltage-whereRequired".to_string(),
class: "EquivalentBranch".to_string(),
property: "ConductingEquipment.BaseVoltage".to_string(),
message: "The association ConductingEquipment.BaseVoltage is not provided.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ConductingEquipment.BaseVoltage:whereRequired".to_string(),
description: "The ConductingEquipment.BaseVoltage association is required for the following ConductingEquipment: ACLineSegment, EquivalentBranch and SeriesCompensator. For all other Equipment-s, not contained in a VoltageLevel, the association ConductingEquipment.BaseVoltage can be provided (as it is optional), however the association to BaseVoltage coming from the container or transformer ends takes precedence.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_equipment_equipment_container_r_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentBranch").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentBranch>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentBranch-containment".to_string(),
class: "EquivalentBranch".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel, Line or Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentBranch:containment".to_string(),
description: "For EquivalentBranch the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel, Line or Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_branch_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentBranch").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentBranch>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel", "Line", "Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentBranch-containment".to_string(),
class: "EquivalentBranch".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel, Line or Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentBranch:containment".to_string(),
description: "For EquivalentBranch the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel, Line or Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_injection_equipment_equipment_containe_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentInjection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentInjection>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentInjection-containment".to_string(),
class: "EquivalentInjection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentInjection:containment".to_string(),
description: "For EquivalentInjection the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel or Line.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_injection_equipment_equipment_containe_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentInjection").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentInjection>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentInjection-containment".to_string(),
class: "EquivalentInjection".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentInjection:containment".to_string(),
description: "For EquivalentInjection the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel or Line.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_shunt_equipment_equipment_container_re_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentShunt").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentShunt>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentShunt-containment".to_string(),
class: "EquivalentShunt".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentShunt:containment".to_string(),
description: "For EquivalentShunt the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_equivalent_shunt_equipment_equipment_container_ha_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("EquivalentShunt").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::EquivalentShunt>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:EquivalentShunt-containment".to_string(),
class: "EquivalentShunt".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:EquivalentShunt:containment".to_string(),
description: "For EquivalentShunt the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_fuse_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Fuse").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Fuse>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Fuse-containment".to_string(),
class: "Fuse".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Fuse:containment".to_string(),
description: "For Fuse the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_fuse_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Fuse").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Fuse>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Fuse-containment".to_string(),
class: "Fuse".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Fuse:containment".to_string(),
description: "For Fuse the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_generating_unit_min_operating_p_l_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.min_operating_p.is_none() || obj.max_operating_p.is_none() { continue; }
if !((obj.min_operating_p.unwrap() as f64) <= obj.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "GeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_equipment_equipment_contain_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SolarGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SolarGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "SolarGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_equipment_equipment_contain_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SolarGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SolarGeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "SolarGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_equipment_equipment_conta_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NuclearGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NuclearGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "NuclearGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_equipment_equipment_conta_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NuclearGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NuclearGeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "NuclearGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_equipment_equipment_conta_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ThermalGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ThermalGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "ThermalGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_equipment_equipment_conta_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ThermalGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ThermalGeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "ThermalGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_equipment_equipment_contain_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("HydroGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::HydroGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "HydroGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_equipment_equipment_contain_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("HydroGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::HydroGeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "HydroGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_equipment_equipment_containe_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("WindGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::WindGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "WindGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_equipment_equipment_containe_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("WindGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::WindGeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "WindGeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_equipment_equipment_container_req_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "GeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_generating_unit_equipment_equipment_container_has_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GeneratingUnit>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit-containment".to_string(),
class: "GeneratingUnit".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit:containment".to_string(),
description: "For GeneratingUnit (SolarGeneratingUnit, NuclearGeneratingUnit, ThermalGeneratingUnit, HydroGeneratingUnit, WindGeneratingUnit) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ground_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Ground").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Ground>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Ground-containment".to_string(),
class: "Ground".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Ground:containment".to_string(),
description: "For Ground the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or VoltageLevel.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ground_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Ground").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Ground>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Ground-containment".to_string(),
class: "Ground".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Ground:containment".to_string(),
description: "For Ground the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay or VoltageLevel.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ground_disconnector_equipment_equipment_container_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GroundDisconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GroundDisconnector>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GroundDisconnector-containment".to_string(),
class: "GroundDisconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GroundDisconnector:containment".to_string(),
description: "For GroundDisconnector the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_ground_disconnector_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("GroundDisconnector").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::GroundDisconnector>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GroundDisconnector-containment".to_string(),
class: "GroundDisconnector".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GroundDisconnector:containment".to_string(),
description: "For GroundDisconnector the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_hydro_generating_unit_generating_unit_min_operati_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("HydroGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::HydroGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.min_operating_p.is_none() || obj.base.max_operating_p.is_none() { continue; }
if !((obj.base.min_operating_p.unwrap() as f64) <= obj.base.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "HydroGeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_hydro_pump_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("HydroPump").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::HydroPump>() {
Some(o) => o, None => continue,
};
if obj.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:HydroPump-containment".to_string(),
class: "HydroPump".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:HydroPump:containment".to_string(),
description: "For HydroPump the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_hydro_pump_equipment_equipment_container_has_value(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("HydroPump").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::HydroPump>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:HydroPump-containment".to_string(),
class: "HydroPump".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:HydroPump:containment".to_string(),
description: "For HydroPump the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_jumper_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Jumper").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Jumper>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Jumper-containment".to_string(),
class: "Jumper".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Jumper:containment".to_string(),
description: "For Jumper the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_jumper_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Jumper").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Jumper>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit", "Line"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Jumper-containment".to_string(),
class: "Jumper".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel, DCConverterUnit or Line.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Jumper:containment".to_string(),
description: "For Jumper the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_junction_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Junction").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Junction>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Junction-containment".to_string(),
class: "Junction".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Line, Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Junction:containment".to_string(),
description: "For Junction the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Line (in case they model T-junction of a Line), or VoltageLevel or Bay (in case they model named join locations within a Substation).".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_junction_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Junction").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Junction>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Line", "Bay", "VoltageLevel"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:Junction-containment".to_string(),
class: "Junction".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Line, Bay or VoltageLevel.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:Junction:containment".to_string(),
description: "For Junction the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Line (in case they model T-junction of a Line), or VoltageLevel or Bay (in case they model named join locations within a Substation).".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_linear_shunt_compensator_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LinearShuntCompensator>() {
Some(o) => o, None => continue,
};
if obj.g_per_section.is_none() { continue; }
if obj.g_per_section.unwrap() < 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:LinearShuntCompensator.gPerSection-valueRange".to_string(),
class: "LinearShuntCompensator".to_string(),
property: "LinearShuntCompensator.gPerSection".to_string(),
message: "The value is negative.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:LinearShuntCompensator.gPerSection:valueRange".to_string(),
description: "LinearShuntCompensator.gPerSection shall be a positive value or zero.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_linear_shunt_compensator_shunt_compensator_voltag_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LinearShuntCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.voltage_sensitivity.is_none() { continue; }
if obj.base.voltage_sensitivity.unwrap() <= 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ShuntCompensator.voltageSensitivity-valueRange".to_string(),
class: "LinearShuntCompensator".to_string(),
property: "ShuntCompensator.voltageSensitivity".to_string(),
message: "The value is negative or zero.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ShuntCompensator.voltageSensitivity:valueRange".to_string(),
description: "The ShuntCompensator.voltageSensitivity attribute shall be greater than zero.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_shunt_compensator_vol_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonlinearShuntCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonlinearShuntCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.voltage_sensitivity.is_none() { continue; }
if obj.base.voltage_sensitivity.unwrap() <= 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ShuntCompensator.voltageSensitivity-valueRange".to_string(),
class: "NonlinearShuntCompensator".to_string(),
property: "ShuntCompensator.voltageSensitivity".to_string(),
message: "The value is negative or zero.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ShuntCompensator.voltageSensitivity:valueRange".to_string(),
description: "The ShuntCompensator.voltageSensitivity attribute shall be greater than zero.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nonlinear_shunt_compensator_point_nonlinear_shunt_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NonlinearShuntCompensatorPoint").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NonlinearShuntCompensatorPoint>() {
Some(o) => o, None => continue,
};
if obj.g.is_none() { continue; }
if obj.g.unwrap() < 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:NonlinearShuntCompensatorPoint.g-valueRange".to_string(),
class: "NonlinearShuntCompensatorPoint".to_string(),
property: "NonlinearShuntCompensatorPoint.g".to_string(),
message: "The value is negative.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:NonlinearShuntCompensatorPoint.g:valueRange".to_string(),
description: "NonlinearShuntCompensatorPoint.g shall be a positive value or zero.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_nuclear_generating_unit_generating_unit_min_opera_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("NuclearGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::NuclearGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.min_operating_p.is_none() || obj.base.max_operating_p.is_none() { continue; }
if !((obj.base.min_operating_p.unwrap() as f64) <= obj.base.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "NuclearGeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_equipment_equipment_container_r_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PowerTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PowerTransformer>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:PowerTransformer-containment".to_string(),
class: "PowerTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:PowerTransformer:containment".to_string(),
description: "For PowerTransformer the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation or DCConverterUnit. For the case of a transformer that connects two substations, the terminal of one of the PowerTransformerEnd-s can be connected to a ConnectivityNode defined in another substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PowerTransformer").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PowerTransformer>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Substation", "DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:PowerTransformer-containment".to_string(),
class: "PowerTransformer".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Substation or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:PowerTransformer:containment".to_string(),
description: "For PowerTransformer the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Substation or DCConverterUnit. For the case of a transformer that connects two substations, the terminal of one of the PowerTransformerEnd-s can be connected to a ConnectivityNode defined in another substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_end_power_transformer_end_g_min_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PowerTransformerEnd").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PowerTransformerEnd>() {
Some(o) => o, None => continue,
};
if obj.g.is_none() { continue; }
if obj.g.unwrap() < 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:PowerTransformerEnd.g-valueRange".to_string(),
class: "PowerTransformerEnd".to_string(),
property: "PowerTransformerEnd.g".to_string(),
message: "The value is negative.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:PowerTransformerEnd.g:valueRange".to_string(),
description: "PowerTransformerEnd.g shall be positive value or zero. Positive magnetising branch conductance (PowerTransformerEnd.g) means positive active power losses in no load.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_power_transformer_end_power_transformer_end_b_max_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("PowerTransformerEnd").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::PowerTransformerEnd>() {
Some(o) => o, None => continue,
};
if obj.b.is_none() { continue; }
if obj.b.unwrap() > 0_f64 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:PowerTransformerEnd.b-valueRange".to_string(),
class: "PowerTransformerEnd".to_string(),
property: "PowerTransformerEnd.b".to_string(),
message: "The value is positive.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:PowerTransformerEnd.b:valueRange".to_string(),
description: "PowerTransformerEnd.b shall be negative value or zero. Negative magnetising branch susceptance (PowerTransformerEnd.b) means inductive reactive power losses in no load. ".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_breaker_equipment_equipment_container_required(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Breaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Breaker>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "Breaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_breaker_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("Breaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::Breaker>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "Breaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_disconnecting_circuit_breaker_equipment_equipment_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DisconnectingCircuitBreaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DisconnectingCircuitBreaker>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "DisconnectingCircuitBreaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_disconnecting_circuit_breaker_equipment_equipment_etc_2(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("DisconnectingCircuitBreaker").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::DisconnectingCircuitBreaker>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "DisconnectingCircuitBreaker".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_load_break_switch_equipment_equipment_container_r_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LoadBreakSwitch").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LoadBreakSwitch>() {
Some(o) => o, None => continue,
};
if obj.base.base.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "LoadBreakSwitch".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_load_break_switch_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("LoadBreakSwitch").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::LoadBreakSwitch>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Bay", "VoltageLevel", "DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ProtectedSwitch-containment".to_string(),
class: "LoadBreakSwitch".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not Bay, VoltageLevel or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ProtectedSwitch:containment".to_string(),
description: "For ProtectedSwitch (Breaker, DisconnectingCircuitBreaker, LoadBreakSwitch) the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type Bay, VoltageLevel or DCConverterUnit.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_regulating_control_regulating_cond_eq_regulating_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut ref_counts: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
for src_mrid in dataset.by_type.get("AsynchronousMachine").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::AsynchronousMachine>()) {
if let Some(r) = &src.base.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("ExternalNetworkInjection").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::ExternalNetworkInjection>()) {
if let Some(r) = &src.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("LinearShuntCompensator").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::LinearShuntCompensator>()) {
if let Some(r) = &src.base.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("NonlinearShuntCompensator").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::NonlinearShuntCompensator>()) {
if let Some(r) = &src.base.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("PowerElectronicsConnection").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::PowerElectronicsConnection>()) {
if let Some(r) = &src.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("RegulatingCondEq").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::RegulatingCondEq>()) {
if let Some(r) = &src.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("RotatingMachine").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::RotatingMachine>()) {
if let Some(r) = &src.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("ShuntCompensator").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::ShuntCompensator>()) {
if let Some(r) = &src.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("StaticVarCompensator").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::StaticVarCompensator>()) {
if let Some(r) = &src.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
for src_mrid in dataset.by_type.get("SynchronousMachine").into_iter().flatten() {
if let Some(src) = dataset.entries.get(src_mrid)
.and_then(|e| e.element.as_any().downcast_ref::<cimstructs::SynchronousMachine>()) {
if let Some(r) = &src.base.base.regulating_control { *ref_counts.entry(r.mrid.as_str()).or_insert(0) += 1; }
}
}
let mut violations = Vec::new();
for mrid in dataset.by_type.get("RegulatingControl").into_iter().flatten() {
let count = ref_counts.get(mrid.as_str()).copied().unwrap_or(0);
if count < 1 {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:RegulatingControl-RegulatingEquipment".to_string(),
class: "RegulatingControl".to_string(),
property: "C:452:EQ:RegulatingControl:RegulatingEquipment".to_string(),
message: "The RegulatingControl is not associated with an Equpment via RegulatingCondEq.RegulatingControl.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:RegulatingControl:RegulatingEquipment".to_string(),
description: "A RegulatingControl that is not a TapChangerControl must have at least one regulating equipment associated through the RegulatingCondEq.RegulatingControl. That is, a RegulatingControl cannot exist without some equipment using it for regulating.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_conducting_equipment_base_volt_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SeriesCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SeriesCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.base_voltage.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:ConductingEquipment.BaseVoltage-whereRequired".to_string(),
class: "SeriesCompensator".to_string(),
property: "ConductingEquipment.BaseVoltage".to_string(),
message: "The association ConductingEquipment.BaseVoltage is not provided.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:ConductingEquipment.BaseVoltage:whereRequired".to_string(),
description: "The ConductingEquipment.BaseVoltage association is required for the following ConductingEquipment: ACLineSegment, EquivalentBranch and SeriesCompensator. For all other Equipment-s, not contained in a VoltageLevel, the association ConductingEquipment.BaseVoltage can be provided (as it is optional), however the association to BaseVoltage coming from the container or transformer ends takes precedence.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_equipment_equipment_container_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SeriesCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SeriesCompensator>() {
Some(o) => o, None => continue,
};
if obj.base.base.equipment_container.is_none() {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:SeriesCompensator-containment".to_string(),
class: "SeriesCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel, Line or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:SeriesCompensator:containment".to_string(),
description: "For SeriesCompensator the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel when in substation, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_series_compensator_equipment_equipment_container_in(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SeriesCompensator").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SeriesCompensator>() {
Some(o) => o, None => continue,
};
let ref_mrid = match obj.base.base.equipment_container.as_ref() {
Some(r) => r.mrid.trim_start_matches('#'), None => continue,
};
if let Some(ref_entry) = dataset.entries.get(ref_mrid) {
let allowed: &[&str] = &["Line", "VoltageLevel", "DCConverterUnit"];
if !allowed.contains(&ref_entry.element.type_name()) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:SeriesCompensator-containment".to_string(),
class: "SeriesCompensator".to_string(),
property: "Equipment.EquipmentContainer".to_string(),
message: "The containment is either missing or it is not VoltageLevel, Line or DCConverterUnit.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:SeriesCompensator:containment".to_string(),
description: "For SeriesCompensator the association Equipment.EquipmentContainer is required and shall point to EquipmentContainer of type VoltageLevel when in substation, DCConverterUnit or Line when outside substation.".to_string(),
});
}
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_solar_generating_unit_generating_unit_min_operati_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SolarGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SolarGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.min_operating_p.is_none() || obj.base.max_operating_p.is_none() { continue; }
if !((obj.base.min_operating_p.unwrap() as f64) <= obj.base.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "SolarGeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_synchronous_machine_synchronous_machine_min_q_les_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("SynchronousMachine").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::SynchronousMachine>() {
Some(o) => o, None => continue,
};
if obj.min_q.is_none() || obj.max_q.is_none() { continue; }
if !((obj.min_q.unwrap() as f64) <= obj.max_q.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:SynchronousMachine.minQ-valueRangePair".to_string(),
class: "SynchronousMachine".to_string(),
property: "SynchronousMachine.minQ".to_string(),
message: "The value is greater than the value of SynchronousMachine.maxQ.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:SynchronousMachine.maxQ:valueRangePair".to_string(),
description: "SynchronousMachine.maxQ shall be greater than or equal to SynchronousMachine.minQ.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_thermal_generating_unit_generating_unit_min_opera_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("ThermalGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::ThermalGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.min_operating_p.is_none() || obj.base.max_operating_p.is_none() { continue; }
if !((obj.base.min_operating_p.unwrap() as f64) <= obj.base.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "ThermalGeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}
pub fn check_p61970_452_equipment_ap_con_complex_shacl_wind_generating_unit_generating_unit_min_operatin_etc(dataset: &CimDataset) -> Vec<Violation> {
let mut violations = Vec::new();
for mrid in dataset.by_type.get("WindGeneratingUnit").into_iter().flatten() {
let entry = &dataset.entries[mrid];
let obj = match entry.element.as_any()
.downcast_ref::<cimstructs::WindGeneratingUnit>() {
Some(o) => o, None => continue,
};
if obj.base.min_operating_p.is_none() || obj.base.max_operating_p.is_none() { continue; }
if !((obj.base.min_operating_p.unwrap() as f64) <= obj.base.max_operating_p.unwrap() as f64) {
violations.push(Violation {
object_id: mrid.clone(),
rule_id: "eq452:GeneratingUnit.minOperatingP-valueRangePair".to_string(),
class: "WindGeneratingUnit".to_string(),
property: "GeneratingUnit.minOperatingP".to_string(),
message: "The value is greater than the value of GeneratingUnit.maxOperatingP.".to_string(),
severity: "sh:Violation".to_string(),
name: "C:452:EQ:GeneratingUnit.minOperatingP:valueRangePair".to_string(),
description: "GeneratingUnit.maxOperatingP shall be greater than or equal to GeneratingUnit.minOperatingP.".to_string(),
});
}
}
violations
}