From 4988360caf48ad7ea19abe60d7dc2f3826bf3bb9 Mon Sep 17 00:00:00 2001 From: Richard Lincoln Date: Mon, 8 Nov 2010 00:58:31 +0000 Subject: [PATCH] Adding class meta-data attributes. --- schemata/CIM14/CombinedVersion.py | 13 ++++++--- schemata/CIM14/Dynamics/AsynchronousMachine.py | 13 ++++++--- schemata/CIM14/Dynamics/AttributeBlockParameter.py | 13 ++++++--- schemata/CIM14/Dynamics/Block.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockConnection.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockConnectivity.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockConstant.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockInputReference.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockInputType.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockOutputReference.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockOutputType.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockParameter.py | 13 ++++++--- schemata/CIM14/Dynamics/BlockType.py | 13 ++++++--- .../CIM14/Dynamics/BlockUsageInputReference.py | 13 ++++++--- .../CIM14/Dynamics/BlockUsageOutputReference.py | 13 ++++++--- schemata/CIM14/Dynamics/CompositeModel.py | 13 ++++++--- schemata/CIM14/Dynamics/ConnectionFrame.py | 13 ++++++--- schemata/CIM14/Dynamics/ExcitationSystemLimiter.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC1A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC2A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC3A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC4A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC5A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC6A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC7B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcAC8B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcBAS.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcBBC.py | 13 ++++++--- schemata/CIM14/Dynamics/ExcitationSystems/ExcCZ.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcDC1A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcDC2A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcDC3A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcDC4B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcELIN1.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcELIN2.py | 13 ++++++--- schemata/CIM14/Dynamics/ExcitationSystems/ExcHU.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcPIC.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcREXS.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcSCRX.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcSEXS.py | 13 ++++++--- schemata/CIM14/Dynamics/ExcitationSystems/ExcSK.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcSK2.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST1A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST2A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST3A.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST4B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST5B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST6B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcST7B.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcWT2E.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcWT3E.py | 13 ++++++--- .../CIM14/Dynamics/ExcitationSystems/ExcWT4E.py | 13 ++++++--- .../Dynamics/ExcitationSystems/ExcitationSystem.py | 13 ++++++--- schemata/CIM14/Dynamics/Generators/GenAsync.py | 13 ++++++--- schemata/CIM14/Dynamics/Generators/GenEquiv.py | 13 ++++++--- schemata/CIM14/Dynamics/Generators/GenLoad.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/AggregateLoad.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadMotor.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadStatic.py | 15 ++++++++--- schemata/CIM14/Dynamics/Loads/LoadStaticArea.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadStaticBus.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadStaticOwner.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadStaticSystem.py | 13 ++++++--- schemata/CIM14/Dynamics/Loads/LoadStaticZone.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlock.py | 15 ++++++++--- schemata/CIM14/Dynamics/MetaBlockConInput.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockConOutput.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockConSignal.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockConnectable.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockConnection.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockConnectivity.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockInput.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockInputReference.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockOutput.py | 13 ++++++--- .../CIM14/Dynamics/MetaBlockOutputReference.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockParameter.py | 13 ++++++--- .../CIM14/Dynamics/MetaBlockParameterReference.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockReference.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockSignal.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockState.py | 13 ++++++--- schemata/CIM14/Dynamics/MetaBlockStateReference.py | 13 ++++++--- schemata/CIM14/Dynamics/Motors/MechLoad1.py | 13 ++++++--- schemata/CIM14/Dynamics/Motors/MechanicalLoad.py | 13 ++++++--- schemata/CIM14/Dynamics/Motors/MotorAsync.py | 13 ++++++--- schemata/CIM14/Dynamics/Motors/MotorSync.py | 15 ++++++++--- .../PowerSystemStabilizer.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssIEEE1A.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssIEEE2B.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssIEEE3B.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssIEEE4B.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssPTIST1.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssPTIST3.py | 13 ++++++--- .../CIM14/Dynamics/PowerSystemStabilizers/PssSB.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssSB4.py | 13 ++++++--- .../CIM14/Dynamics/PowerSystemStabilizers/PssSH.py | 13 ++++++--- .../CIM14/Dynamics/PowerSystemStabilizers/PssSK.py | 13 ++++++--- .../Dynamics/PowerSystemStabilizers/PssWSCC.py | 13 ++++++--- schemata/CIM14/Dynamics/ProtectiveDevice.py | 13 ++++++--- schemata/CIM14/Dynamics/RotatingMachine.py | 13 ++++++--- schemata/CIM14/Dynamics/Slot.py | 13 ++++++--- schemata/CIM14/Dynamics/SlotConnection.py | 13 ++++++--- schemata/CIM14/Dynamics/SlotInput.py | 13 ++++++--- schemata/CIM14/Dynamics/SlotOutput.py | 13 ++++++--- schemata/CIM14/Dynamics/SlotReference.py | 13 ++++++--- schemata/CIM14/Dynamics/SourceModels.py | 13 ++++++--- schemata/CIM14/Dynamics/StaticVarDevice.py | 13 ++++++--- schemata/CIM14/Dynamics/TieToMeasurement.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/Class1.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/GovCT1.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/GovCT2.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/GovDUM.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovGASM.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovGAST.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovGAST2.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovGASTWD.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydro0.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydro1.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydro2.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydro3.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydro4.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydroDD.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydroPID.py | 13 ++++++--- .../Dynamics/TurbineGovernors/GovHydroPID2.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydroR.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovHydroWEH.py | 13 ++++++--- .../Dynamics/TurbineGovernors/GovHydroWPID.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/GovRAV.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteam0.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteam1.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteamCC.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteamEU.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteamFV2.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteamFV3.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovSteamSGO.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT1P.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT1T.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT2P.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT2T.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT3P.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT3T.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT4P.py | 13 ++++++--- .../CIM14/Dynamics/TurbineGovernors/GovWT4T.py | 13 ++++++--- schemata/CIM14/Dynamics/TurbineGovernors/TLCFB1.py | 13 ++++++--- .../Dynamics/TurbineGovernors/TurbineGovernor.py | 13 ++++++--- schemata/CIM14/Dynamics/UserBlockParameter.py | 13 ++++++--- .../Dynamics/VoltageCompensator/VcompCross.py | 13 ++++++--- .../CIM14/Dynamics/VoltageCompensator/VcompIEEE.py | 13 ++++++--- .../VoltageCompensator/VoltageCompensator.py | 13 ++++++--- schemata/CIM14/Element.py | 11 ++++++-- schemata/CIM14/IEC61968/AssetModels/AssetModel.py | 17 ++++++++---- schemata/CIM14/IEC61968/AssetModels/CableInfo.py | 19 ++++++++----- .../AssetModels/ConcentricNeutralCableInfo.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/ConductorInfo.py | 17 ++++++++---- .../AssetModels/DistributionWindingTest.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/EndDeviceModel.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/OpenCircuitTest.py | 13 ++++++--- .../IEC61968/AssetModels/OverheadConductorInfo.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/ShortCircuitTest.py | 13 ++++++--- .../IEC61968/AssetModels/TapeShieldCableInfo.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/ToWindingSpec.py | 13 ++++++--- .../CIM14/IEC61968/AssetModels/TransformerInfo.py | 13 ++++++--- schemata/CIM14/IEC61968/AssetModels/WindingInfo.py | 15 ++++++++--- .../CIM14/IEC61968/AssetModels/WireArrangement.py | 13 ++++++--- schemata/CIM14/IEC61968/AssetModels/WireType.py | 15 ++++++++--- schemata/CIM14/IEC61968/Assets/AcceptanceTest.py | 13 ++++++--- schemata/CIM14/IEC61968/Assets/Asset.py | 13 ++++++--- schemata/CIM14/IEC61968/Assets/AssetContainer.py | 13 ++++++--- schemata/CIM14/IEC61968/Assets/AssetFunction.py | 13 ++++++--- schemata/CIM14/IEC61968/Assets/ComMediaAsset.py | 13 ++++++--- schemata/CIM14/IEC61968/Assets/Seal.py | 17 ++++++++---- schemata/CIM14/IEC61968/Common/ActivityRecord.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/Agreement.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/CoordinateSystem.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/DateTimeInterval.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/Document.py | 13 ++++++--- .../CIM14/IEC61968/Common/ElectronicAddress.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/Location.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/Organisation.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/PositionPoint.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/PostalAddress.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/Status.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/StreetAddress.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/StreetDetail.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/TelephoneNumber.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/TimePoint.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/TimeSchedule.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/TownDetail.py | 13 ++++++--- schemata/CIM14/IEC61968/Common/UserAttribute.py | 13 ++++++--- schemata/CIM14/IEC61968/Customers/Customer.py | 15 ++++++++--- .../CIM14/IEC61968/Customers/CustomerAccount.py | 13 ++++++--- .../CIM14/IEC61968/Customers/CustomerAgreement.py | 13 ++++++--- .../CIM14/IEC61968/Customers/PricingStructure.py | 15 ++++++++--- .../CIM14/IEC61968/Customers/ServiceCategory.py | 15 ++++++++--- .../CIM14/IEC61968/Customers/ServiceLocation.py | 13 ++++++--- schemata/CIM14/IEC61968/Customers/Tariff.py | 13 ++++++--- schemata/CIM14/IEC61968/IEC61968CIMVersion.py | 13 ++++++--- .../LoadControl/ConnectDisconnectFunction.py | 13 ++++++--- .../LoadControl/RemoteConnectDisconnectInfo.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/ComFunction.py | 13 ++++++--- .../IEC61968/Metering/DemandResponseProgram.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/DeviceFunction.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/DynamicDemand.py | 15 ++++++++--- .../IEC61968/Metering/ElectricMeteringFunction.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/EndDeviceAsset.py | 13 ++++++--- .../CIM14/IEC61968/Metering/EndDeviceControl.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/EndDeviceEvent.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/EndDeviceGroup.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/IntervalBlock.py | 13 ++++++--- .../CIM14/IEC61968/Metering/IntervalReading.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/MeterAsset.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/MeterReading.py | 13 ++++++--- .../CIM14/IEC61968/Metering/MeterServiceWork.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/Pending.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/Reading.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/ReadingQuality.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/ReadingType.py | 19 ++++++++----- schemata/CIM14/IEC61968/Metering/Register.py | 13 ++++++--- schemata/CIM14/IEC61968/Metering/SDPLocation.py | 13 ++++++--- .../IEC61968/Metering/ServiceDeliveryPoint.py | 15 ++++++++--- .../IEC61968/PaymentMetering/AccountMovement.py | 13 ++++++--- .../IEC61968/PaymentMetering/AccountingUnit.py | 17 ++++++++---- .../IEC61968/PaymentMetering/AuxiliaryAccount.py | 13 ++++++--- .../IEC61968/PaymentMetering/AuxiliaryAgreement.py | 13 ++++++--- .../IEC61968/PaymentMetering/BankAccountDetail.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Card.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Cashier.py | 13 ++++++--- .../CIM14/IEC61968/PaymentMetering/CashierShift.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Charge.py | 15 ++++++++--- schemata/CIM14/IEC61968/PaymentMetering/Cheque.py | 15 ++++++++--- .../PaymentMetering/ConsumptionTariffInterval.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Due.py | 13 ++++++--- .../CIM14/IEC61968/PaymentMetering/LineDetail.py | 13 ++++++--- .../IEC61968/PaymentMetering/MerchantAccount.py | 13 ++++++--- .../IEC61968/PaymentMetering/MerchantAgreement.py | 13 ++++++--- .../CIM14/IEC61968/PaymentMetering/PointOfSale.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Receipt.py | 13 ++++++--- .../IEC61968/PaymentMetering/ServiceSupplier.py | 15 ++++++++--- schemata/CIM14/IEC61968/PaymentMetering/Shift.py | 13 ++++++--- .../IEC61968/PaymentMetering/TariffProfile.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Tender.py | 15 ++++++++--- .../IEC61968/PaymentMetering/TimeTariffInterval.py | 13 ++++++--- .../CIM14/IEC61968/PaymentMetering/Transaction.py | 15 ++++++++--- .../CIM14/IEC61968/PaymentMetering/Transactor.py | 13 ++++++--- schemata/CIM14/IEC61968/PaymentMetering/Vendor.py | 13 ++++++--- .../CIM14/IEC61968/PaymentMetering/VendorShift.py | 13 ++++++--- .../IEC61968/WiresExt/DistributionLineSegment.py | 13 ++++++--- .../IEC61968/WiresExt/DistributionTapChanger.py | 15 ++++++++--- .../IEC61968/WiresExt/DistributionTransformer.py | 13 ++++++--- .../WiresExt/DistributionTransformerWinding.py | 13 ++++++--- .../IEC61968/WiresExt/PerLengthPhaseImpedance.py | 13 ++++++--- .../WiresExt/PerLengthSequenceImpedance.py | 13 ++++++--- .../CIM14/IEC61968/WiresExt/PhaseImpedanceData.py | 13 ++++++--- .../CIM14/IEC61968/WiresExt/TransformerBank.py | 13 ++++++--- .../CIM14/IEC61968/WiresExt/WindingPiImpedance.py | 13 ++++++--- schemata/CIM14/IEC61968/Work/Work.py | 15 ++++++++--- schemata/CIM14/IEC61970/Contingency/Contingency.py | 13 ++++++--- .../IEC61970/Contingency/ContingencyElement.py | 13 ++++++--- .../IEC61970/Contingency/ContingencyEquipment.py | 15 ++++++++--- .../IEC61970/ControlArea/AltGeneratingUnitMeas.py | 13 ++++++--- schemata/CIM14/IEC61970/ControlArea/AltTieMeas.py | 13 ++++++--- schemata/CIM14/IEC61970/ControlArea/ControlArea.py | 15 ++++++++--- .../ControlArea/ControlAreaGeneratingUnit.py | 13 ++++++--- schemata/CIM14/IEC61970/ControlArea/TieFlow.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/BasePower.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/BaseVoltage.py | 13 ++++++--- .../CIM14/IEC61970/Core/BasicIntervalSchedule.py | 21 ++++++++++----- schemata/CIM14/IEC61970/Core/Bay.py | 17 ++++++++---- .../CIM14/IEC61970/Core/ConductingEquipment.py | 15 ++++++++--- schemata/CIM14/IEC61970/Core/ConnectivityNode.py | 13 ++++++--- .../IEC61970/Core/ConnectivityNodeContainer.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/Curve.py | 31 +++++++++++++--------- schemata/CIM14/IEC61970/Core/CurveData.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/Equipment.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/EquipmentContainer.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/GeographicalRegion.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/IdentifiedObject.py | 13 ++++++--- .../IEC61970/Core/IrregularIntervalSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/IrregularTimePoint.py | 13 ++++++--- .../CIM14/IEC61970/Core/OperatingParticipant.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/OperatingShare.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/PSRType.py | 13 ++++++--- .../CIM14/IEC61970/Core/PowerSystemResource.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/PsrList.py | 13 ++++++--- .../CIM14/IEC61970/Core/RegularIntervalSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/RegularTimePoint.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/ReportingGroup.py | 13 ++++++--- .../CIM14/IEC61970/Core/ReportingSuperGroup.py | 13 ++++++--- .../CIM14/IEC61970/Core/SubGeographicalRegion.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/Substation.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/Terminal.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/Unit.py | 13 ++++++--- schemata/CIM14/IEC61970/Core/VoltageLevel.py | 13 ++++++--- .../CIM14/IEC61970/Equivalents/EquivalentBranch.py | 13 ++++++--- .../IEC61970/Equivalents/EquivalentEquipment.py | 13 ++++++--- .../IEC61970/Equivalents/EquivalentInjection.py | 13 ++++++--- .../IEC61970/Equivalents/EquivalentNetwork.py | 13 ++++++--- .../CIM14/IEC61970/Equivalents/EquivalentShunt.py | 13 ++++++--- .../GenerationDynamics/BWRSteamSupply.py | 13 ++++++--- .../GenerationDynamics/CTTempActivePowerCurve.py | 13 ++++++--- .../GenerationDynamics/CombustionTurbine.py | 13 ++++++--- .../Generation/GenerationDynamics/DrumBoiler.py | 13 ++++++--- .../GenerationDynamics/FossilSteamSupply.py | 15 ++++++++--- .../GenerationDynamics/HeatRecoveryBoiler.py | 13 ++++++--- .../Generation/GenerationDynamics/HydroTurbine.py | 15 ++++++++--- .../GenerationDynamics/PWRSteamSupply.py | 13 ++++++--- .../Generation/GenerationDynamics/PrimeMover.py | 13 ++++++--- .../Generation/GenerationDynamics/SteamSupply.py | 13 ++++++--- .../Generation/GenerationDynamics/SteamTurbine.py | 13 ++++++--- .../Generation/GenerationDynamics/Subcritical.py | 13 ++++++--- .../Generation/GenerationDynamics/Supercritical.py | 13 ++++++--- .../Generation/Production/AirCompressor.py | 13 ++++++--- .../IEC61970/Generation/Production/CAESPlant.py | 13 ++++++--- .../Generation/Production/CogenerationPlant.py | 13 ++++++--- .../Generation/Production/CombinedCyclePlant.py | 13 ++++++--- .../Generation/Production/EmissionAccount.py | 17 ++++++++---- .../Generation/Production/EmissionCurve.py | 15 ++++++++--- .../IEC61970/Generation/Production/FossilFuel.py | 15 ++++++++--- .../Production/FuelAllocationSchedule.py | 15 ++++++++--- .../Generation/Production/GenUnitOpCostCurve.py | 13 ++++++--- .../Generation/Production/GenUnitOpSchedule.py | 13 ++++++--- .../Generation/Production/GeneratingUnit.py | 19 ++++++++----- .../Production/GrossToNetActivePowerCurve.py | 13 ++++++--- .../Generation/Production/HeatInputCurve.py | 13 ++++++--- .../Generation/Production/HeatRateCurve.py | 13 ++++++--- .../Production/HydroGeneratingEfficiencyCurve.py | 13 ++++++--- .../Generation/Production/HydroGeneratingUnit.py | 15 ++++++++--- .../Generation/Production/HydroPowerPlant.py | 15 ++++++++--- .../IEC61970/Generation/Production/HydroPump.py | 13 ++++++--- .../Generation/Production/HydroPumpOpSchedule.py | 13 ++++++--- .../Production/IncrementalHeatRateCurve.py | 13 ++++++--- .../Generation/Production/InflowForecast.py | 13 ++++++--- .../Generation/Production/LevelVsVolumeCurve.py | 13 ++++++--- .../Generation/Production/NuclearGeneratingUnit.py | 13 ++++++--- .../Generation/Production/PenstockLossCurve.py | 13 ++++++--- .../IEC61970/Generation/Production/Reservoir.py | 13 ++++++--- .../Generation/Production/ShutdownCurve.py | 13 ++++++--- .../Generation/Production/StartIgnFuelCurve.py | 15 ++++++++--- .../Generation/Production/StartMainFuelCurve.py | 15 ++++++++--- .../Generation/Production/StartRampCurve.py | 13 ++++++--- .../IEC61970/Generation/Production/StartupModel.py | 13 ++++++--- .../Generation/Production/SteamSendoutSchedule.py | 13 ++++++--- .../Generation/Production/TailbayLossCurve.py | 13 ++++++--- .../Generation/Production/TargetLevelSchedule.py | 13 ++++++--- .../Generation/Production/ThermalGeneratingUnit.py | 13 ++++++--- .../Generation/Production/WindGeneratingUnit.py | 13 ++++++--- schemata/CIM14/IEC61970/IEC61970CIMVersion.py | 13 ++++++--- .../Informative/InfCore/ModelingAuthority.py | 13 ++++++--- .../Informative/InfCore/ModelingAuthoritySet.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/ConformLoad.py | 13 ++++++--- .../CIM14/IEC61970/LoadModel/ConformLoadGroup.py | 13 ++++++--- .../IEC61970/LoadModel/ConformLoadSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/DayType.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/EnergyArea.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/LoadArea.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/LoadGroup.py | 13 ++++++--- .../LoadModel/LoadResponseCharacteristic.py | 13 ++++++--- .../CIM14/IEC61970/LoadModel/NonConformLoad.py | 13 ++++++--- .../IEC61970/LoadModel/NonConformLoadGroup.py | 13 ++++++--- .../IEC61970/LoadModel/NonConformLoadSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/PowerCutZone.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/Season.py | 15 ++++++++--- .../IEC61970/LoadModel/SeasonDayTypeSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/StationSupply.py | 13 ++++++--- schemata/CIM14/IEC61970/LoadModel/SubLoadArea.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Accumulator.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/AccumulatorLimit.py | 13 ++++++--- .../CIM14/IEC61970/Meas/AccumulatorLimitSet.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/AccumulatorValue.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Analog.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/AnalogLimit.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/AnalogLimitSet.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/AnalogValue.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Command.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Control.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/ControlType.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/CurrentTransformer.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Discrete.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/DiscreteValue.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Limit.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/LimitSet.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Measurement.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/MeasurementValue.py | 13 ++++++--- .../CIM14/IEC61970/Meas/MeasurementValueQuality.py | 13 ++++++--- .../CIM14/IEC61970/Meas/MeasurementValueSource.py | 13 ++++++--- .../CIM14/IEC61970/Meas/PotentialTransformer.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/Quality61850.py | 17 ++++++++---- schemata/CIM14/IEC61970/Meas/SetPoint.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/StringMeasurement.py | 13 ++++++--- .../CIM14/IEC61970/Meas/StringMeasurementValue.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/ValueAliasSet.py | 13 ++++++--- schemata/CIM14/IEC61970/Meas/ValueToAlias.py | 13 ++++++--- .../IEC61970/OperationalLimits/ActivePowerLimit.py | 13 ++++++--- .../OperationalLimits/ApparentPowerLimit.py | 13 ++++++--- .../IEC61970/OperationalLimits/BranchGroup.py | 13 ++++++--- .../OperationalLimits/BranchGroupTerminal.py | 13 ++++++--- .../IEC61970/OperationalLimits/CurrentLimit.py | 13 ++++++--- .../IEC61970/OperationalLimits/OperationalLimit.py | 13 ++++++--- .../OperationalLimits/OperationalLimitSet.py | 13 ++++++--- .../OperationalLimits/OperationalLimitType.py | 15 ++++++++--- .../IEC61970/OperationalLimits/VoltageLimit.py | 13 ++++++--- schemata/CIM14/IEC61970/Outage/ClearanceTag.py | 13 ++++++--- schemata/CIM14/IEC61970/Outage/ClearanceTagType.py | 13 ++++++--- schemata/CIM14/IEC61970/Outage/OutageSchedule.py | 13 ++++++--- .../CIM14/IEC61970/Outage/SwitchingOperation.py | 15 ++++++++--- schemata/CIM14/IEC61970/Protection/CurrentRelay.py | 13 ++++++--- .../CIM14/IEC61970/Protection/FaultIndicator.py | 13 ++++++--- .../IEC61970/Protection/ProtectionEquipment.py | 13 ++++++--- .../CIM14/IEC61970/Protection/RecloseSequence.py | 13 ++++++--- .../CIM14/IEC61970/Protection/SurgeProtector.py | 13 ++++++--- .../CIM14/IEC61970/Protection/SynchrocheckRelay.py | 13 ++++++--- schemata/CIM14/IEC61970/SCADA/CommunicationLink.py | 13 ++++++--- schemata/CIM14/IEC61970/SCADA/RemoteControl.py | 13 ++++++--- schemata/CIM14/IEC61970/SCADA/RemotePoint.py | 13 ++++++--- schemata/CIM14/IEC61970/SCADA/RemoteSource.py | 13 ++++++--- schemata/CIM14/IEC61970/SCADA/RemoteUnit.py | 15 ++++++++--- .../CIM14/IEC61970/StateVariables/StateVariable.py | 13 ++++++--- .../CIM14/IEC61970/StateVariables/SvInjection.py | 13 ++++++--- .../CIM14/IEC61970/StateVariables/SvPowerFlow.py | 13 ++++++--- .../IEC61970/StateVariables/SvShortCircuit.py | 13 ++++++--- .../StateVariables/SvShuntCompensatorSections.py | 13 ++++++--- schemata/CIM14/IEC61970/StateVariables/SvStatus.py | 13 ++++++--- .../CIM14/IEC61970/StateVariables/SvTapStep.py | 13 ++++++--- .../CIM14/IEC61970/StateVariables/SvVoltage.py | 13 ++++++--- .../IEC61970/StateVariables/TopologicalIsland.py | 13 ++++++--- schemata/CIM14/IEC61970/Topology/BusNameMarker.py | 13 ++++++--- .../CIM14/IEC61970/Topology/TopologicalNode.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/ACLineSegment.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Breaker.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/BusbarSection.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/CompositeSwitch.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Conductor.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Connector.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/DCLineSegment.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Disconnector.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/EnergyConsumer.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/EnergySource.py | 13 ++++++--- .../CIM14/IEC61970/Wires/FrequencyConverter.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Fuse.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Ground.py | 13 ++++++--- .../CIM14/IEC61970/Wires/GroundDisconnector.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/HeatExchanger.py | 13 ++++++--- .../IEC61970/Wires/ImpedanceVariationCurve.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Jumper.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Junction.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Line.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/LoadBreakSwitch.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/MutualCoupling.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/PhaseTapChanger.py | 15 ++++++++--- .../CIM14/IEC61970/Wires/PhaseVariationCurve.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Plant.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/PowerTransformer.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/ProtectedSwitch.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/RatioTapChanger.py | 15 ++++++++--- .../CIM14/IEC61970/Wires/RatioVariationCurve.py | 13 ++++++--- .../IEC61970/Wires/ReactiveCapabilityCurve.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/RectifierInverter.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/RegulatingCondEq.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/RegulatingControl.py | 15 ++++++++--- .../CIM14/IEC61970/Wires/RegulationSchedule.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/Resistor.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/SeriesCompensator.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/ShuntCompensator.py | 13 ++++++--- .../CIM14/IEC61970/Wires/StaticVarCompensator.py | 15 ++++++++--- schemata/CIM14/IEC61970/Wires/Switch.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/SwitchSchedule.py | 13 ++++++--- .../CIM14/IEC61970/Wires/SynchronousMachine.py | 19 ++++++++----- schemata/CIM14/IEC61970/Wires/TapChanger.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/TapSchedule.py | 13 ++++++--- .../CIM14/IEC61970/Wires/TransformerWinding.py | 17 ++++++++---- .../CIM14/IEC61970/Wires/VoltageControlZone.py | 13 ++++++--- schemata/CIM14/IEC61970/Wires/WindingTest.py | 13 ++++++--- schemata/CIM14/__init__.py | 7 +---- 472 files changed, 4788 insertions(+), 1496 deletions(-) diff --git a/schemata/CIM14/CombinedVersion.py b/schemata/CIM14/CombinedVersion.py index 964be03..b9d3846 100644 --- a/schemata/CIM14/CombinedVersion.py +++ b/schemata/CIM14/CombinedVersion.py @@ -20,8 +20,8 @@ class CombinedVersion(Element): """The combined version denotes the versions of the subpackages that have been combined into the total CIIMmodel. This is a convenience instead of having to look at each subpackage. """ - def __init__(self, version='', date='', **kw_args): - """Initializes a new 'CombinedVersion' instance. + def __init__(self, version='', date='', *args, **kw_args): + """Initialises a new 'CombinedVersion' instance. @param version: Form is IEC61970CIMXXvYY_IEC61968CIMXXvYY_combined where XX is the major CIM package version and the YY is the minor version, and different packages could have different major and minor versions. For example IEC61970CIM13v18_IEC61968CIM10v16_combined. Additional packages might be added in the future. @param date: Form is YYYY-MM-DD for example for January 5, 2009 it is 2009-01-05. @@ -32,5 +32,12 @@ class CombinedVersion(Element): #: Form is YYYY-MM-DD for example for January 5, 2009 it is 2009-01-05. self.date = date - super(CombinedVersion, self).__init__(**kw_args) + super(CombinedVersion, self).__init__(*args, **kw_args) + + _attrs = ["version", "date"] + _attr_types = {"version": str, "date": str} + _defaults = {"version": '', "date": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/AsynchronousMachine.py b/schemata/CIM14/Dynamics/AsynchronousMachine.py index f9f7969..b64250e 100644 --- a/schemata/CIM14/Dynamics/AsynchronousMachine.py +++ b/schemata/CIM14/Dynamics/AsynchronousMachine.py @@ -20,8 +20,8 @@ class AsynchronousMachine(RotatingMachine): """An asynchronous (induction) machine with no external connection to the rotor windings, e.g squirel-cage induction machine. """ - def __init__(self, xm=0.0, xs=0.0, xpp=0.0, xlr2=0.0, rr2=0.0, tpo=0.0, rr1=0.0, xp=0.0, tppo=0.0, xlr1=0.0, **kw_args): - """Initializes a new 'AsynchronousMachine' instance. + def __init__(self, xm=0.0, xs=0.0, xpp=0.0, xlr2=0.0, rr2=0.0, tpo=0.0, rr1=0.0, xp=0.0, tppo=0.0, xlr1=0.0, *args, **kw_args): + """Initialises a new 'AsynchronousMachine' instance. @param xm: Magnetizing reactance @param xs: Synchronous reactance (>= Xp) @@ -64,5 +64,12 @@ class AsynchronousMachine(RotatingMachine): #: Damper 1 winding leakage reactance self.xlr1 = xlr1 - super(AsynchronousMachine, self).__init__(**kw_args) + super(AsynchronousMachine, self).__init__(*args, **kw_args) + + _attrs = ["xm", "xs", "xpp", "xlr2", "rr2", "tpo", "rr1", "xp", "tppo", "xlr1"] + _attr_types = {"xm": float, "xs": float, "xpp": float, "xlr2": float, "rr2": float, "tpo": float, "rr1": float, "xp": float, "tppo": float, "xlr1": float} + _defaults = {"xm": 0.0, "xs": 0.0, "xpp": 0.0, "xlr2": 0.0, "rr2": 0.0, "tpo": 0.0, "rr1": 0.0, "xp": 0.0, "tppo": 0.0, "xlr1": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/AttributeBlockParameter.py b/schemata/CIM14/Dynamics/AttributeBlockParameter.py index c4ef9be..2aa42a5 100644 --- a/schemata/CIM14/Dynamics/AttributeBlockParameter.py +++ b/schemata/CIM14/Dynamics/AttributeBlockParameter.py @@ -20,13 +20,20 @@ class AttributeBlockParameter(MetaBlockParameter): """An attribute from the associated PowerSystemResource is used. This is like reflection into the UML model as one must name the paramter the same as the CIM name of the desired attribute. Such parameters are not important for completely standard models as the relation to the CIM attributes is fixed. This object is required for user defined models that use attributes already existing on the PowerSystemResource or its derived classes. Using this class avoids creating new paramter instances (with values) when we already have the values as class attributes of the associated PowerSystemResource. Standard block models might optinally use objects of this class to convey information about the internals of the standard block. """ - def __init__(self, attributeName='', **kw_args): - """Initializes a new 'AttributeBlockParameter' instance. + def __init__(self, attributeName='', *args, **kw_args): + """Initialises a new 'AttributeBlockParameter' instance. @param attributeName: The name of the attribute in the information model. This could be any attribute of the derived class of the power system resource for which the block is intended to be used. For example, if the one were using the xxx attribute from Generator class, one would specifiy this attribute as 'xxx'. This would also limit the block to only those classes which have an 'xxx' attribute. This attribute could be replaced by using the inherited IdentifiedObject.name value for the purpose described above. """ #: The name of the attribute in the information model. This could be any attribute of the derived class of the power system resource for which the block is intended to be used. For example, if the one were using the xxx attribute from Generator class, one would specifiy this attribute as 'xxx'. This would also limit the block to only those classes which have an 'xxx' attribute. This attribute could be replaced by using the inherited IdentifiedObject.name value for the purpose described above. self.attributeName = attributeName - super(AttributeBlockParameter, self).__init__(**kw_args) + super(AttributeBlockParameter, self).__init__(*args, **kw_args) + + _attrs = ["attributeName"] + _attr_types = {"attributeName": str} + _defaults = {"attributeName": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Block.py b/schemata/CIM14/Dynamics/Block.py index 917f22a..812cb23 100644 --- a/schemata/CIM14/Dynamics/Block.py +++ b/schemata/CIM14/Dynamics/Block.py @@ -20,8 +20,8 @@ class Block(PowerSystemResource): """A specific usage of a dynamics block, supplied with parameters and any linkages to the power system static model that are required. Sometimes a block is used to simply specify a location of input or output from dyanmics equations to the static model. """ - def __init__(self, positiveFlowIn=False, inService=False, Terminal=None, MemberOf_BlockConnectivity=None, blockUsageInputReference0=None, BlockUsageOutputReference=None, PowerSystemResource=None, slotReference0=None, tieToMeasurement0=None, MetaBlock=None, BlockConnection=None, BlockParameter=None, **kw_args): - """Initializes a new 'Block' instance. + def __init__(self, positiveFlowIn=False, inService=False, Terminal=None, MemberOf_BlockConnectivity=None, blockUsageInputReference0=None, BlockUsageOutputReference=None, PowerSystemResource=None, slotReference0=None, tieToMeasurement0=None, MetaBlock=None, BlockConnection=None, BlockParameter=None, *args, **kw_args): + """Initialises a new 'Block' instance. @param positiveFlowIn: If true then any flows associated with a terminal are referenced as positive into the device. @param inService: @@ -72,7 +72,14 @@ class Block(PowerSystemResource): self._BlockParameter = [] self.BlockParameter = [] if BlockParameter is None else BlockParameter - super(Block, self).__init__(**kw_args) + super(Block, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn", "inService"] + _attr_types = {"positiveFlowIn": bool, "inService": bool} + _defaults = {"positiveFlowIn": False, "inService": False} + _enums = {} + _refs = ["Terminal", "MemberOf_BlockConnectivity", "blockUsageInputReference0", "BlockUsageOutputReference", "PowerSystemResource", "slotReference0", "tieToMeasurement0", "MetaBlock", "BlockConnection", "BlockParameter"] + _many_refs = ["blockUsageInputReference0", "BlockUsageOutputReference", "tieToMeasurement0", "BlockConnection", "BlockParameter"] def getTerminal(self): """The optional terminal to which the block applies. This is used to link a specific terminal flow to the dynamics block. diff --git a/schemata/CIM14/Dynamics/BlockConnection.py b/schemata/CIM14/Dynamics/BlockConnection.py index 1787127..19ab8f8 100644 --- a/schemata/CIM14/Dynamics/BlockConnection.py +++ b/schemata/CIM14/Dynamics/BlockConnection.py @@ -20,8 +20,8 @@ class BlockConnection(IdentifiedObject): """A meta-dyanamics model connectivity specification. """ - def __init__(self, MetaBlockConnection=None, MemberOf_BlockConnectivity=None, Block=None, **kw_args): - """Initializes a new 'BlockConnection' instance. + def __init__(self, MetaBlockConnection=None, MemberOf_BlockConnectivity=None, Block=None, *args, **kw_args): + """Initialises a new 'BlockConnection' instance. @param MetaBlockConnection: @param MemberOf_BlockConnectivity: @@ -36,7 +36,14 @@ class BlockConnection(IdentifiedObject): self._Block = None self.Block = Block - super(BlockConnection, self).__init__(**kw_args) + super(BlockConnection, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConnection", "MemberOf_BlockConnectivity", "Block"] + _many_refs = [] def getMetaBlockConnection(self): diff --git a/schemata/CIM14/Dynamics/BlockConnectivity.py b/schemata/CIM14/Dynamics/BlockConnectivity.py index 0b64e23..bc58291 100644 --- a/schemata/CIM14/Dynamics/BlockConnectivity.py +++ b/schemata/CIM14/Dynamics/BlockConnectivity.py @@ -20,8 +20,8 @@ class BlockConnectivity(IdentifiedObject): """A instance definition of connectivity of BlockUsage objects as defined in a a BlockConnection within the dyanmics-meta-model. """ - def __init__(self, MetaBlockConnectivity=None, Block=None, BlockConnection=None, **kw_args): - """Initializes a new 'BlockConnectivity' instance. + def __init__(self, MetaBlockConnectivity=None, Block=None, BlockConnection=None, *args, **kw_args): + """Initialises a new 'BlockConnectivity' instance. @param MetaBlockConnectivity: @param Block: @@ -36,7 +36,14 @@ class BlockConnectivity(IdentifiedObject): self._BlockConnection = [] self.BlockConnection = [] if BlockConnection is None else BlockConnection - super(BlockConnectivity, self).__init__(**kw_args) + super(BlockConnectivity, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConnectivity", "Block", "BlockConnection"] + _many_refs = ["Block", "BlockConnection"] def getMetaBlockConnectivity(self): diff --git a/schemata/CIM14/Dynamics/BlockConstant.py b/schemata/CIM14/Dynamics/BlockConstant.py index b1f0612..92c54ab 100644 --- a/schemata/CIM14/Dynamics/BlockConstant.py +++ b/schemata/CIM14/Dynamics/BlockConstant.py @@ -20,8 +20,8 @@ class BlockConstant(MetaBlockConnectable): """Used as a constant in the internal definition of a block. This is meta dynamics model, so you need not specify this paramter in each usage of the block as a normal instance parameter. """ - def __init__(self, value=0.0, metaBlock0=None, **kw_args): - """Initializes a new 'BlockConstant' instance. + def __init__(self, value=0.0, metaBlock0=None, *args, **kw_args): + """Initialises a new 'BlockConstant' instance. @param value: The constant value of used for the internal defintion of a block. @param metaBlock0: @@ -32,7 +32,14 @@ class BlockConstant(MetaBlockConnectable): self._metaBlock0 = None self.metaBlock0 = metaBlock0 - super(BlockConstant, self).__init__(**kw_args) + super(BlockConstant, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["metaBlock0"] + _many_refs = [] def getmetaBlock0(self): diff --git a/schemata/CIM14/Dynamics/BlockInputReference.py b/schemata/CIM14/Dynamics/BlockInputReference.py index 76198cf..423bb39 100644 --- a/schemata/CIM14/Dynamics/BlockInputReference.py +++ b/schemata/CIM14/Dynamics/BlockInputReference.py @@ -20,8 +20,8 @@ class BlockInputReference(IdentifiedObject): """Used at the meta dynamics level. This is how the internal definiton of a block references the input of another block. """ - def __init__(self, metaBlockReference0=None, metaBlockInput0=None, BlockConnectable=None, **kw_args): - """Initializes a new 'BlockInputReference' instance. + def __init__(self, metaBlockReference0=None, metaBlockInput0=None, BlockConnectable=None, *args, **kw_args): + """Initialises a new 'BlockInputReference' instance. @param metaBlockReference0: @param metaBlockInput0: References the idenfiied input for the block reference. @@ -36,7 +36,14 @@ class BlockInputReference(IdentifiedObject): self._BlockConnectable = None self.BlockConnectable = BlockConnectable - super(BlockInputReference, self).__init__(**kw_args) + super(BlockInputReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["metaBlockReference0", "metaBlockInput0", "BlockConnectable"] + _many_refs = [] def getmetaBlockReference0(self): diff --git a/schemata/CIM14/Dynamics/BlockInputType.py b/schemata/CIM14/Dynamics/BlockInputType.py index 8c7f6ef..799a0b7 100644 --- a/schemata/CIM14/Dynamics/BlockInputType.py +++ b/schemata/CIM14/Dynamics/BlockInputType.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class BlockInputType(IdentifiedObject): - def __init__(self, slotInput0=None, metaBlockInput0=None, **kw_args): - """Initializes a new 'BlockInputType' instance. + def __init__(self, slotInput0=None, metaBlockInput0=None, *args, **kw_args): + """Initialises a new 'BlockInputType' instance. @param slotInput0: @param metaBlockInput0: @@ -30,7 +30,14 @@ class BlockInputType(IdentifiedObject): self._metaBlockInput0 = [] self.metaBlockInput0 = [] if metaBlockInput0 is None else metaBlockInput0 - super(BlockInputType, self).__init__(**kw_args) + super(BlockInputType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slotInput0", "metaBlockInput0"] + _many_refs = ["slotInput0", "metaBlockInput0"] def getslotInput0(self): diff --git a/schemata/CIM14/Dynamics/BlockOutputReference.py b/schemata/CIM14/Dynamics/BlockOutputReference.py index 5023059..8df2993 100644 --- a/schemata/CIM14/Dynamics/BlockOutputReference.py +++ b/schemata/CIM14/Dynamics/BlockOutputReference.py @@ -20,8 +20,8 @@ class BlockOutputReference(MetaBlockConnectable): """References output from another block at the meta dynamics level. The other block must be a BlockReference in containing block. """ - def __init__(self, metaBlockOutput0=None, metaBlockReference0=None, **kw_args): - """Initializes a new 'BlockOutputReference' instance. + def __init__(self, metaBlockOutput0=None, metaBlockReference0=None, *args, **kw_args): + """Initialises a new 'BlockOutputReference' instance. @param metaBlockOutput0: @param metaBlockReference0: @@ -32,7 +32,14 @@ class BlockOutputReference(MetaBlockConnectable): self._metaBlockReference0 = [] self.metaBlockReference0 = [] if metaBlockReference0 is None else metaBlockReference0 - super(BlockOutputReference, self).__init__(**kw_args) + super(BlockOutputReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["metaBlockOutput0", "metaBlockReference0"] + _many_refs = ["metaBlockReference0"] def getmetaBlockOutput0(self): diff --git a/schemata/CIM14/Dynamics/BlockOutputType.py b/schemata/CIM14/Dynamics/BlockOutputType.py index 9b01893..79289bf 100644 --- a/schemata/CIM14/Dynamics/BlockOutputType.py +++ b/schemata/CIM14/Dynamics/BlockOutputType.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class BlockOutputType(IdentifiedObject): - def __init__(self, metaBlockOutput0=None, slotOutput0=None, **kw_args): - """Initializes a new 'BlockOutputType' instance. + def __init__(self, metaBlockOutput0=None, slotOutput0=None, *args, **kw_args): + """Initialises a new 'BlockOutputType' instance. @param metaBlockOutput0: @param slotOutput0: @@ -30,7 +30,14 @@ class BlockOutputType(IdentifiedObject): self._slotOutput0 = [] self.slotOutput0 = [] if slotOutput0 is None else slotOutput0 - super(BlockOutputType, self).__init__(**kw_args) + super(BlockOutputType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["metaBlockOutput0", "slotOutput0"] + _many_refs = ["metaBlockOutput0", "slotOutput0"] def getmetaBlockOutput0(self): diff --git a/schemata/CIM14/Dynamics/BlockParameter.py b/schemata/CIM14/Dynamics/BlockParameter.py index 9c4d349..5cc4e68 100644 --- a/schemata/CIM14/Dynamics/BlockParameter.py +++ b/schemata/CIM14/Dynamics/BlockParameter.py @@ -20,8 +20,8 @@ class BlockParameter(IdentifiedObject): """Specification of a paramter for use in a dynamic block. This is a paramters like a time constant that could be unique for each instance of, for example, an exciter in the model. """ - def __init__(self, value=0.0, MetaBlockParameter=None, MemberOf_MetaBlockReference=None, UserBlockParameter=None, MemberOf_Block=None, **kw_args): - """Initializes a new 'BlockParameter' instance. + def __init__(self, value=0.0, MetaBlockParameter=None, MemberOf_MetaBlockReference=None, UserBlockParameter=None, MemberOf_Block=None, *args, **kw_args): + """Initialises a new 'BlockParameter' instance. @param value: The paramter value for this instance of a dynamic block usage. @param MetaBlockParameter: @@ -44,7 +44,14 @@ class BlockParameter(IdentifiedObject): self._MemberOf_Block = None self.MemberOf_Block = MemberOf_Block - super(BlockParameter, self).__init__(**kw_args) + super(BlockParameter, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["MetaBlockParameter", "MemberOf_MetaBlockReference", "UserBlockParameter", "MemberOf_Block"] + _many_refs = [] def getMetaBlockParameter(self): diff --git a/schemata/CIM14/Dynamics/BlockType.py b/schemata/CIM14/Dynamics/BlockType.py index a2a9bbd..7cbbad4 100644 --- a/schemata/CIM14/Dynamics/BlockType.py +++ b/schemata/CIM14/Dynamics/BlockType.py @@ -20,8 +20,8 @@ class BlockType(IdentifiedObject): """This is the kind of a block used to specify what kind of blocks could fit into a particular slot. For example, only blocks of type 'pss' would fit into a 'pss' type block. Though a cross compound generator configuration would possibly have multple pss blocks playing specific roles such as pss1 and pss2.. """ - def __init__(self, slot0=None, metaBlock0=None, **kw_args): - """Initializes a new 'BlockType' instance. + def __init__(self, slot0=None, metaBlock0=None, *args, **kw_args): + """Initialises a new 'BlockType' instance. @param slot0: @param metaBlock0: @@ -32,7 +32,14 @@ class BlockType(IdentifiedObject): self._metaBlock0 = [] self.metaBlock0 = [] if metaBlock0 is None else metaBlock0 - super(BlockType, self).__init__(**kw_args) + super(BlockType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slot0", "metaBlock0"] + _many_refs = ["slot0", "metaBlock0"] def getslot0(self): diff --git a/schemata/CIM14/Dynamics/BlockUsageInputReference.py b/schemata/CIM14/Dynamics/BlockUsageInputReference.py index 1652b1c..5210193 100644 --- a/schemata/CIM14/Dynamics/BlockUsageInputReference.py +++ b/schemata/CIM14/Dynamics/BlockUsageInputReference.py @@ -20,8 +20,8 @@ class BlockUsageInputReference(IdentifiedObject): """Used at instance level to tie the input of a referenced block to the output of another referenced block. Note that typically an input is only tied to an output of another block at the same PowerSystemResource, but there is no restriction to do so. """ - def __init__(self, block0=None, BlockUsageOutputReference=None, metaBlockInput0=None, **kw_args): - """Initializes a new 'BlockUsageInputReference' instance. + def __init__(self, block0=None, BlockUsageOutputReference=None, metaBlockInput0=None, *args, **kw_args): + """Initialises a new 'BlockUsageInputReference' instance. @param block0: @param BlockUsageOutputReference: Can cross BlockUsage objects. @@ -36,7 +36,14 @@ class BlockUsageInputReference(IdentifiedObject): self._metaBlockInput0 = None self.metaBlockInput0 = metaBlockInput0 - super(BlockUsageInputReference, self).__init__(**kw_args) + super(BlockUsageInputReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["block0", "BlockUsageOutputReference", "metaBlockInput0"] + _many_refs = [] def getblock0(self): diff --git a/schemata/CIM14/Dynamics/BlockUsageOutputReference.py b/schemata/CIM14/Dynamics/BlockUsageOutputReference.py index 4050e5a..9b5b508 100644 --- a/schemata/CIM14/Dynamics/BlockUsageOutputReference.py +++ b/schemata/CIM14/Dynamics/BlockUsageOutputReference.py @@ -20,8 +20,8 @@ class BlockUsageOutputReference(IdentifiedObject): """Used at instance level to tie the input of a referenced block to the output of another referenced block. Note that typically an input is only tied to an output of another block at the same PowerSystemResource, but there is no restriction to do so. If the output is implicity tied to an input, then the an instance of this class is not required. The sole purpose of this class is to explicitly tio the input of other blocks at the power system instance level. """ - def __init__(self, block0=None, BlockUsageInputReference=None, metaBlockOutput0=None, **kw_args): - """Initializes a new 'BlockUsageOutputReference' instance. + def __init__(self, block0=None, BlockUsageInputReference=None, metaBlockOutput0=None, *args, **kw_args): + """Initialises a new 'BlockUsageOutputReference' instance. @param block0: @param BlockUsageInputReference: Can cross BlockUsage objects. @@ -36,7 +36,14 @@ class BlockUsageOutputReference(IdentifiedObject): self._metaBlockOutput0 = None self.metaBlockOutput0 = metaBlockOutput0 - super(BlockUsageOutputReference, self).__init__(**kw_args) + super(BlockUsageOutputReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["block0", "BlockUsageInputReference", "metaBlockOutput0"] + _many_refs = ["BlockUsageInputReference"] def getblock0(self): diff --git a/schemata/CIM14/Dynamics/CompositeModel.py b/schemata/CIM14/Dynamics/CompositeModel.py index 149b92b..aa69304 100644 --- a/schemata/CIM14/Dynamics/CompositeModel.py +++ b/schemata/CIM14/Dynamics/CompositeModel.py @@ -18,15 +18,22 @@ from CIM14.Element import Element class CompositeModel(Element): - def __init__(self, slotReference0=None, **kw_args): - """Initializes a new 'CompositeModel' instance. + def __init__(self, slotReference0=None, *args, **kw_args): + """Initialises a new 'CompositeModel' instance. @param slotReference0: """ self._slotReference0 = [] self.slotReference0 = [] if slotReference0 is None else slotReference0 - super(CompositeModel, self).__init__(**kw_args) + super(CompositeModel, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slotReference0"] + _many_refs = ["slotReference0"] def getslotReference0(self): diff --git a/schemata/CIM14/Dynamics/ConnectionFrame.py b/schemata/CIM14/Dynamics/ConnectionFrame.py index c50b503..8325cc1 100644 --- a/schemata/CIM14/Dynamics/ConnectionFrame.py +++ b/schemata/CIM14/Dynamics/ConnectionFrame.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class ConnectionFrame(IdentifiedObject): - def __init__(self, slotConnection0=None, slot0=None, **kw_args): - """Initializes a new 'ConnectionFrame' instance. + def __init__(self, slotConnection0=None, slot0=None, *args, **kw_args): + """Initialises a new 'ConnectionFrame' instance. @param slotConnection0: @param slot0: @@ -30,7 +30,14 @@ class ConnectionFrame(IdentifiedObject): self._slot0 = [] self.slot0 = [] if slot0 is None else slot0 - super(ConnectionFrame, self).__init__(**kw_args) + super(ConnectionFrame, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slotConnection0", "slot0"] + _many_refs = ["slotConnection0", "slot0"] def getslotConnection0(self): diff --git a/schemata/CIM14/Dynamics/ExcitationSystemLimiter.py b/schemata/CIM14/Dynamics/ExcitationSystemLimiter.py index e0d16db..cbdc756 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystemLimiter.py +++ b/schemata/CIM14/Dynamics/ExcitationSystemLimiter.py @@ -18,9 +18,16 @@ from CIM14.Element import Element class ExcitationSystemLimiter(Element): - def __init__(self, **kw_args): - """Initializes a new 'ExcitationSystemLimiter' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcitationSystemLimiter' instance. """ - super(ExcitationSystemLimiter, self).__init__(**kw_args) + super(ExcitationSystemLimiter, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC1A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC1A.py index 86ceb00..0fcaaa3 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC1A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC1A.py @@ -20,8 +20,8 @@ class ExcAC1A(ExcitationSystem): """IEEE (1992/2005) AC1A Model The model represents the field-controlled alternator-rectifier excitation systems designated Type AC1A. These excitation systems consist of an alternator main exciter with non-controlled rectifiers. """ - def __init__(self, vrmin=0.0, tr=0.0, vrmax=0.0, ta=0.0, kf=0.0, te=0.0, ka=0.0, vamax=0.0, tb=0.0, e1=0.0, kd=0.0, se1=0.0, vamin=0.0, ke=0.0, kc=0.0, tf=0.0, tc=0.0, e2=0.0, se2=0.0, **kw_args): - """Initializes a new 'ExcAC1A' instance. + def __init__(self, vrmin=0.0, tr=0.0, vrmax=0.0, ta=0.0, kf=0.0, te=0.0, ka=0.0, vamax=0.0, tb=0.0, e1=0.0, kd=0.0, se1=0.0, vamin=0.0, ke=0.0, kc=0.0, tf=0.0, tc=0.0, e2=0.0, se2=0.0, *args, **kw_args): + """Initialises a new 'ExcAC1A' instance. @param vrmin: Minimum exciter control signal (< 0.) @param tr: Filter time constant (>= 0.) @@ -100,5 +100,12 @@ class ExcAC1A(ExcitationSystem): #: Saturation factor at e2 (>= 0.) self.se2 = se2 - super(ExcAC1A, self).__init__(**kw_args) + super(ExcAC1A, self).__init__(*args, **kw_args) + + _attrs = ["vrmin", "tr", "vrmax", "ta", "kf", "te", "ka", "vamax", "tb", "e1", "kd", "se1", "vamin", "ke", "kc", "tf", "tc", "e2", "se2"] + _attr_types = {"vrmin": float, "tr": float, "vrmax": float, "ta": float, "kf": float, "te": float, "ka": float, "vamax": float, "tb": float, "e1": float, "kd": float, "se1": float, "vamin": float, "ke": float, "kc": float, "tf": float, "tc": float, "e2": float, "se2": float} + _defaults = {"vrmin": 0.0, "tr": 0.0, "vrmax": 0.0, "ta": 0.0, "kf": 0.0, "te": 0.0, "ka": 0.0, "vamax": 0.0, "tb": 0.0, "e1": 0.0, "kd": 0.0, "se1": 0.0, "vamin": 0.0, "ke": 0.0, "kc": 0.0, "tf": 0.0, "tc": 0.0, "e2": 0.0, "se2": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC2A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC2A.py index dcccebd..ee5d5a6 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC2A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC2A.py @@ -20,8 +20,8 @@ class ExcAC2A(ExcitationSystem): """IEEE (1992/2005) AC2A Model The model designated as Type AC2A, represents a high initial response fieldcontrolled alternator-rectifier excitation system. The alternator main exciter is used with non-controlled rectifiers. The Type AC2A model is similar to that of Type AC1A except for the inclusion of exciter time constant compensation and exciter field current limiting elements. """ - def __init__(self, vrmin=0.0, vamin=0.0, kh=0.0, vrmax=0.0, tb=0.0, e1=0.0, se1=0.0, te=0.0, kf=0.0, tc=0.0, e2=0.0, ke=0.0, tr=0.0, tf=0.0, ta=0.0, kc=0.0, kd=0.0, se2=0.0, vfemax=0.0, vamax=0.0, kb=0.0, ka=0.0, **kw_args): - """Initializes a new 'ExcAC2A' instance. + def __init__(self, vrmin=0.0, vamin=0.0, kh=0.0, vrmax=0.0, tb=0.0, e1=0.0, se1=0.0, te=0.0, kf=0.0, tc=0.0, e2=0.0, ke=0.0, tr=0.0, tf=0.0, ta=0.0, kc=0.0, kd=0.0, se2=0.0, vfemax=0.0, vamax=0.0, kb=0.0, ka=0.0, *args, **kw_args): + """Initialises a new 'ExcAC2A' instance. @param vrmin: Minimum exciter control signal (< 0.) @param vamin: Minimum AVR output (< 0.) @@ -112,5 +112,12 @@ class ExcAC2A(ExcitationSystem): #: AVR gain (> 0.) self.ka = ka - super(ExcAC2A, self).__init__(**kw_args) + super(ExcAC2A, self).__init__(*args, **kw_args) + + _attrs = ["vrmin", "vamin", "kh", "vrmax", "tb", "e1", "se1", "te", "kf", "tc", "e2", "ke", "tr", "tf", "ta", "kc", "kd", "se2", "vfemax", "vamax", "kb", "ka"] + _attr_types = {"vrmin": float, "vamin": float, "kh": float, "vrmax": float, "tb": float, "e1": float, "se1": float, "te": float, "kf": float, "tc": float, "e2": float, "ke": float, "tr": float, "tf": float, "ta": float, "kc": float, "kd": float, "se2": float, "vfemax": float, "vamax": float, "kb": float, "ka": float} + _defaults = {"vrmin": 0.0, "vamin": 0.0, "kh": 0.0, "vrmax": 0.0, "tb": 0.0, "e1": 0.0, "se1": 0.0, "te": 0.0, "kf": 0.0, "tc": 0.0, "e2": 0.0, "ke": 0.0, "tr": 0.0, "tf": 0.0, "ta": 0.0, "kc": 0.0, "kd": 0.0, "se2": 0.0, "vfemax": 0.0, "vamax": 0.0, "kb": 0.0, "ka": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC3A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC3A.py index 4740d1b..626c47a 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC3A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC3A.py @@ -20,8 +20,8 @@ class ExcAC3A(ExcitationSystem): """IEEE (1992/2005) AC3A Model The model represents the field-controlled alternator-rectifier excitation systems designated Type AC3A. These excitation systems include an alternator main exciter with non-controlled rectifiers. The exciter employs self-excitation, and the voltage regulator power is derived from the exciter output voltage. Therefore, this system has an additional nonlinearity, simulated by the use of a multiplier whose inputs are the voltage regulator command signal, VA, and the exciter output voltage, EFD, times KR. This model is applicable to excitation systems employing static voltage regulators. """ - def __init__(self, kf=0.0, e2=0.0, te=0.0, ka=0.0, kr=0.0, tc=0.0, efdn=0.0, ke=0.0, e1=0.0, kd=0.0, se2=0.0, vamax=0.0, tr=0.0, vamin=0.0, tf=0.0, vemin=0.0, kn=0.0, vfemax=0.0, tb=0.0, se1=0.0, kc=0.0, ta=0.0, **kw_args): - """Initializes a new 'ExcAC3A' instance. + def __init__(self, kf=0.0, e2=0.0, te=0.0, ka=0.0, kr=0.0, tc=0.0, efdn=0.0, ke=0.0, e1=0.0, kd=0.0, se2=0.0, vamax=0.0, tr=0.0, vamin=0.0, tf=0.0, vemin=0.0, kn=0.0, vfemax=0.0, tb=0.0, se1=0.0, kc=0.0, ta=0.0, *args, **kw_args): + """Initialises a new 'ExcAC3A' instance. @param kf: Low level rate feedback gain (>= 0.) @param e2: Field voltage value 2. (> 0.) @@ -112,5 +112,12 @@ class ExcAC3A(ExcitationSystem): #: AVR time constant (> 0.) self.ta = ta - super(ExcAC3A, self).__init__(**kw_args) + super(ExcAC3A, self).__init__(*args, **kw_args) + + _attrs = ["kf", "e2", "te", "ka", "kr", "tc", "efdn", "ke", "e1", "kd", "se2", "vamax", "tr", "vamin", "tf", "vemin", "kn", "vfemax", "tb", "se1", "kc", "ta"] + _attr_types = {"kf": float, "e2": float, "te": float, "ka": float, "kr": float, "tc": float, "efdn": float, "ke": float, "e1": float, "kd": float, "se2": float, "vamax": float, "tr": float, "vamin": float, "tf": float, "vemin": float, "kn": float, "vfemax": float, "tb": float, "se1": float, "kc": float, "ta": float} + _defaults = {"kf": 0.0, "e2": 0.0, "te": 0.0, "ka": 0.0, "kr": 0.0, "tc": 0.0, "efdn": 0.0, "ke": 0.0, "e1": 0.0, "kd": 0.0, "se2": 0.0, "vamax": 0.0, "tr": 0.0, "vamin": 0.0, "tf": 0.0, "vemin": 0.0, "kn": 0.0, "vfemax": 0.0, "tb": 0.0, "se1": 0.0, "kc": 0.0, "ta": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC4A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC4A.py index 0108870..c0c2cc4 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC4A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC4A.py @@ -20,8 +20,8 @@ class ExcAC4A(ExcitationSystem): """IEEE (1992/2005) AC4A Model The Type AC4A alternator-supplied controlled-rectifier excitation system is quite different from the other type ac systems. This high initial response excitation system utilizes a full thyristor bridge in the exciter output circuit. The voltage regulator controls the firing of the thyristor bridges. The exciter alternator uses an independent voltage regulator to control its output voltage to a constant value. These effects are not modeled; however, transient loading effects on the exciter alternator are included. """ - def __init__(self, ka=0.0, vimin=0.0, tb=0.0, tr=0.0, tc=0.0, ta=0.0, kc=0.0, vrmin=0.0, vrmax=0.0, vimax=0.0, **kw_args): - """Initializes a new 'ExcAC4A' instance. + def __init__(self, ka=0.0, vimin=0.0, tb=0.0, tr=0.0, tc=0.0, ta=0.0, kc=0.0, vrmin=0.0, vrmax=0.0, vimax=0.0, *args, **kw_args): + """Initialises a new 'ExcAC4A' instance. @param ka: Gain (> 0.) @param vimin: Minimum error signal (< 0.) @@ -64,5 +64,12 @@ class ExcAC4A(ExcitationSystem): #: Maximum error signal ( > 0.) self.vimax = vimax - super(ExcAC4A, self).__init__(**kw_args) + super(ExcAC4A, self).__init__(*args, **kw_args) + + _attrs = ["ka", "vimin", "tb", "tr", "tc", "ta", "kc", "vrmin", "vrmax", "vimax"] + _attr_types = {"ka": float, "vimin": float, "tb": float, "tr": float, "tc": float, "ta": float, "kc": float, "vrmin": float, "vrmax": float, "vimax": float} + _defaults = {"ka": 0.0, "vimin": 0.0, "tb": 0.0, "tr": 0.0, "tc": 0.0, "ta": 0.0, "kc": 0.0, "vrmin": 0.0, "vrmax": 0.0, "vimax": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC5A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC5A.py index 8e33d77..6fc5f06 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC5A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC5A.py @@ -20,8 +20,8 @@ class ExcAC5A(ExcitationSystem): """IEEE (1992/2005) AC5A Model The model designated as Type AC5A, is a simplified model for brushless excitation systems. The regulator is supplied from a source, such as a permanent magnet generator, which is not affected by system disturbances. Unlike other ac models, this model uses loaded rather than open circuit exciter saturation data in the same way as it is used for the dc models. Because the model has been widely implemented by the industry, it is sometimes used to represent other types of systems when either detailed data for them are not available or simplified models are required. """ - def __init__(self, ka=0.0, e1=0.0, kf=0.0, te=0.0, vrmin=0.0, vrmax=0.0, se2=0.0, tf3=0.0, e2=0.0, ke=0.0, tr=0.0, se1=0.0, tf2=0.0, tf1=0.0, ta=0.0, **kw_args): - """Initializes a new 'ExcAC5A' instance. + def __init__(self, ka=0.0, e1=0.0, kf=0.0, te=0.0, vrmin=0.0, vrmax=0.0, se2=0.0, tf3=0.0, e2=0.0, ke=0.0, tr=0.0, se1=0.0, tf2=0.0, tf1=0.0, ta=0.0, *args, **kw_args): + """Initialises a new 'ExcAC5A' instance. @param ka: Gain (> 0.) @param e1: Field voltage value 1 (> 0.) @@ -84,5 +84,12 @@ class ExcAC5A(ExcitationSystem): #: Time constant (> 0.) self.ta = ta - super(ExcAC5A, self).__init__(**kw_args) + super(ExcAC5A, self).__init__(*args, **kw_args) + + _attrs = ["ka", "e1", "kf", "te", "vrmin", "vrmax", "se2", "tf3", "e2", "ke", "tr", "se1", "tf2", "tf1", "ta"] + _attr_types = {"ka": float, "e1": float, "kf": float, "te": float, "vrmin": float, "vrmax": float, "se2": float, "tf3": float, "e2": float, "ke": float, "tr": float, "se1": float, "tf2": float, "tf1": float, "ta": float} + _defaults = {"ka": 0.0, "e1": 0.0, "kf": 0.0, "te": 0.0, "vrmin": 0.0, "vrmax": 0.0, "se2": 0.0, "tf3": 0.0, "e2": 0.0, "ke": 0.0, "tr": 0.0, "se1": 0.0, "tf2": 0.0, "tf1": 0.0, "ta": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC6A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC6A.py index d2085c1..aec1a07 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC6A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC6A.py @@ -20,8 +20,8 @@ class ExcAC6A(ExcitationSystem): """IEEE (1992/2005) AC6A Model The model is used to represent field-controlled alternator-rectifier excitation systems with system-supplied electronic voltage regulators. The maximum output of the regulator, VR, is a function of terminal voltage, VT. The field current limiter included in the original model AC6A remains in the 2005 update. """ - def __init__(self, te=0.0, ka=0.0, vhmax=0.0, kh=0.0, tk=0.0, ke=0.0, se1=0.0, tr=0.0, vrmin=0.0, vrmax=0.0, tc=0.0, e2=0.0, tj=0.0, kc=0.0, vfelim=0.0, ta=0.0, th=0.0, kd=0.0, vamax=0.0, tb=0.0, e1=0.0, vamin=0.0, se2=0.0, **kw_args): - """Initializes a new 'ExcAC6A' instance. + def __init__(self, te=0.0, ka=0.0, vhmax=0.0, kh=0.0, tk=0.0, ke=0.0, se1=0.0, tr=0.0, vrmin=0.0, vrmax=0.0, tc=0.0, e2=0.0, tj=0.0, kc=0.0, vfelim=0.0, ta=0.0, th=0.0, kd=0.0, vamax=0.0, tb=0.0, e1=0.0, vamin=0.0, se2=0.0, *args, **kw_args): + """Initialises a new 'ExcAC6A' instance. @param te: Exciter time constant (> 0.) @param ka: Gain (> 0.) @@ -116,5 +116,12 @@ class ExcAC6A(ExcitationSystem): #: Saturation factor at e2 (>= 0.) self.se2 = se2 - super(ExcAC6A, self).__init__(**kw_args) + super(ExcAC6A, self).__init__(*args, **kw_args) + + _attrs = ["te", "ka", "vhmax", "kh", "tk", "ke", "se1", "tr", "vrmin", "vrmax", "tc", "e2", "tj", "kc", "vfelim", "ta", "th", "kd", "vamax", "tb", "e1", "vamin", "se2"] + _attr_types = {"te": float, "ka": float, "vhmax": float, "kh": float, "tk": float, "ke": float, "se1": float, "tr": float, "vrmin": float, "vrmax": float, "tc": float, "e2": float, "tj": float, "kc": float, "vfelim": float, "ta": float, "th": float, "kd": float, "vamax": float, "tb": float, "e1": float, "vamin": float, "se2": float} + _defaults = {"te": 0.0, "ka": 0.0, "vhmax": 0.0, "kh": 0.0, "tk": 0.0, "ke": 0.0, "se1": 0.0, "tr": 0.0, "vrmin": 0.0, "vrmax": 0.0, "tc": 0.0, "e2": 0.0, "tj": 0.0, "kc": 0.0, "vfelim": 0.0, "ta": 0.0, "th": 0.0, "kd": 0.0, "vamax": 0.0, "tb": 0.0, "e1": 0.0, "vamin": 0.0, "se2": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC7B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC7B.py index f21b9fe..d7df55c 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC7B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC7B.py @@ -20,8 +20,8 @@ class ExcAC7B(ExcitationSystem): """IEEE (2005) AC7B Model These excitation systems consist of an ac alternator with either stationary or rotating rectifiers to produce the dc field requirements. Upgrades to earlier ac excitation systems, which replace only the controls but retain the ac alternator and diode rectifier bridge, have resulted in this new model. Some of the features of this excitation system include a high bandwidth inner loop regulating generator field voltage or exciter current (KF2, KF1), a fast exciter current limit, VFEMAX, to protect the field of the ac alternator, and the PID generator voltage regulator (AVR). An alternative rate feedback loop (KF, TF) is provided for stabilization if the AVR does not include a derivative term. If a PSS control is supplied, the Type PSS2B or PSS3B models are appropriate. """ - def __init__(self, kir=0.0, kpr=0.0, vfemax=0.0, te=0.0, vemin=0.0, ke=0.0, kp=0.0, kd=0.0, kdr=0.0, kf3=0.0, e1=0.0, tdr=0.0, se2=0.0, kf1=0.0, e2=0.0, kc=0.0, vamin=0.0, se1=0.0, vrmin=0.0, tf=0.0, vrmax=0.0, kf2=0.0, kl=0.0, kpa=0.0, kia=0.0, tr=0.0, vamax=0.0, **kw_args): - """Initializes a new 'ExcAC7B' instance. + def __init__(self, kir=0.0, kpr=0.0, vfemax=0.0, te=0.0, vemin=0.0, ke=0.0, kp=0.0, kd=0.0, kdr=0.0, kf3=0.0, e1=0.0, tdr=0.0, se2=0.0, kf1=0.0, e2=0.0, kc=0.0, vamin=0.0, se1=0.0, vrmin=0.0, tf=0.0, vrmax=0.0, kf2=0.0, kl=0.0, kpa=0.0, kia=0.0, tr=0.0, vamax=0.0, *args, **kw_args): + """Initialises a new 'ExcAC7B' instance. @param kir: Regulator integral gain (>= 0.) @param kpr: Regulator proportional gain (> 0. if kir = 0.) @@ -132,5 +132,12 @@ class ExcAC7B(ExcitationSystem): #: Maximum amplifier output (> 0.) self.vamax = vamax - super(ExcAC7B, self).__init__(**kw_args) + super(ExcAC7B, self).__init__(*args, **kw_args) + + _attrs = ["kir", "kpr", "vfemax", "te", "vemin", "ke", "kp", "kd", "kdr", "kf3", "e1", "tdr", "se2", "kf1", "e2", "kc", "vamin", "se1", "vrmin", "tf", "vrmax", "kf2", "kl", "kpa", "kia", "tr", "vamax"] + _attr_types = {"kir": float, "kpr": float, "vfemax": float, "te": float, "vemin": float, "ke": float, "kp": float, "kd": float, "kdr": float, "kf3": float, "e1": float, "tdr": float, "se2": float, "kf1": float, "e2": float, "kc": float, "vamin": float, "se1": float, "vrmin": float, "tf": float, "vrmax": float, "kf2": float, "kl": float, "kpa": float, "kia": float, "tr": float, "vamax": float} + _defaults = {"kir": 0.0, "kpr": 0.0, "vfemax": 0.0, "te": 0.0, "vemin": 0.0, "ke": 0.0, "kp": 0.0, "kd": 0.0, "kdr": 0.0, "kf3": 0.0, "e1": 0.0, "tdr": 0.0, "se2": 0.0, "kf1": 0.0, "e2": 0.0, "kc": 0.0, "vamin": 0.0, "se1": 0.0, "vrmin": 0.0, "tf": 0.0, "vrmax": 0.0, "kf2": 0.0, "kl": 0.0, "kpa": 0.0, "kia": 0.0, "tr": 0.0, "vamax": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC8B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC8B.py index 2fe8dad..39077d2 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC8B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcAC8B.py @@ -20,8 +20,8 @@ class ExcAC8B(ExcitationSystem): """IEEE (2005) AC8B Model The AVR in this model consists of PID control, with separate constants for the proportional (KPR), integral (KIR), and derivative (KDR) gains. The representation of the brushless exciter (TE, KE, SE, KC, KD) is similar to the model Type AC2A. The Type AC8B model can be used to represent static voltage regulators applied to brushless excitation systems. Digitally based voltage regulators feeding dc rotating main exciters can be represented with the AC Type AC8B model with the parameters KC and KD set to 0. For thyristor power stages fed from the generator terminals, the limits VRMAX and VRMIN should be a function of terminal voltage: VT x VRMAX and VT x VRMIN. """ - def __init__(self, vfemax=0.0, vrmin=0.0, ta=0.0, tdr=0.0, vtmult=0.0, ka=0.0, kdr=0.0, se1=0.0, e1=0.0, vemin=0.0, te=0.0, ke=0.0, se2=0.0, tr=0.0, kir=0.0, kpr=0.0, vrmax=0.0, kd=0.0, e2=0.0, kc=0.0, **kw_args): - """Initializes a new 'ExcAC8B' instance. + def __init__(self, vfemax=0.0, vrmin=0.0, ta=0.0, tdr=0.0, vtmult=0.0, ka=0.0, kdr=0.0, se1=0.0, e1=0.0, vemin=0.0, te=0.0, ke=0.0, se2=0.0, tr=0.0, kir=0.0, kpr=0.0, vrmax=0.0, kd=0.0, e2=0.0, kc=0.0, *args, **kw_args): + """Initialises a new 'ExcAC8B' instance. @param vfemax: Exciter field current limit parameter @param vrmin: Minimum controller output (<= 0.) @@ -104,5 +104,12 @@ class ExcAC8B(ExcitationSystem): #: Rectifier regulation factor (>= 0.) self.kc = kc - super(ExcAC8B, self).__init__(**kw_args) + super(ExcAC8B, self).__init__(*args, **kw_args) + + _attrs = ["vfemax", "vrmin", "ta", "tdr", "vtmult", "ka", "kdr", "se1", "e1", "vemin", "te", "ke", "se2", "tr", "kir", "kpr", "vrmax", "kd", "e2", "kc"] + _attr_types = {"vfemax": float, "vrmin": float, "ta": float, "tdr": float, "vtmult": float, "ka": float, "kdr": float, "se1": float, "e1": float, "vemin": float, "te": float, "ke": float, "se2": float, "tr": float, "kir": float, "kpr": float, "vrmax": float, "kd": float, "e2": float, "kc": float} + _defaults = {"vfemax": 0.0, "vrmin": 0.0, "ta": 0.0, "tdr": 0.0, "vtmult": 0.0, "ka": 0.0, "kdr": 0.0, "se1": 0.0, "e1": 0.0, "vemin": 0.0, "te": 0.0, "ke": 0.0, "se2": 0.0, "tr": 0.0, "kir": 0.0, "kpr": 0.0, "vrmax": 0.0, "kd": 0.0, "e2": 0.0, "kc": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcBAS.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcBAS.py index a86bcd0..e8c20cd 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcBAS.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcBAS.py @@ -20,9 +20,16 @@ class ExcBAS(ExcitationSystem): """Basler static voltage regulator feeding dc or ac rotating exciter model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcBAS' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcBAS' instance. """ - super(ExcBAS, self).__init__(**kw_args) + super(ExcBAS, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcBBC.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcBBC.py index 151915f..2a1ebab 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcBBC.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcBBC.py @@ -20,9 +20,16 @@ class ExcBBC(ExcitationSystem): """Static Excitation System Model with ABB regulator """ - def __init__(self, **kw_args): - """Initializes a new 'ExcBBC' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcBBC' instance. """ - super(ExcBBC, self).__init__(**kw_args) + super(ExcBBC, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcCZ.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcCZ.py index e3f485e..35235bf 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcCZ.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcCZ.py @@ -20,9 +20,16 @@ class ExcCZ(ExcitationSystem): """Czech proportional/integral excitation system model. """ - def __init__(self, **kw_args): - """Initializes a new 'ExcCZ' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcCZ' instance. """ - super(ExcCZ, self).__init__(**kw_args) + super(ExcCZ, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC1A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC1A.py index 650b176..a80f241 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC1A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC1A.py @@ -20,8 +20,8 @@ class ExcDC1A(ExcitationSystem): """IEEE (1992/2005) DC1A Model This model is used to represent field-controlled dc commutator exciters with continuously acting voltage regulators (especially the direct-acting rheostatic, rotating amplifier, and magnetic amplifier types). Because this model has been widely implemented by the industry, it is sometimes used to represent other types of systems when detailed data for them are not available or when a simplified model is required. """ - def __init__(self, ta=0.0, ka=0.0, e1=0.0, tb=0.0, se2=0.0, te=0.0, exclim=0.0, e2=0.0, tr=0.0, uelin=0.0, tf=0.0, vrmax=0.0, kf=0.0, ke=0.0, se1=0.0, vrmin=0.0, tc=0.0, **kw_args): - """Initializes a new 'ExcDC1A' instance. + def __init__(self, ta=0.0, ka=0.0, e1=0.0, tb=0.0, se2=0.0, te=0.0, exclim=0.0, e2=0.0, tr=0.0, uelin=0.0, tf=0.0, vrmax=0.0, kf=0.0, ke=0.0, se1=0.0, vrmin=0.0, tc=0.0, *args, **kw_args): + """Initialises a new 'ExcDC1A' instance. @param ta: Time constant (> 0.) @param ka: Gain (> 0.) @@ -92,5 +92,12 @@ class ExcDC1A(ExcitationSystem): #: Lead time constant self.tc = tc - super(ExcDC1A, self).__init__(**kw_args) + super(ExcDC1A, self).__init__(*args, **kw_args) + + _attrs = ["ta", "ka", "e1", "tb", "se2", "te", "exclim", "e2", "tr", "uelin", "tf", "vrmax", "kf", "ke", "se1", "vrmin", "tc"] + _attr_types = {"ta": float, "ka": float, "e1": float, "tb": float, "se2": float, "te": float, "exclim": float, "e2": float, "tr": float, "uelin": float, "tf": float, "vrmax": float, "kf": float, "ke": float, "se1": float, "vrmin": float, "tc": float} + _defaults = {"ta": 0.0, "ka": 0.0, "e1": 0.0, "tb": 0.0, "se2": 0.0, "te": 0.0, "exclim": 0.0, "e2": 0.0, "tr": 0.0, "uelin": 0.0, "tf": 0.0, "vrmax": 0.0, "kf": 0.0, "ke": 0.0, "se1": 0.0, "vrmin": 0.0, "tc": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC2A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC2A.py index ab01595..746d074 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC2A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC2A.py @@ -20,8 +20,8 @@ class ExcDC2A(ExcitationSystem): """IEEE (1992/2005) DC2A Model The model is used to represent field-controlled dc commutator exciters with continuously acting voltage regulators having supplies obtained from the generator or auxiliary bus. It differs from the Type DC1A model only in the voltage regulator output limits, which are now proportional to terminal voltage VT. It is representative of solid-state replacements for various forms of older mechanical and rotating amplifier regulating equipment connected to dc commutator exciters. """ - def __init__(self, te=0.0, ke=0.0, e1=0.0, tc=0.0, se2=0.0, tb=0.0, uelin=0.0, e2=0.0, tf=0.0, kf=0.0, vrmax=0.0, se1=0.0, ta=0.0, ka=0.0, tr=0.0, exclim=0.0, vrmin=0.0, **kw_args): - """Initializes a new 'ExcDC2A' instance. + def __init__(self, te=0.0, ke=0.0, e1=0.0, tc=0.0, se2=0.0, tb=0.0, uelin=0.0, e2=0.0, tf=0.0, kf=0.0, vrmax=0.0, se1=0.0, ta=0.0, ka=0.0, tr=0.0, exclim=0.0, vrmin=0.0, *args, **kw_args): + """Initialises a new 'ExcDC2A' instance. @param te: Exciter time constant (> 0.) @param ke: Exciter field resistance line slope @@ -92,5 +92,12 @@ class ExcDC2A(ExcitationSystem): #: Minimum controller output (< 0.) self.vrmin = vrmin - super(ExcDC2A, self).__init__(**kw_args) + super(ExcDC2A, self).__init__(*args, **kw_args) + + _attrs = ["te", "ke", "e1", "tc", "se2", "tb", "uelin", "e2", "tf", "kf", "vrmax", "se1", "ta", "ka", "tr", "exclim", "vrmin"] + _attr_types = {"te": float, "ke": float, "e1": float, "tc": float, "se2": float, "tb": float, "uelin": float, "e2": float, "tf": float, "kf": float, "vrmax": float, "se1": float, "ta": float, "ka": float, "tr": float, "exclim": float, "vrmin": float} + _defaults = {"te": 0.0, "ke": 0.0, "e1": 0.0, "tc": 0.0, "se2": 0.0, "tb": 0.0, "uelin": 0.0, "e2": 0.0, "tf": 0.0, "kf": 0.0, "vrmax": 0.0, "se1": 0.0, "ta": 0.0, "ka": 0.0, "tr": 0.0, "exclim": 0.0, "vrmin": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC3A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC3A.py index 658460b..7bc58af 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC3A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC3A.py @@ -20,8 +20,8 @@ class ExcDC3A(ExcitationSystem): """IEEE (1992/2005) DC3A Model The Type DC3A model is used to represent older systems, in particular those dc commutator exciters with non-continuously acting regulators that were commonly used before the development of the continuously acting varieties. These systems respond at basically two different rates, depending upon the magnitude of voltage error. For small errors, adjustment is made periodically with a signal to a motor-operated rheostat. Larger errors cause resistors to be quickly shorted or inserted and a strong forcing signal applied to the exciter. Continuous motion of the motor-operated rheostat occurs for these larger error signals, even though it is bypassed by contactor action. """ - def __init__(self, e1=0.0, vrmax=0.0, te=0.0, ke=0.0, tr=0.0, se2=0.0, trh=0.0, vrmin=0.0, exclim=0.0, e2=0.0, kv=0.0, se1=0.0, **kw_args): - """Initializes a new 'ExcDC3A' instance. + def __init__(self, e1=0.0, vrmax=0.0, te=0.0, ke=0.0, tr=0.0, se2=0.0, trh=0.0, vrmin=0.0, exclim=0.0, e2=0.0, kv=0.0, se1=0.0, *args, **kw_args): + """Initialises a new 'ExcDC3A' instance. @param e1: Field voltage value 1 (> 0.) @param vrmax: Maximum control element output (> 0.) @@ -72,5 +72,12 @@ class ExcDC3A(ExcitationSystem): #: Saturation factor at e1 (>= 0.) self.se1 = se1 - super(ExcDC3A, self).__init__(**kw_args) + super(ExcDC3A, self).__init__(*args, **kw_args) + + _attrs = ["e1", "vrmax", "te", "ke", "tr", "se2", "trh", "vrmin", "exclim", "e2", "kv", "se1"] + _attr_types = {"e1": float, "vrmax": float, "te": float, "ke": float, "tr": float, "se2": float, "trh": float, "vrmin": float, "exclim": float, "e2": float, "kv": float, "se1": float} + _defaults = {"e1": 0.0, "vrmax": 0.0, "te": 0.0, "ke": 0.0, "tr": 0.0, "se2": 0.0, "trh": 0.0, "vrmin": 0.0, "exclim": 0.0, "e2": 0.0, "kv": 0.0, "se1": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC4B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC4B.py index d4187e0..d1e950b 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC4B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcDC4B.py @@ -20,8 +20,8 @@ class ExcDC4B(ExcitationSystem): """IEEE (2005) DC4B Model These excitation systems utilize a field-controlled dc commutator exciter with a continuously acting voltage regulator having supplies obtained from the generator or auxiliary bus. The replacement of the controls only as an upgrade (retaining the dc commutator exciter) has resulted in a new model. This excitation system typically includes a proportional, integral, and differential (PID) generator voltage regulator (AVR). An alternative rate feedback loop (kf, tf) for stabilization is also shown in the model if the AVR does not include a derivative term. If a PSS control is supplied, the appropriate model is the Type PSS2B model. """ - def __init__(self, e1=0.0, se2=0.0, tf=0.0, oelin=0.0, ki=0.0, ta=0.0, vrmax=0.0, tr=0.0, kf=0.0, vrmin=0.0, te=0.0, ka=0.0, kp=0.0, td=0.0, kd=0.0, vemin=0.0, ke=0.0, se1=0.0, e2=0.0, uelin=0.0, **kw_args): - """Initializes a new 'ExcDC4B' instance. + def __init__(self, e1=0.0, se2=0.0, tf=0.0, oelin=0.0, ki=0.0, ta=0.0, vrmax=0.0, tr=0.0, kf=0.0, vrmin=0.0, te=0.0, ka=0.0, kp=0.0, td=0.0, kd=0.0, vemin=0.0, ke=0.0, se1=0.0, e2=0.0, uelin=0.0, *args, **kw_args): + """Initialises a new 'ExcDC4B' instance. @param e1: Field voltage value 1 (> 0.) @param se2: Saturation factor at e2 (>= 0.) @@ -104,5 +104,12 @@ class ExcDC4B(ExcitationSystem): #: UEL input: if < 2, HV gate; if = 2, add to error signal self.uelin = uelin - super(ExcDC4B, self).__init__(**kw_args) + super(ExcDC4B, self).__init__(*args, **kw_args) + + _attrs = ["e1", "se2", "tf", "oelin", "ki", "ta", "vrmax", "tr", "kf", "vrmin", "te", "ka", "kp", "td", "kd", "vemin", "ke", "se1", "e2", "uelin"] + _attr_types = {"e1": float, "se2": float, "tf": float, "oelin": float, "ki": float, "ta": float, "vrmax": float, "tr": float, "kf": float, "vrmin": float, "te": float, "ka": float, "kp": float, "td": float, "kd": float, "vemin": float, "ke": float, "se1": float, "e2": float, "uelin": float} + _defaults = {"e1": 0.0, "se2": 0.0, "tf": 0.0, "oelin": 0.0, "ki": 0.0, "ta": 0.0, "vrmax": 0.0, "tr": 0.0, "kf": 0.0, "vrmin": 0.0, "te": 0.0, "ka": 0.0, "kp": 0.0, "td": 0.0, "kd": 0.0, "vemin": 0.0, "ke": 0.0, "se1": 0.0, "e2": 0.0, "uelin": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN1.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN1.py index aa89a2a..c36f95b 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN1.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN1.py @@ -20,9 +20,16 @@ class ExcELIN1(ExcitationSystem): """Simplified Excitation System Model - ELIN (VATECH) """ - def __init__(self, **kw_args): - """Initializes a new 'ExcELIN1' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcELIN1' instance. """ - super(ExcELIN1, self).__init__(**kw_args) + super(ExcELIN1, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN2.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN2.py index bdc431d..3f71731 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN2.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcELIN2.py @@ -20,9 +20,16 @@ class ExcELIN2(ExcitationSystem): """Detailed Excitation System Model - ELIN (VATECH) """ - def __init__(self, **kw_args): - """Initializes a new 'ExcELIN2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcELIN2' instance. """ - super(ExcELIN2, self).__init__(**kw_args) + super(ExcELIN2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcHU.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcHU.py index 6bba7a3..2c18eec 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcHU.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcHU.py @@ -20,9 +20,16 @@ class ExcHU(ExcitationSystem): """Hungarian Excitation System Model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcHU' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcHU' instance. """ - super(ExcHU, self).__init__(**kw_args) + super(ExcHU, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcPIC.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcPIC.py index e1d107a..9fdb7fa 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcPIC.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcPIC.py @@ -20,9 +20,16 @@ class ExcPIC(ExcitationSystem): """Excitation System Model with PI voltage regulator """ - def __init__(self, **kw_args): - """Initializes a new 'ExcPIC' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcPIC' instance. """ - super(ExcPIC, self).__init__(**kw_args) + super(ExcPIC, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcREXS.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcREXS.py index 42002cd..b68dc04 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcREXS.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcREXS.py @@ -20,9 +20,16 @@ class ExcREXS(ExcitationSystem): """General Purpose Rotating Excitation System Model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcREXS' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcREXS' instance. """ - super(ExcREXS, self).__init__(**kw_args) + super(ExcREXS, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSCRX.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSCRX.py index 956dba2..fe1604f 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSCRX.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSCRX.py @@ -20,8 +20,8 @@ class ExcSCRX(ExcitationSystem): """Simple excitation system model representing generic characteristics of many excitation systems; intended for use where negative field current may be a problem """ - def __init__(self, tb=0.0, cswitch=False, emin=0.0, k=0.0, te=0.0, emax=0.0, tatb=0.0, rcrfd=0.0, **kw_args): - """Initializes a new 'ExcSCRX' instance. + def __init__(self, tb=0.0, cswitch=False, emin=0.0, k=0.0, te=0.0, emax=0.0, tatb=0.0, rcrfd=0.0, *args, **kw_args): + """Initialises a new 'ExcSCRX' instance. @param tb: Denominator time constant of lag-lead block @param cswitch: Power source switch: 1 ? fixed voltage 0 ? generator terminal voltage @@ -56,5 +56,12 @@ class ExcSCRX(ExcitationSystem): #: Rc/Rfd - ratio of field discharge resistance to field winding resistance self.rcrfd = rcrfd - super(ExcSCRX, self).__init__(**kw_args) + super(ExcSCRX, self).__init__(*args, **kw_args) + + _attrs = ["tb", "cswitch", "emin", "k", "te", "emax", "tatb", "rcrfd"] + _attr_types = {"tb": float, "cswitch": bool, "emin": float, "k": float, "te": float, "emax": float, "tatb": float, "rcrfd": float} + _defaults = {"tb": 0.0, "cswitch": False, "emin": 0.0, "k": 0.0, "te": 0.0, "emax": 0.0, "tatb": 0.0, "rcrfd": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSEXS.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSEXS.py index c5592ab..bb1d9a6 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSEXS.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSEXS.py @@ -20,8 +20,8 @@ class ExcSEXS(ExcitationSystem): """Simplified Excitation System Model """ - def __init__(self, tb=0.0, kc=0.0, emax=0.0, tatb=0.0, tc=0.0, efdmin=0.0, efdmax=0.0, emin=0.0, k=0.0, te=0.0, **kw_args): - """Initializes a new 'ExcSEXS' instance. + def __init__(self, tb=0.0, kc=0.0, emax=0.0, tatb=0.0, tc=0.0, efdmin=0.0, efdmax=0.0, emin=0.0, k=0.0, te=0.0, *args, **kw_args): + """Initialises a new 'ExcSEXS' instance. @param tb: Denominator time constant of lag-lead block @param kc: PI controller gain (> 0. if Tc > 0.) @@ -64,5 +64,12 @@ class ExcSEXS(ExcitationSystem): #: Time constant of gain block (> 0.) self.te = te - super(ExcSEXS, self).__init__(**kw_args) + super(ExcSEXS, self).__init__(*args, **kw_args) + + _attrs = ["tb", "kc", "emax", "tatb", "tc", "efdmin", "efdmax", "emin", "k", "te"] + _attr_types = {"tb": float, "kc": float, "emax": float, "tatb": float, "tc": float, "efdmin": float, "efdmax": float, "emin": float, "k": float, "te": float} + _defaults = {"tb": 0.0, "kc": 0.0, "emax": 0.0, "tatb": 0.0, "tc": 0.0, "efdmin": 0.0, "efdmax": 0.0, "emin": 0.0, "k": 0.0, "te": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK.py index ee27e37..ba842f6 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK.py @@ -20,9 +20,16 @@ class ExcSK(ExcitationSystem): """Slovakian Excitation System Model (UEL, secondary voltage control) """ - def __init__(self, **kw_args): - """Initializes a new 'ExcSK' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcSK' instance. """ - super(ExcSK, self).__init__(**kw_args) + super(ExcSK, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK2.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK2.py index 8c34ac5..8ec2af1 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK2.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcSK2.py @@ -20,9 +20,16 @@ class ExcSK2(ExcitationSystem): """Slovakian alternator-rectifier Excitation System Model (UEL, secondary voltage control) """ - def __init__(self, **kw_args): - """Initializes a new 'ExcSK2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcSK2' instance. """ - super(ExcSK2, self).__init__(**kw_args) + super(ExcSK2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST1A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST1A.py index 5c1e60f..7ca7d8c 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST1A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST1A.py @@ -20,8 +20,8 @@ class ExcST1A(ExcitationSystem): """IEEE (1992/2005) ST1A Model The computer model of the Type ST1A potential-source controlled-rectifier excitation system represents systems in which excitation power is supplied through a transformer from the generator terminals (or the unit's auxiliary bus) and is regulated by a controlled rectifier. The maximum exciter voltage available from such systems is directly related to the generator terminal voltage. """ - def __init__(self, ta=0.0, vimin=0.0, vamin=0.0, kf=0.0, vrmin=0.0, ka=0.0, tb=0.0, vamax=0.0, tb1=0.0, uelin=0.0, kc=0.0, tc1=0.0, tf=0.0, klr=0.0, vimax=0.0, tc=0.0, pssin=0.0, vrmax=0.0, tr=0.0, ilr=0.0, **kw_args): - """Initializes a new 'ExcST1A' instance. + def __init__(self, ta=0.0, vimin=0.0, vamin=0.0, kf=0.0, vrmin=0.0, ka=0.0, tb=0.0, vamax=0.0, tb1=0.0, uelin=0.0, kc=0.0, tc1=0.0, tf=0.0, klr=0.0, vimax=0.0, tc=0.0, pssin=0.0, vrmax=0.0, tr=0.0, ilr=0.0, *args, **kw_args): + """Initialises a new 'ExcST1A' instance. @param ta: Time constant (>= 0.) @param vimin: Minimum error (< 0.) @@ -104,5 +104,12 @@ class ExcST1A(ExcitationSystem): #: Maximum field current self.ilr = ilr - super(ExcST1A, self).__init__(**kw_args) + super(ExcST1A, self).__init__(*args, **kw_args) + + _attrs = ["ta", "vimin", "vamin", "kf", "vrmin", "ka", "tb", "vamax", "tb1", "uelin", "kc", "tc1", "tf", "klr", "vimax", "tc", "pssin", "vrmax", "tr", "ilr"] + _attr_types = {"ta": float, "vimin": float, "vamin": float, "kf": float, "vrmin": float, "ka": float, "tb": float, "vamax": float, "tb1": float, "uelin": float, "kc": float, "tc1": float, "tf": float, "klr": float, "vimax": float, "tc": float, "pssin": float, "vrmax": float, "tr": float, "ilr": float} + _defaults = {"ta": 0.0, "vimin": 0.0, "vamin": 0.0, "kf": 0.0, "vrmin": 0.0, "ka": 0.0, "tb": 0.0, "vamax": 0.0, "tb1": 0.0, "uelin": 0.0, "kc": 0.0, "tc1": 0.0, "tf": 0.0, "klr": 0.0, "vimax": 0.0, "tc": 0.0, "pssin": 0.0, "vrmax": 0.0, "tr": 0.0, "ilr": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST2A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST2A.py index 53f8e96..fd1ba7c 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST2A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST2A.py @@ -20,8 +20,8 @@ class ExcST2A(ExcitationSystem): """IEEE (1992/2005) ST2A Model Some static systems utilize both current and voltage sources (generator terminal quantities) to comprise the power source. These compound-source rectifier excitation systems are designated Type ST2A. The regulator controls the exciter output through controlled saturation of the power transformer components. """ - def __init__(self, te=0.0, ka=0.0, tb=0.0, tf=0.0, kf=0.0, ke=0.0, tr=0.0, tc=0.0, ta=0.0, kc=0.0, ki=0.0, kp=0.0, uelin=0.0, vrmax=0.0, efdmax=0.0, vrmin=0.0, **kw_args): - """Initializes a new 'ExcST2A' instance. + def __init__(self, te=0.0, ka=0.0, tb=0.0, tf=0.0, kf=0.0, ke=0.0, tr=0.0, tc=0.0, ta=0.0, kc=0.0, ki=0.0, kp=0.0, uelin=0.0, vrmax=0.0, efdmax=0.0, vrmin=0.0, *args, **kw_args): + """Initialises a new 'ExcST2A' instance. @param te: Transformer saturation control time constant (> 0.) @param ka: Gain (> 0.) @@ -88,5 +88,12 @@ class ExcST2A(ExcitationSystem): #: Minimum controller output (< 0.) self.vrmin = vrmin - super(ExcST2A, self).__init__(**kw_args) + super(ExcST2A, self).__init__(*args, **kw_args) + + _attrs = ["te", "ka", "tb", "tf", "kf", "ke", "tr", "tc", "ta", "kc", "ki", "kp", "uelin", "vrmax", "efdmax", "vrmin"] + _attr_types = {"te": float, "ka": float, "tb": float, "tf": float, "kf": float, "ke": float, "tr": float, "tc": float, "ta": float, "kc": float, "ki": float, "kp": float, "uelin": float, "vrmax": float, "efdmax": float, "vrmin": float} + _defaults = {"te": 0.0, "ka": 0.0, "tb": 0.0, "tf": 0.0, "kf": 0.0, "ke": 0.0, "tr": 0.0, "tc": 0.0, "ta": 0.0, "kc": 0.0, "ki": 0.0, "kp": 0.0, "uelin": 0.0, "vrmax": 0.0, "efdmax": 0.0, "vrmin": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST3A.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST3A.py index 0030f30..1cbea54 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST3A.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST3A.py @@ -20,8 +20,8 @@ class ExcST3A(ExcitationSystem): """IEEE (1992/2005) ST3A Model Some static systems utilize a field voltage control loop to linearize the exciter control characteristic. This also makes the output independent of supply source variations until supply limitations are reached. These systems utilize a variety of controlled-rectifier designs: full thyristor complements or hybrid bridges in either series or shunt configurations. The power source may consist of only a potential source, either fed from the machine terminals or from internal windings. Some designs may have compound power sources utilizing both machine potential and current. These power sources are represented as phasor combinations of machine terminal current and voltage and are accommodated by suitable parameters in the model Type ST3A. """ - def __init__(self, kp=0.0, angp=0.0, xl=0.0, tc=0.0, tb=0.0, ki=0.0, vbmax=0.0, kc=0.0, vrmax=0.0, vimax=0.0, vgmax=0.0, km=0.0, vmmax=0.0, ka=0.0, tr=0.0, vrmin=0.0, kg=0.0, vimin=0.0, vmmin=0.0, tm=0.0, ta=0.0, **kw_args): - """Initializes a new 'ExcST3A' instance. + def __init__(self, kp=0.0, angp=0.0, xl=0.0, tc=0.0, tb=0.0, ki=0.0, vbmax=0.0, kc=0.0, vrmax=0.0, vimax=0.0, vgmax=0.0, km=0.0, vmmax=0.0, ka=0.0, tr=0.0, vrmin=0.0, kg=0.0, vimin=0.0, vmmin=0.0, tm=0.0, ta=0.0, *args, **kw_args): + """Initialises a new 'ExcST3A' instance. @param kp: Potential source gain (> 0.) @param angp: Phase angle of potential source @@ -108,5 +108,12 @@ class ExcST3A(ExcitationSystem): #: AVR time constant (>= 0.) self.ta = ta - super(ExcST3A, self).__init__(**kw_args) + super(ExcST3A, self).__init__(*args, **kw_args) + + _attrs = ["kp", "angp", "xl", "tc", "tb", "ki", "vbmax", "kc", "vrmax", "vimax", "vgmax", "km", "vmmax", "ka", "tr", "vrmin", "kg", "vimin", "vmmin", "tm", "ta"] + _attr_types = {"kp": float, "angp": float, "xl": float, "tc": float, "tb": float, "ki": float, "vbmax": float, "kc": float, "vrmax": float, "vimax": float, "vgmax": float, "km": float, "vmmax": float, "ka": float, "tr": float, "vrmin": float, "kg": float, "vimin": float, "vmmin": float, "tm": float, "ta": float} + _defaults = {"kp": 0.0, "angp": 0.0, "xl": 0.0, "tc": 0.0, "tb": 0.0, "ki": 0.0, "vbmax": 0.0, "kc": 0.0, "vrmax": 0.0, "vimax": 0.0, "vgmax": 0.0, "km": 0.0, "vmmax": 0.0, "ka": 0.0, "tr": 0.0, "vrmin": 0.0, "kg": 0.0, "vimin": 0.0, "vmmin": 0.0, "tm": 0.0, "ta": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST4B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST4B.py index 9e6e957..55207ac 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST4B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST4B.py @@ -20,8 +20,8 @@ class ExcST4B(ExcitationSystem): """IEEE (2005) ST4B Model This model is a variation of the Type ST3A model, with a proportional plus integral (PI) regulator block replacing the lag-lead regulator characteristic that was in the ST3A model. Both potential- and compoundsource rectifier excitation systems are modeled. The PI regulator blocks have nonwindup limits that are represented. The voltage regulator of this model is typically implemented digitally. """ - def __init__(self, kp=0.0, kim=0.0, vbmax=0.0, kc=0.0, kpr=0.0, xl=0.0, vgmax=0.0, vmmin=0.0, kg=0.0, vmmax=0.0, tr=0.0, ta=0.0, kpm=0.0, angp=0.0, vrmin=0.0, kir=0.0, vrmax=0.0, ki=0.0, **kw_args): - """Initializes a new 'ExcST4B' instance. + def __init__(self, kp=0.0, kim=0.0, vbmax=0.0, kc=0.0, kpr=0.0, xl=0.0, vgmax=0.0, vmmin=0.0, kg=0.0, vmmax=0.0, tr=0.0, ta=0.0, kpm=0.0, angp=0.0, vrmin=0.0, kir=0.0, vrmax=0.0, ki=0.0, *args, **kw_args): + """Initialises a new 'ExcST4B' instance. @param kp: Potential source gain (> 0.) @param kim: Integral gain of inner loop regulator @@ -96,5 +96,12 @@ class ExcST4B(ExcitationSystem): #: Current source gain (>= 0.) self.ki = ki - super(ExcST4B, self).__init__(**kw_args) + super(ExcST4B, self).__init__(*args, **kw_args) + + _attrs = ["kp", "kim", "vbmax", "kc", "kpr", "xl", "vgmax", "vmmin", "kg", "vmmax", "tr", "ta", "kpm", "angp", "vrmin", "kir", "vrmax", "ki"] + _attr_types = {"kp": float, "kim": float, "vbmax": float, "kc": float, "kpr": float, "xl": float, "vgmax": float, "vmmin": float, "kg": float, "vmmax": float, "tr": float, "ta": float, "kpm": float, "angp": float, "vrmin": float, "kir": float, "vrmax": float, "ki": float} + _defaults = {"kp": 0.0, "kim": 0.0, "vbmax": 0.0, "kc": 0.0, "kpr": 0.0, "xl": 0.0, "vgmax": 0.0, "vmmin": 0.0, "kg": 0.0, "vmmax": 0.0, "tr": 0.0, "ta": 0.0, "kpm": 0.0, "angp": 0.0, "vrmin": 0.0, "kir": 0.0, "vrmax": 0.0, "ki": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST5B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST5B.py index 95c4544..cdee444 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST5B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST5B.py @@ -20,8 +20,8 @@ class ExcST5B(ExcitationSystem): """IEEE (2005) ST5B Model The Type ST5B excitation system is a variation of the Type ST1A model, with alternative overexcitation and underexcitation inputs and additional limits. The corresponding stabilizer models that can be used with these models are the Type PSS2B, PSS3B, or PSS4B. """ - def __init__(self, tb2=0.0, tb1=0.0, tub2=0.0, tuc1=0.0, kr=0.0, tob2=0.0, tob1=0.0, tc1=0.0, toc1=0.0, tub1=0.0, tc2=0.0, kc=0.0, vrmax=0.0, tuc2=0.0, toc2=0.0, t1=0.0, tr=0.0, vrmin=0.0, **kw_args): - """Initializes a new 'ExcST5B' instance. + def __init__(self, tb2=0.0, tb1=0.0, tub2=0.0, tuc1=0.0, kr=0.0, tob2=0.0, tob1=0.0, tc1=0.0, toc1=0.0, tub1=0.0, tc2=0.0, kc=0.0, vrmax=0.0, tuc2=0.0, toc2=0.0, t1=0.0, tr=0.0, vrmin=0.0, *args, **kw_args): + """Initialises a new 'ExcST5B' instance. @param tb2: Regulator lag time constant (>= 0.) @param tb1: Regulator lag time constant (>= 0.) @@ -96,5 +96,12 @@ class ExcST5B(ExcitationSystem): #: Minimum regulator output (< 0.) self.vrmin = vrmin - super(ExcST5B, self).__init__(**kw_args) + super(ExcST5B, self).__init__(*args, **kw_args) + + _attrs = ["tb2", "tb1", "tub2", "tuc1", "kr", "tob2", "tob1", "tc1", "toc1", "tub1", "tc2", "kc", "vrmax", "tuc2", "toc2", "t1", "tr", "vrmin"] + _attr_types = {"tb2": float, "tb1": float, "tub2": float, "tuc1": float, "kr": float, "tob2": float, "tob1": float, "tc1": float, "toc1": float, "tub1": float, "tc2": float, "kc": float, "vrmax": float, "tuc2": float, "toc2": float, "t1": float, "tr": float, "vrmin": float} + _defaults = {"tb2": 0.0, "tb1": 0.0, "tub2": 0.0, "tuc1": 0.0, "kr": 0.0, "tob2": 0.0, "tob1": 0.0, "tc1": 0.0, "toc1": 0.0, "tub1": 0.0, "tc2": 0.0, "kc": 0.0, "vrmax": 0.0, "tuc2": 0.0, "toc2": 0.0, "t1": 0.0, "tr": 0.0, "vrmin": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST6B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST6B.py index ad9cfa3..e601602 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST6B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST6B.py @@ -20,8 +20,8 @@ class ExcST6B(ExcitationSystem): """IEEE (2005) ST6B Model The AVR consists of a PI voltage regulator with an inner loop field voltage regulator and pre-control. The field voltage regulator implements a proportional control. The pre-control and the delay in the feedback circuit increase the dynamic response. """ - def __init__(self, tr=0.0, ilr=0.0, vrmin=0.0, vmult=0.0, vrmax=0.0, oelin=0.0, klr=0.0, kg=0.0, kpa=0.0, vamax=0.0, ts=0.0, kcl=0.0, tg=0.0, vamin=0.0, kia=0.0, kff=0.0, km=0.0, **kw_args): - """Initializes a new 'ExcST6B' instance. + def __init__(self, tr=0.0, ilr=0.0, vrmin=0.0, vmult=0.0, vrmax=0.0, oelin=0.0, klr=0.0, kg=0.0, kpa=0.0, vamax=0.0, ts=0.0, kcl=0.0, tg=0.0, vamin=0.0, kia=0.0, kff=0.0, km=0.0, *args, **kw_args): + """Initialises a new 'ExcST6B' instance. @param tr: Filter time constant (>= 0.) @param ilr: Field current limiter setpoint (> 0.) @@ -92,5 +92,12 @@ class ExcST6B(ExcitationSystem): #: Main gain self.km = km - super(ExcST6B, self).__init__(**kw_args) + super(ExcST6B, self).__init__(*args, **kw_args) + + _attrs = ["tr", "ilr", "vrmin", "vmult", "vrmax", "oelin", "klr", "kg", "kpa", "vamax", "ts", "kcl", "tg", "vamin", "kia", "kff", "km"] + _attr_types = {"tr": float, "ilr": float, "vrmin": float, "vmult": float, "vrmax": float, "oelin": float, "klr": float, "kg": float, "kpa": float, "vamax": float, "ts": float, "kcl": float, "tg": float, "vamin": float, "kia": float, "kff": float, "km": float} + _defaults = {"tr": 0.0, "ilr": 0.0, "vrmin": 0.0, "vmult": 0.0, "vrmax": 0.0, "oelin": 0.0, "klr": 0.0, "kg": 0.0, "kpa": 0.0, "vamax": 0.0, "ts": 0.0, "kcl": 0.0, "tg": 0.0, "vamin": 0.0, "kia": 0.0, "kff": 0.0, "km": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST7B.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST7B.py index de69b1a..005fe69 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcST7B.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcST7B.py @@ -20,8 +20,8 @@ class ExcST7B(ExcitationSystem): """IEEE (2005) ST7B Model The model ST7B is representative of static potential-source excitation systems. In this system, the AVR consists of a PI voltage regulator. A phase lead-lag filter in series allows introduction of a derivative function, typically used with brushless excitation systems. In that case, the regulator is of the PID type. In addition, the terminal voltage channel includes a phase lead-lag filter. The AVR includes the appropriate inputs on its reference for overexcitation limiter (OEL1), underexcitation limiter (UEL), stator current limiter (SCL), and current compensator (DROOP). All these limitations, when they work at voltage reference level, keep the PSS (VS signal from Type PSS1A, PSS2A, or PSS2B) in operation. However, the UEL limitation can also be transferred to the high value (HV) gate acting on the output signal. In addition, the output signal passes through a low value (LV) gate for a ceiling overexcitation limiter (OEL2). """ - def __init__(self, oelin=0.0, vmax=0.0, tb=0.0, kia=0.0, kpa=0.0, kh=0.0, vrmin=0.0, ts=0.0, tia=0.0, tg=0.0, tr=0.0, tf=0.0, vrmax=0.0, uelin=0.0, kl=0.0, vmin=0.0, tc=0.0, **kw_args): - """Initializes a new 'ExcST7B' instance. + def __init__(self, oelin=0.0, vmax=0.0, tb=0.0, kia=0.0, kpa=0.0, kh=0.0, vrmin=0.0, ts=0.0, tia=0.0, tg=0.0, tr=0.0, tf=0.0, vrmax=0.0, uelin=0.0, kl=0.0, vmin=0.0, tc=0.0, *args, **kw_args): + """Initialises a new 'ExcST7B' instance. @param oelin: OEL input selector: 1 ? add to Vref, 2 ? input LV gate, 2 ? output LV gate, 0 ? no OEL input @param vmax: Maximum voltage reference signal (> 0.) @@ -92,5 +92,12 @@ class ExcST7B(ExcitationSystem): #: Lead-lag numerator time constant (>= 0.) self.tc = tc - super(ExcST7B, self).__init__(**kw_args) + super(ExcST7B, self).__init__(*args, **kw_args) + + _attrs = ["oelin", "vmax", "tb", "kia", "kpa", "kh", "vrmin", "ts", "tia", "tg", "tr", "tf", "vrmax", "uelin", "kl", "vmin", "tc"] + _attr_types = {"oelin": float, "vmax": float, "tb": float, "kia": float, "kpa": float, "kh": float, "vrmin": float, "ts": float, "tia": float, "tg": float, "tr": float, "tf": float, "vrmax": float, "uelin": float, "kl": float, "vmin": float, "tc": float} + _defaults = {"oelin": 0.0, "vmax": 0.0, "tb": 0.0, "kia": 0.0, "kpa": 0.0, "kh": 0.0, "vrmin": 0.0, "ts": 0.0, "tia": 0.0, "tg": 0.0, "tr": 0.0, "tf": 0.0, "vrmax": 0.0, "uelin": 0.0, "kl": 0.0, "vmin": 0.0, "tc": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT2E.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT2E.py index 73b05db..484b004 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT2E.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT2E.py @@ -20,9 +20,16 @@ class ExcWT2E(ExcitationSystem): """Type 2 standard wind turbine field resistance control model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcWT2E' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcWT2E' instance. """ - super(ExcWT2E, self).__init__(**kw_args) + super(ExcWT2E, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT3E.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT3E.py index da4237b..3dd5083 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT3E.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT3E.py @@ -20,9 +20,16 @@ class ExcWT3E(ExcitationSystem): """Type 3 standard wind turbine converter control model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcWT3E' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcWT3E' instance. """ - super(ExcWT3E, self).__init__(**kw_args) + super(ExcWT3E, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT4E.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT4E.py index b87b213..b9ad958 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT4E.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcWT4E.py @@ -20,9 +20,16 @@ class ExcWT4E(ExcitationSystem): """Type 4 standard wind turbine convertor control model """ - def __init__(self, **kw_args): - """Initializes a new 'ExcWT4E' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcWT4E' instance. """ - super(ExcWT4E, self).__init__(**kw_args) + super(ExcWT4E, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ExcitationSystems/ExcitationSystem.py b/schemata/CIM14/Dynamics/ExcitationSystems/ExcitationSystem.py index faf662b..6347dff 100644 --- a/schemata/CIM14/Dynamics/ExcitationSystems/ExcitationSystem.py +++ b/schemata/CIM14/Dynamics/ExcitationSystems/ExcitationSystem.py @@ -20,9 +20,16 @@ class ExcitationSystem(PowerSystemResource): """An excitation system provides the field voltage (Efd) for a synchronous machine model. It is linked to a specific generator by the Bus number and Unit ID. """ - def __init__(self, **kw_args): - """Initializes a new 'ExcitationSystem' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ExcitationSystem' instance. """ - super(ExcitationSystem, self).__init__(**kw_args) + super(ExcitationSystem, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Generators/GenAsync.py b/schemata/CIM14/Dynamics/Generators/GenAsync.py index 778767e..ea4d575 100644 --- a/schemata/CIM14/Dynamics/Generators/GenAsync.py +++ b/schemata/CIM14/Dynamics/Generators/GenAsync.py @@ -20,9 +20,16 @@ class GenAsync(AsynchronousMachine): """An asynchronous (induction) generator with no external connection to the rotor windings, e.g., squirrel-cage induction machine. """ - def __init__(self, **kw_args): - """Initializes a new 'GenAsync' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GenAsync' instance. """ - super(GenAsync, self).__init__(**kw_args) + super(GenAsync, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Generators/GenEquiv.py b/schemata/CIM14/Dynamics/Generators/GenEquiv.py index 488ce3b..bd287c5 100644 --- a/schemata/CIM14/Dynamics/Generators/GenEquiv.py +++ b/schemata/CIM14/Dynamics/Generators/GenEquiv.py @@ -20,8 +20,8 @@ class GenEquiv(RotatingMachine): """An equivalent representation of a synchronous generator as a constant internal voltage behind an impedance Ra plus Xp. """ - def __init__(self, xp=0.0, synchronousMachine0=None, **kw_args): - """Initializes a new 'GenEquiv' instance. + def __init__(self, xp=0.0, synchronousMachine0=None, *args, **kw_args): + """Initialises a new 'GenEquiv' instance. @param xp: Equivalent reactance, also known as Xp. @param synchronousMachine0: @@ -32,7 +32,14 @@ class GenEquiv(RotatingMachine): self._synchronousMachine0 = [] self.synchronousMachine0 = [] if synchronousMachine0 is None else synchronousMachine0 - super(GenEquiv, self).__init__(**kw_args) + super(GenEquiv, self).__init__(*args, **kw_args) + + _attrs = ["xp"] + _attr_types = {"xp": float} + _defaults = {"xp": 0.0} + _enums = {} + _refs = ["synchronousMachine0"] + _many_refs = ["synchronousMachine0"] def getsynchronousMachine0(self): diff --git a/schemata/CIM14/Dynamics/Generators/GenLoad.py b/schemata/CIM14/Dynamics/Generators/GenLoad.py index 79459d3..e133792 100644 --- a/schemata/CIM14/Dynamics/Generators/GenLoad.py +++ b/schemata/CIM14/Dynamics/Generators/GenLoad.py @@ -20,15 +20,22 @@ class GenLoad(RegulatingCondEq): """Representation of a small generator as a negative load rather than a dynamic generator model. This practice is also referred to as 'netting' the generation with the load, i.e. taking the net value of load minus generation as the new load value. For dynamic modeling purposes, each generator that does not have a dynamic load model must have a genLoad record. """ - def __init__(self, synchronousMachine0=None, **kw_args): - """Initializes a new 'GenLoad' instance. + def __init__(self, synchronousMachine0=None, *args, **kw_args): + """Initialises a new 'GenLoad' instance. @param synchronousMachine0: """ self._synchronousMachine0 = [] self.synchronousMachine0 = [] if synchronousMachine0 is None else synchronousMachine0 - super(GenLoad, self).__init__(**kw_args) + super(GenLoad, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["synchronousMachine0"] + _many_refs = ["synchronousMachine0"] def getsynchronousMachine0(self): diff --git a/schemata/CIM14/Dynamics/Loads/AggregateLoad.py b/schemata/CIM14/Dynamics/Loads/AggregateLoad.py index a38fab2..7734553 100644 --- a/schemata/CIM14/Dynamics/Loads/AggregateLoad.py +++ b/schemata/CIM14/Dynamics/Loads/AggregateLoad.py @@ -20,15 +20,22 @@ class AggregateLoad(PowerSystemResource): """Aggregate loads are used to represent all or part of the real and reactive load from a load in the static (power flow) data. This load is usually the aggregation of many individual load devices. The load models are approximate representation of the aggregate response of the load devices to system disturbances. Models of loads for dynamic analysis may themselves be either static or dynamic. A static load model represents the sensitivity of the real and reactive power consumed by the load to the amplitude and frequency of the bus voltage. A dynamic load model can used to represent the aggregate response of the motor components of the load. Large industrial motors or groups of similar motors may be represented by individual motor models (synchronous or asynchronous) which are usually represented as generators with negative Pgen in the static (power flow) data. """ - def __init__(self, energyConsumer0=None, **kw_args): - """Initializes a new 'AggregateLoad' instance. + def __init__(self, energyConsumer0=None, *args, **kw_args): + """Initialises a new 'AggregateLoad' instance. @param energyConsumer0: """ self._energyConsumer0 = [] self.energyConsumer0 = [] if energyConsumer0 is None else energyConsumer0 - super(AggregateLoad, self).__init__(**kw_args) + super(AggregateLoad, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["energyConsumer0"] + _many_refs = ["energyConsumer0"] def getenergyConsumer0(self): diff --git a/schemata/CIM14/Dynamics/Loads/LoadMotor.py b/schemata/CIM14/Dynamics/Loads/LoadMotor.py index 5da234c..afb37ee 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadMotor.py +++ b/schemata/CIM14/Dynamics/Loads/LoadMotor.py @@ -20,8 +20,8 @@ class LoadMotor(AggregateLoad): """Aggregate induction motor load. This model is used to represent a fraction of an ordinary load as 'induction motor load'. It allows load that is treated as ordinary constant power in power flow analysis to be represented by an induction motor in dynamic simulation. Either a 'one-cage' or 'two-cage' model of the induction machine can be modeled. Magnetic saturation is not modeled. This model is intended for representation of aggregations of many motors dispersed through a load represented at a high voltage bus but where there is no information on the characteristics of individual motors. """ - def __init__(self, tv=0.0, pfrac=0.0, vt=0.0, d=0.0, ra=0.0, ls=0.0, lfac=0.0, tpo=0.0, h=0.0, lp=0.0, lpp=0.0, tppo=0.0, tbkr=0.0, **kw_args): - """Initializes a new 'LoadMotor' instance. + def __init__(self, tv=0.0, pfrac=0.0, vt=0.0, d=0.0, ra=0.0, ls=0.0, lfac=0.0, tpo=0.0, h=0.0, lp=0.0, lpp=0.0, tppo=0.0, tbkr=0.0, *args, **kw_args): + """Initialises a new 'LoadMotor' instance. @param tv: Voltage trip pickup time (default = 999) @param pfrac: Fraction of constant-power load to be represented by this motor model (between 1.0 and 0.0) @@ -76,5 +76,12 @@ class LoadMotor(AggregateLoad): #: Circuit breaker operating time (default = 999) self.tbkr = tbkr - super(LoadMotor, self).__init__(**kw_args) + super(LoadMotor, self).__init__(*args, **kw_args) + + _attrs = ["tv", "pfrac", "vt", "d", "ra", "ls", "lfac", "tpo", "h", "lp", "lpp", "tppo", "tbkr"] + _attr_types = {"tv": float, "pfrac": float, "vt": float, "d": float, "ra": float, "ls": float, "lfac": float, "tpo": float, "h": float, "lp": float, "lpp": float, "tppo": float, "tbkr": float} + _defaults = {"tv": 0.0, "pfrac": 0.0, "vt": 0.0, "d": 0.0, "ra": 0.0, "ls": 0.0, "lfac": 0.0, "tpo": 0.0, "h": 0.0, "lp": 0.0, "lpp": 0.0, "tppo": 0.0, "tbkr": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStatic.py b/schemata/CIM14/Dynamics/Loads/LoadStatic.py index 5a7a9f1..5d34663 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStatic.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStatic.py @@ -20,8 +20,8 @@ class LoadStatic(AggregateLoad): """General Static Load Model. A static load model represents the sensitivity of the real and reactive power consumed by the load to the amplitude and frequency of the bus voltage. """ - def __init__(self, staticLoadType='ZIP1', ep1=0.0, kp3=0.0, eq3=0.0, kp2=0.0, eq2=0.0, kqf=0.0, kq4=0.0, kq2=0.0, kp1=0.0, ep2=0.0, eq1=0.0, kpf=0.0, kp4=0.0, kq3=0.0, ep3=0.0, kq1=0.0, **kw_args): - """Initializes a new 'LoadStatic' instance. + def __init__(self, staticLoadType="ZIP1", ep1=0.0, kp3=0.0, eq3=0.0, kp2=0.0, eq2=0.0, kqf=0.0, kq4=0.0, kq2=0.0, kp1=0.0, ep2=0.0, eq1=0.0, kpf=0.0, kp4=0.0, kq3=0.0, ep3=0.0, kq1=0.0, *args, **kw_args): + """Initialises a new 'LoadStatic' instance. @param staticLoadType: Type of static load model Values are: "ZIP1", "exponential", "ZIP2" @param ep1: @@ -41,7 +41,7 @@ class LoadStatic(AggregateLoad): @param ep3: @param kq1: """ - #: Type of static load modelValues are: "ZIP1", "exponential", "ZIP2" + #: Type of static load model Values are: "ZIP1", "exponential", "ZIP2" self.staticLoadType = staticLoadType @@ -92,5 +92,12 @@ class LoadStatic(AggregateLoad): self.kq1 = kq1 - super(LoadStatic, self).__init__(**kw_args) + super(LoadStatic, self).__init__(*args, **kw_args) + + _attrs = ["staticLoadType", "ep1", "kp3", "eq3", "kp2", "eq2", "kqf", "kq4", "kq2", "kp1", "ep2", "eq1", "kpf", "kp4", "kq3", "ep3", "kq1"] + _attr_types = {"staticLoadType": str, "ep1": float, "kp3": float, "eq3": float, "kp2": float, "eq2": float, "kqf": float, "kq4": float, "kq2": float, "kp1": float, "ep2": float, "eq1": float, "kpf": float, "kp4": float, "kq3": float, "ep3": float, "kq1": float} + _defaults = {"staticLoadType": "ZIP1", "ep1": 0.0, "kp3": 0.0, "eq3": 0.0, "kp2": 0.0, "eq2": 0.0, "kqf": 0.0, "kq4": 0.0, "kq2": 0.0, "kp1": 0.0, "ep2": 0.0, "eq1": 0.0, "kpf": 0.0, "kp4": 0.0, "kq3": 0.0, "ep3": 0.0, "kq1": 0.0} + _enums = {"staticLoadType": "StaticLoadType"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStaticArea.py b/schemata/CIM14/Dynamics/Loads/LoadStaticArea.py index ce82fbf..708985f 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStaticArea.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStaticArea.py @@ -20,9 +20,16 @@ class LoadStaticArea(LoadStatic): """Static load associated with an Area. """ - def __init__(self, **kw_args): - """Initializes a new 'LoadStaticArea' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'LoadStaticArea' instance. """ - super(LoadStaticArea, self).__init__(**kw_args) + super(LoadStaticArea, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStaticBus.py b/schemata/CIM14/Dynamics/Loads/LoadStaticBus.py index f23faa1..bed7643 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStaticBus.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStaticBus.py @@ -20,9 +20,16 @@ class LoadStaticBus(LoadStatic): """Static load model associated with a single bus. """ - def __init__(self, **kw_args): - """Initializes a new 'LoadStaticBus' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'LoadStaticBus' instance. """ - super(LoadStaticBus, self).__init__(**kw_args) + super(LoadStaticBus, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStaticOwner.py b/schemata/CIM14/Dynamics/Loads/LoadStaticOwner.py index 62ad013..85dd117 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStaticOwner.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStaticOwner.py @@ -20,9 +20,16 @@ class LoadStaticOwner(LoadStatic): """Static load associated with a single owner. """ - def __init__(self, **kw_args): - """Initializes a new 'LoadStaticOwner' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'LoadStaticOwner' instance. """ - super(LoadStaticOwner, self).__init__(**kw_args) + super(LoadStaticOwner, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStaticSystem.py b/schemata/CIM14/Dynamics/Loads/LoadStaticSystem.py index cf81820..9ee58a0 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStaticSystem.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStaticSystem.py @@ -20,9 +20,16 @@ class LoadStaticSystem(LoadStatic): """Static load associated with a specific system. """ - def __init__(self, **kw_args): - """Initializes a new 'LoadStaticSystem' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'LoadStaticSystem' instance. """ - super(LoadStaticSystem, self).__init__(**kw_args) + super(LoadStaticSystem, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Loads/LoadStaticZone.py b/schemata/CIM14/Dynamics/Loads/LoadStaticZone.py index 10d77c8..f1cb148 100644 --- a/schemata/CIM14/Dynamics/Loads/LoadStaticZone.py +++ b/schemata/CIM14/Dynamics/Loads/LoadStaticZone.py @@ -20,9 +20,16 @@ class LoadStaticZone(LoadStatic): """Static load associated with a zone. """ - def __init__(self, **kw_args): - """Initializes a new 'LoadStaticZone' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'LoadStaticZone' instance. """ - super(LoadStaticZone, self).__init__(**kw_args) + super(LoadStaticZone, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/MetaBlock.py b/schemata/CIM14/Dynamics/MetaBlock.py index e985d57..3cdee67 100644 --- a/schemata/CIM14/Dynamics/MetaBlock.py +++ b/schemata/CIM14/Dynamics/MetaBlock.py @@ -20,8 +20,8 @@ class MetaBlock(IdentifiedObject): """A block is a meta-data representation of a control block. It has an external interface and an optinal internal interface. Blocks internals can be ommitted if the block is well understood by both exchange parties. When well understood by both partice the block can be treated as a primitive block. All dynamic models must be defined to the level of primtive blocks in order for the model to be consumed and used for dynamic simulation. Examples of primitive blocks include a well known IEEE exciter model, a summation block, or an integrator block. """ - def __init__(self, blockKind='powerSystemStabilizer', internal=False, proprietary=False, primitive=False, MetaBlockReference=None, MetaBlockOutput=None, MetaBlockState=None, MetaBlockSignal=None, blockType0=None, MetaBlockInput=None, blockConstant0=None, Block=None, MetaBlockParameter=None, **kw_args): - """Initializes a new 'MetaBlock' instance. + def __init__(self, blockKind="powerSystemStabilizer", internal=False, proprietary=False, primitive=False, MetaBlockReference=None, MetaBlockOutput=None, MetaBlockState=None, MetaBlockSignal=None, blockType0=None, MetaBlockInput=None, blockConstant0=None, Block=None, MetaBlockParameter=None, *args, **kw_args): + """Initialises a new 'MetaBlock' instance. @param blockKind: Enumeration type: StandardControlBlock, Excitation System, ... Name used to distinguish which standard control block (Integration, Summation, ...)? Values are: "powerSystemStabilizer", "automaticVoltageControl", "turbine", "govenor", "dotDotDot", "energySource", "exciter" @param internal: This block is intended to be used only internally within other blocks. An example would be a summation or integrator block. Such bocks are typically also primitive, though more complex internal blocks made up of other primitive controls could be built. @@ -37,7 +37,7 @@ class MetaBlock(IdentifiedObject): @param Block: @param MetaBlockParameter: Paramters belong to a block. """ - #: Enumeration type: StandardControlBlock, Excitation System, ... Name used to distinguish which standard control block (Integration, Summation, ...)?Values are: "powerSystemStabilizer", "automaticVoltageControl", "turbine", "govenor", "dotDotDot", "energySource", "exciter" + #: Enumeration type: StandardControlBlock, Excitation System, ... Name used to distinguish which standard control block (Integration, Summation, ...)? Values are: "powerSystemStabilizer", "automaticVoltageControl", "turbine", "govenor", "dotDotDot", "energySource", "exciter" self.blockKind = blockKind #: This block is intended to be used only internally within other blocks. An example would be a summation or integrator block. Such bocks are typically also primitive, though more complex internal blocks made up of other primitive controls could be built. @@ -76,7 +76,14 @@ class MetaBlock(IdentifiedObject): self._MetaBlockParameter = [] self.MetaBlockParameter = [] if MetaBlockParameter is None else MetaBlockParameter - super(MetaBlock, self).__init__(**kw_args) + super(MetaBlock, self).__init__(*args, **kw_args) + + _attrs = ["blockKind", "internal", "proprietary", "primitive"] + _attr_types = {"blockKind": str, "internal": bool, "proprietary": bool, "primitive": bool} + _defaults = {"blockKind": "powerSystemStabilizer", "internal": False, "proprietary": False, "primitive": False} + _enums = {"blockKind": "BlockKind"} + _refs = ["MetaBlockReference", "MetaBlockOutput", "MetaBlockState", "MetaBlockSignal", "blockType0", "MetaBlockInput", "blockConstant0", "Block", "MetaBlockParameter"] + _many_refs = ["MetaBlockReference", "MetaBlockOutput", "MetaBlockState", "MetaBlockSignal", "MetaBlockInput", "blockConstant0", "Block", "MetaBlockParameter"] def getMetaBlockReference(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConInput.py b/schemata/CIM14/Dynamics/MetaBlockConInput.py index fb06afe..6282a63 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConInput.py +++ b/schemata/CIM14/Dynamics/MetaBlockConInput.py @@ -20,8 +20,8 @@ class MetaBlockConInput(IdentifiedObject): """If model the association to MeasurementType, the it means take the input from the associated PSR or Terminal in the static model. """ - def __init__(self, MetaBlockConSignal=None, MemberOf_MetaBlockConnection=None, Unit=None, **kw_args): - """Initializes a new 'MetaBlockConInput' instance. + def __init__(self, MetaBlockConSignal=None, MemberOf_MetaBlockConnection=None, Unit=None, *args, **kw_args): + """Initialises a new 'MetaBlockConInput' instance. @param MetaBlockConSignal: @param MemberOf_MetaBlockConnection: @@ -36,7 +36,14 @@ class MetaBlockConInput(IdentifiedObject): self._Unit = None self.Unit = Unit - super(MetaBlockConInput, self).__init__(**kw_args) + super(MetaBlockConInput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConSignal", "MemberOf_MetaBlockConnection", "Unit"] + _many_refs = [] def getMetaBlockConSignal(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConOutput.py b/schemata/CIM14/Dynamics/MetaBlockConOutput.py index 5d0d595..2166daa 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConOutput.py +++ b/schemata/CIM14/Dynamics/MetaBlockConOutput.py @@ -20,8 +20,8 @@ class MetaBlockConOutput(IdentifiedObject): """If model uses MeasurementType association, it means the output is pushed back to the steady state model (if reasonable). """ - def __init__(self, MetaBlockConSignal=None, MemberOf_MetaBlockConnection=None, Unit=None, **kw_args): - """Initializes a new 'MetaBlockConOutput' instance. + def __init__(self, MetaBlockConSignal=None, MemberOf_MetaBlockConnection=None, Unit=None, *args, **kw_args): + """Initialises a new 'MetaBlockConOutput' instance. @param MetaBlockConSignal: @param MemberOf_MetaBlockConnection: @@ -36,7 +36,14 @@ class MetaBlockConOutput(IdentifiedObject): self._Unit = None self.Unit = Unit - super(MetaBlockConOutput, self).__init__(**kw_args) + super(MetaBlockConOutput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConSignal", "MemberOf_MetaBlockConnection", "Unit"] + _many_refs = ["MetaBlockConSignal"] def getMetaBlockConSignal(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConSignal.py b/schemata/CIM14/Dynamics/MetaBlockConSignal.py index 5bc78a1..e989e82 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConSignal.py +++ b/schemata/CIM14/Dynamics/MetaBlockConSignal.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockConSignal(IdentifiedObject): - def __init__(self, MetaBlockConInput=None, MemberOf_MetaBlockConnectivity=None, MetaBlockConOutput=None, metaBlockConnectivity0=None, **kw_args): - """Initializes a new 'MetaBlockConSignal' instance. + def __init__(self, MetaBlockConInput=None, MemberOf_MetaBlockConnectivity=None, MetaBlockConOutput=None, metaBlockConnectivity0=None, *args, **kw_args): + """Initialises a new 'MetaBlockConSignal' instance. @param MetaBlockConInput: @param MemberOf_MetaBlockConnectivity: @@ -38,7 +38,14 @@ class MetaBlockConSignal(IdentifiedObject): self._metaBlockConnectivity0 = None self.metaBlockConnectivity0 = metaBlockConnectivity0 - super(MetaBlockConSignal, self).__init__(**kw_args) + super(MetaBlockConSignal, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConInput", "MemberOf_MetaBlockConnectivity", "MetaBlockConOutput", "metaBlockConnectivity0"] + _many_refs = [] def getMetaBlockConInput(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConnectable.py b/schemata/CIM14/Dynamics/MetaBlockConnectable.py index bd78395..8c493ea 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConnectable.py +++ b/schemata/CIM14/Dynamics/MetaBlockConnectable.py @@ -20,8 +20,8 @@ class MetaBlockConnectable(IdentifiedObject): """This is a source connection for a block input at the dynamics meta-data level. The subtypes represent different ways to obtain the numbers. Note that a block output is NOT derived from this class since block outputs can only be computed from references to other blocks via the BlockOutputReference class. """ - def __init__(self, StandardControlBlock_MetaBlockStateReference=None, MetaBlockOutputReference=None, MetaBlockStateReference=None, BlockInputReference=None, StandardControlBlock_MetaBlockInputReference=None, StandardControlBlock_MetaBlockParameterReference=None, MetaBlockParameterReference=None, StandardControlBlock_MetaBlockOutputReference=None, MetaBlockInputReference=None, **kw_args): - """Initializes a new 'MetaBlockConnectable' instance. + def __init__(self, StandardControlBlock_MetaBlockStateReference=None, MetaBlockOutputReference=None, MetaBlockStateReference=None, BlockInputReference=None, StandardControlBlock_MetaBlockInputReference=None, StandardControlBlock_MetaBlockParameterReference=None, MetaBlockParameterReference=None, StandardControlBlock_MetaBlockOutputReference=None, MetaBlockInputReference=None, *args, **kw_args): + """Initialises a new 'MetaBlockConnectable' instance. @param StandardControlBlock_MetaBlockStateReference: @param MetaBlockOutputReference: @@ -60,7 +60,14 @@ class MetaBlockConnectable(IdentifiedObject): self._MetaBlockInputReference = [] self.MetaBlockInputReference = [] if MetaBlockInputReference is None else MetaBlockInputReference - super(MetaBlockConnectable, self).__init__(**kw_args) + super(MetaBlockConnectable, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["StandardControlBlock_MetaBlockStateReference", "MetaBlockOutputReference", "MetaBlockStateReference", "BlockInputReference", "StandardControlBlock_MetaBlockInputReference", "StandardControlBlock_MetaBlockParameterReference", "MetaBlockParameterReference", "StandardControlBlock_MetaBlockOutputReference", "MetaBlockInputReference"] + _many_refs = ["StandardControlBlock_MetaBlockStateReference", "MetaBlockOutputReference", "MetaBlockStateReference", "BlockInputReference", "StandardControlBlock_MetaBlockInputReference", "StandardControlBlock_MetaBlockParameterReference", "MetaBlockParameterReference", "StandardControlBlock_MetaBlockOutputReference", "MetaBlockInputReference"] def getStandardControlBlock_MetaBlockStateReference(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConnection.py b/schemata/CIM14/Dynamics/MetaBlockConnection.py index 3fd3ada..c6819bc 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConnection.py +++ b/schemata/CIM14/Dynamics/MetaBlockConnection.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockConnection(IdentifiedObject): - def __init__(self, slotname='', MetaBlockConOutput=None, MetaBlockConInput=None, metaBlockConnectivity0=None, BlockConnection=None, MemberOf_MetaBlockConnectivity=None, **kw_args): - """Initializes a new 'MetaBlockConnection' instance. + def __init__(self, slotname='', MetaBlockConOutput=None, MetaBlockConInput=None, metaBlockConnectivity0=None, BlockConnection=None, MemberOf_MetaBlockConnectivity=None, *args, **kw_args): + """Initialises a new 'MetaBlockConnection' instance. @param slotname: Used for standard connection situations where multiple blocks of same class or same MetaBlock::blockkind have to be connected. The slotnames used are defined in the Reference Manual for Exchanging Standard Power System Dynamic Models. Application: Cross-compound or Combined Cycle connections. @param MetaBlockConOutput: @@ -46,7 +46,14 @@ class MetaBlockConnection(IdentifiedObject): self._MemberOf_MetaBlockConnectivity = None self.MemberOf_MetaBlockConnectivity = MemberOf_MetaBlockConnectivity - super(MetaBlockConnection, self).__init__(**kw_args) + super(MetaBlockConnection, self).__init__(*args, **kw_args) + + _attrs = ["slotname"] + _attr_types = {"slotname": str} + _defaults = {"slotname": ''} + _enums = {} + _refs = ["MetaBlockConOutput", "MetaBlockConInput", "metaBlockConnectivity0", "BlockConnection", "MemberOf_MetaBlockConnectivity"] + _many_refs = ["MetaBlockConOutput", "MetaBlockConInput", "BlockConnection"] def getMetaBlockConOutput(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockConnectivity.py b/schemata/CIM14/Dynamics/MetaBlockConnectivity.py index 6dbb5dd..0ebb678 100644 --- a/schemata/CIM14/Dynamics/MetaBlockConnectivity.py +++ b/schemata/CIM14/Dynamics/MetaBlockConnectivity.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockConnectivity(IdentifiedObject): - def __init__(self, BlockConnectivity=None, MetaBlockConSignal=None, metaBlockConnection0=None, metaBlockConSignal0=None, MetaBlockConnection=None, **kw_args): - """Initializes a new 'MetaBlockConnectivity' instance. + def __init__(self, BlockConnectivity=None, MetaBlockConSignal=None, metaBlockConnection0=None, metaBlockConSignal0=None, MetaBlockConnection=None, *args, **kw_args): + """Initialises a new 'MetaBlockConnectivity' instance. @param BlockConnectivity: @param MetaBlockConSignal: @@ -42,7 +42,14 @@ class MetaBlockConnectivity(IdentifiedObject): self._MetaBlockConnection = [] self.MetaBlockConnection = [] if MetaBlockConnection is None else MetaBlockConnection - super(MetaBlockConnectivity, self).__init__(**kw_args) + super(MetaBlockConnectivity, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["BlockConnectivity", "MetaBlockConSignal", "metaBlockConnection0", "metaBlockConSignal0", "MetaBlockConnection"] + _many_refs = ["BlockConnectivity", "MetaBlockConSignal", "metaBlockConnection0", "metaBlockConSignal0", "MetaBlockConnection"] def getBlockConnectivity(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockInput.py b/schemata/CIM14/Dynamics/MetaBlockInput.py index caf020b..747654d 100644 --- a/schemata/CIM14/Dynamics/MetaBlockInput.py +++ b/schemata/CIM14/Dynamics/MetaBlockInput.py @@ -20,8 +20,8 @@ class MetaBlockInput(MetaBlockConnectable): """Linkage at the dynanics meta model level. The output of a block could link to this. This is a public interface external to the block. """ - def __init__(self, blockInputReference0=None, MemberOf_MetaBlock=None, blockUsageInputReference0=None, blockInputType0=None, tieToMeasurement0=None, **kw_args): - """Initializes a new 'MetaBlockInput' instance. + def __init__(self, blockInputReference0=None, MemberOf_MetaBlock=None, blockUsageInputReference0=None, blockInputType0=None, tieToMeasurement0=None, *args, **kw_args): + """Initialises a new 'MetaBlockInput' instance. @param blockInputReference0: References the idenfiied input for the block reference. @param MemberOf_MetaBlock: Inputs belong to a block. @@ -44,7 +44,14 @@ class MetaBlockInput(MetaBlockConnectable): self._tieToMeasurement0 = [] self.tieToMeasurement0 = [] if tieToMeasurement0 is None else tieToMeasurement0 - super(MetaBlockInput, self).__init__(**kw_args) + super(MetaBlockInput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["blockInputReference0", "MemberOf_MetaBlock", "blockUsageInputReference0", "blockInputType0", "tieToMeasurement0"] + _many_refs = ["blockInputReference0", "blockUsageInputReference0", "tieToMeasurement0"] def getblockInputReference0(self): """References the idenfiied input for the block reference. diff --git a/schemata/CIM14/Dynamics/MetaBlockInputReference.py b/schemata/CIM14/Dynamics/MetaBlockInputReference.py index a0ba23b..dd1aed6 100644 --- a/schemata/CIM14/Dynamics/MetaBlockInputReference.py +++ b/schemata/CIM14/Dynamics/MetaBlockInputReference.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockInputReference(IdentifiedObject): - def __init__(self, positiveFlowIn=False, StandardControlBlock_MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, MetaBlockSignal=None, MetaBlockConnectable=None, **kw_args): - """Initializes a new 'MetaBlockInputReference' instance. + def __init__(self, positiveFlowIn=False, StandardControlBlock_MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, MetaBlockSignal=None, MetaBlockConnectable=None, *args, **kw_args): + """Initialises a new 'MetaBlockInputReference' instance. @param positiveFlowIn: If true then any flows associated with a terminal are referenced as positive from the system into the device. @param StandardControlBlock_MetaBlockConnectable: @@ -42,7 +42,14 @@ class MetaBlockInputReference(IdentifiedObject): self._MetaBlockConnectable = None self.MetaBlockConnectable = MetaBlockConnectable - super(MetaBlockInputReference, self).__init__(**kw_args) + super(MetaBlockInputReference, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn"] + _attr_types = {"positiveFlowIn": bool} + _defaults = {"positiveFlowIn": False} + _enums = {} + _refs = ["StandardControlBlock_MetaBlockConnectable", "MemberOf_MetaBlockReference", "MetaBlockSignal", "MetaBlockConnectable"] + _many_refs = [] def getStandardControlBlock_MetaBlockConnectable(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockOutput.py b/schemata/CIM14/Dynamics/MetaBlockOutput.py index bd2ed4f..ea5cf16 100644 --- a/schemata/CIM14/Dynamics/MetaBlockOutput.py +++ b/schemata/CIM14/Dynamics/MetaBlockOutput.py @@ -20,8 +20,8 @@ class MetaBlockOutput(MetaBlockConnectable): """Output state of a block. This is a public interface external to the block. One or more block outputs should be specified in order to link blocks together. Certain block kinds might require a specific output. For example, an exciter block might require an output called 'Ea'. """ - def __init__(self, BlockOutputReference=None, MemberOf_MetaBlock=None, blockUsageOutputReference0=None, blockOutputType0=None, **kw_args): - """Initializes a new 'MetaBlockOutput' instance. + def __init__(self, BlockOutputReference=None, MemberOf_MetaBlock=None, blockUsageOutputReference0=None, blockOutputType0=None, *args, **kw_args): + """Initialises a new 'MetaBlockOutput' instance. @param BlockOutputReference: A block output reference for the block output. The output of the block is passed to the block output reference which is a block connectable and thus can be connected at the dynamics metadata level to another block. @param MemberOf_MetaBlock: The block that contains the output. @@ -40,7 +40,14 @@ class MetaBlockOutput(MetaBlockConnectable): self._blockOutputType0 = None self.blockOutputType0 = blockOutputType0 - super(MetaBlockOutput, self).__init__(**kw_args) + super(MetaBlockOutput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["BlockOutputReference", "MemberOf_MetaBlock", "blockUsageOutputReference0", "blockOutputType0"] + _many_refs = ["BlockOutputReference", "blockUsageOutputReference0"] def getBlockOutputReference(self): """A block output reference for the block output. The output of the block is passed to the block output reference which is a block connectable and thus can be connected at the dynamics metadata level to another block. diff --git a/schemata/CIM14/Dynamics/MetaBlockOutputReference.py b/schemata/CIM14/Dynamics/MetaBlockOutputReference.py index d90bed8..f22c53c 100644 --- a/schemata/CIM14/Dynamics/MetaBlockOutputReference.py +++ b/schemata/CIM14/Dynamics/MetaBlockOutputReference.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockOutputReference(IdentifiedObject): - def __init__(self, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, MetaBlockSignal=None, StandardControlBlock_MetaBlockConnectable=None, **kw_args): - """Initializes a new 'MetaBlockOutputReference' instance. + def __init__(self, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, MetaBlockSignal=None, StandardControlBlock_MetaBlockConnectable=None, *args, **kw_args): + """Initialises a new 'MetaBlockOutputReference' instance. @param MetaBlockConnectable: @param MemberOf_MetaBlockReference: @@ -38,7 +38,14 @@ class MetaBlockOutputReference(IdentifiedObject): self._StandardControlBlock_MetaBlockConnectable = None self.StandardControlBlock_MetaBlockConnectable = StandardControlBlock_MetaBlockConnectable - super(MetaBlockOutputReference, self).__init__(**kw_args) + super(MetaBlockOutputReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MetaBlockConnectable", "MemberOf_MetaBlockReference", "MetaBlockSignal", "StandardControlBlock_MetaBlockConnectable"] + _many_refs = ["MetaBlockSignal"] def getMetaBlockConnectable(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockParameter.py b/schemata/CIM14/Dynamics/MetaBlockParameter.py index 6cab05f..21cede2 100644 --- a/schemata/CIM14/Dynamics/MetaBlockParameter.py +++ b/schemata/CIM14/Dynamics/MetaBlockParameter.py @@ -20,8 +20,8 @@ class MetaBlockParameter(MetaBlockConnectable): """An identified parameter of a block. This is meta dynamics model and does not contain specific parameter values. When using a block one would need to supply specific parameter values. These are typically time constants, but are not restricted to this. Sometimes, for standard blocks, the block paramter may come directly from the attributes of an associated PowerSystemResource object, but such parameters may be specified to enable user defined models to alter the behavior of a standard block. """ - def __init__(self, BlockParameter=None, MemberOf_MetaBlock=None, **kw_args): - """Initializes a new 'MetaBlockParameter' instance. + def __init__(self, BlockParameter=None, MemberOf_MetaBlock=None, *args, **kw_args): + """Initialises a new 'MetaBlockParameter' instance. @param BlockParameter: @param MemberOf_MetaBlock: Paramters belong to a block. @@ -32,7 +32,14 @@ class MetaBlockParameter(MetaBlockConnectable): self._MemberOf_MetaBlock = None self.MemberOf_MetaBlock = MemberOf_MetaBlock - super(MetaBlockParameter, self).__init__(**kw_args) + super(MetaBlockParameter, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["BlockParameter", "MemberOf_MetaBlock"] + _many_refs = ["BlockParameter"] def getBlockParameter(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockParameterReference.py b/schemata/CIM14/Dynamics/MetaBlockParameterReference.py index 28c2536..c7c3ba3 100644 --- a/schemata/CIM14/Dynamics/MetaBlockParameterReference.py +++ b/schemata/CIM14/Dynamics/MetaBlockParameterReference.py @@ -20,8 +20,8 @@ class MetaBlockParameterReference(IdentifiedObject): """References a parameter of a block used in the internal representation of a block. """ - def __init__(self, StandardControlBlock_MetaBlockConnectable=None, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, **kw_args): - """Initializes a new 'MetaBlockParameterReference' instance. + def __init__(self, StandardControlBlock_MetaBlockConnectable=None, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, *args, **kw_args): + """Initialises a new 'MetaBlockParameterReference' instance. @param StandardControlBlock_MetaBlockConnectable: @param MetaBlockConnectable: @@ -36,7 +36,14 @@ class MetaBlockParameterReference(IdentifiedObject): self._MemberOf_MetaBlockReference = None self.MemberOf_MetaBlockReference = MemberOf_MetaBlockReference - super(MetaBlockParameterReference, self).__init__(**kw_args) + super(MetaBlockParameterReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["StandardControlBlock_MetaBlockConnectable", "MetaBlockConnectable", "MemberOf_MetaBlockReference"] + _many_refs = [] def getStandardControlBlock_MetaBlockConnectable(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockReference.py b/schemata/CIM14/Dynamics/MetaBlockReference.py index e2b8a84..edf3824 100644 --- a/schemata/CIM14/Dynamics/MetaBlockReference.py +++ b/schemata/CIM14/Dynamics/MetaBlockReference.py @@ -20,8 +20,8 @@ class MetaBlockReference(IdentifiedObject): """References a control block at the internal meta dynamics model level. These references are contained in other blocks and reference the single instance of the meta model that defines a particular block definition. One would not expect to see bock references contained within a primitive block. """ - def __init__(self, equationType='', blockInputReference0=None, MemberOf_MetaBlock=None, MetaBlock=None, blockOutputReference0=None, MetaBlockStateReference=None, MetaBlockInputReference=None, MetaBlockOutputReference=None, BlockParameter=None, MetaBlockParameterReference=None, **kw_args): - """Initializes a new 'MetaBlockReference' instance. + def __init__(self, equationType='', blockInputReference0=None, MemberOf_MetaBlock=None, MetaBlock=None, blockOutputReference0=None, MetaBlockStateReference=None, MetaBlockInputReference=None, MetaBlockOutputReference=None, BlockParameter=None, MetaBlockParameterReference=None, *args, **kw_args): + """Initialises a new 'MetaBlockReference' instance. @param equationType: should be enum, initial conditions vs. simulation equations @param blockInputReference0: @@ -63,7 +63,14 @@ class MetaBlockReference(IdentifiedObject): self._MetaBlockParameterReference = [] self.MetaBlockParameterReference = [] if MetaBlockParameterReference is None else MetaBlockParameterReference - super(MetaBlockReference, self).__init__(**kw_args) + super(MetaBlockReference, self).__init__(*args, **kw_args) + + _attrs = ["equationType"] + _attr_types = {"equationType": str} + _defaults = {"equationType": ''} + _enums = {} + _refs = ["blockInputReference0", "MemberOf_MetaBlock", "MetaBlock", "blockOutputReference0", "MetaBlockStateReference", "MetaBlockInputReference", "MetaBlockOutputReference", "BlockParameter", "MetaBlockParameterReference"] + _many_refs = ["blockInputReference0", "blockOutputReference0", "MetaBlockStateReference", "MetaBlockInputReference", "MetaBlockOutputReference", "BlockParameter", "MetaBlockParameterReference"] def getblockInputReference0(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockSignal.py b/schemata/CIM14/Dynamics/MetaBlockSignal.py index 95139a4..7ee3e63 100644 --- a/schemata/CIM14/Dynamics/MetaBlockSignal.py +++ b/schemata/CIM14/Dynamics/MetaBlockSignal.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockSignal(IdentifiedObject): - def __init__(self, metaBlockSignal1=None, metaBlockSignal=None, MemberOf_MetaBlock=None, From=None, To=None, **kw_args): - """Initializes a new 'MetaBlockSignal' instance. + def __init__(self, metaBlockSignal1=None, metaBlockSignal=None, MemberOf_MetaBlock=None, From=None, To=None, *args, **kw_args): + """Initialises a new 'MetaBlockSignal' instance. @param metaBlockSignal1: @param metaBlockSignal: @@ -42,7 +42,14 @@ class MetaBlockSignal(IdentifiedObject): self._To = None self.To = To - super(MetaBlockSignal, self).__init__(**kw_args) + super(MetaBlockSignal, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["metaBlockSignal1", "metaBlockSignal", "MemberOf_MetaBlock", "From", "To"] + _many_refs = ["metaBlockSignal1", "metaBlockSignal"] def getmetaBlockSignal1(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockState.py b/schemata/CIM14/Dynamics/MetaBlockState.py index a9cc881..3fb45e0 100644 --- a/schemata/CIM14/Dynamics/MetaBlockState.py +++ b/schemata/CIM14/Dynamics/MetaBlockState.py @@ -18,15 +18,22 @@ from CIM14.Dynamics.MetaBlockConnectable import MetaBlockConnectable class MetaBlockState(MetaBlockConnectable): - def __init__(self, MemberOf_MetaBlock=None, **kw_args): - """Initializes a new 'MetaBlockState' instance. + def __init__(self, MemberOf_MetaBlock=None, *args, **kw_args): + """Initialises a new 'MetaBlockState' instance. @param MemberOf_MetaBlock: """ self._MemberOf_MetaBlock = None self.MemberOf_MetaBlock = MemberOf_MetaBlock - super(MetaBlockState, self).__init__(**kw_args) + super(MetaBlockState, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MemberOf_MetaBlock"] + _many_refs = [] def getMemberOf_MetaBlock(self): diff --git a/schemata/CIM14/Dynamics/MetaBlockStateReference.py b/schemata/CIM14/Dynamics/MetaBlockStateReference.py index 3eb79d8..6d3782e 100644 --- a/schemata/CIM14/Dynamics/MetaBlockStateReference.py +++ b/schemata/CIM14/Dynamics/MetaBlockStateReference.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class MetaBlockStateReference(IdentifiedObject): - def __init__(self, positiveFlowIn=False, StandardControlBlock_MetaBlockConnectable=None, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, **kw_args): - """Initializes a new 'MetaBlockStateReference' instance. + def __init__(self, positiveFlowIn=False, StandardControlBlock_MetaBlockConnectable=None, MetaBlockConnectable=None, MemberOf_MetaBlockReference=None, *args, **kw_args): + """Initialises a new 'MetaBlockStateReference' instance. @param positiveFlowIn: If true then any flows associated with a terminal are referenced as positive from the system into the device. @param StandardControlBlock_MetaBlockConnectable: @@ -38,7 +38,14 @@ class MetaBlockStateReference(IdentifiedObject): self._MemberOf_MetaBlockReference = None self.MemberOf_MetaBlockReference = MemberOf_MetaBlockReference - super(MetaBlockStateReference, self).__init__(**kw_args) + super(MetaBlockStateReference, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn"] + _attr_types = {"positiveFlowIn": bool} + _defaults = {"positiveFlowIn": False} + _enums = {} + _refs = ["StandardControlBlock_MetaBlockConnectable", "MetaBlockConnectable", "MemberOf_MetaBlockReference"] + _many_refs = [] def getStandardControlBlock_MetaBlockConnectable(self): diff --git a/schemata/CIM14/Dynamics/Motors/MechLoad1.py b/schemata/CIM14/Dynamics/Motors/MechLoad1.py index 100ecf2..3b5edb3 100644 --- a/schemata/CIM14/Dynamics/Motors/MechLoad1.py +++ b/schemata/CIM14/Dynamics/Motors/MechLoad1.py @@ -20,8 +20,8 @@ class MechLoad1(MechanicalLoad): """Mechanical load model 1 """ - def __init__(self, e=0.0, b=0.0, d=0.0, a=0.0, **kw_args): - """Initializes a new 'MechLoad1' instance. + def __init__(self, e=0.0, b=0.0, d=0.0, a=0.0, *args, **kw_args): + """Initialises a new 'MechLoad1' instance. @param e: Exponent @param b: Speed squared coefficient @@ -40,5 +40,12 @@ class MechLoad1(MechanicalLoad): #: Speed squared coefficient self.a = a - super(MechLoad1, self).__init__(**kw_args) + super(MechLoad1, self).__init__(*args, **kw_args) + + _attrs = ["e", "b", "d", "a"] + _attr_types = {"e": float, "b": float, "d": float, "a": float} + _defaults = {"e": 0.0, "b": 0.0, "d": 0.0, "a": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Motors/MechanicalLoad.py b/schemata/CIM14/Dynamics/Motors/MechanicalLoad.py index e32a9a6..a685e13 100644 --- a/schemata/CIM14/Dynamics/Motors/MechanicalLoad.py +++ b/schemata/CIM14/Dynamics/Motors/MechanicalLoad.py @@ -20,15 +20,22 @@ class MechanicalLoad(PowerSystemResource): """A mechanical load represents the variation in a motor's shaft torque or power as a function of shaft speed. """ - def __init__(self, rotatingMachine0=None, **kw_args): - """Initializes a new 'MechanicalLoad' instance. + def __init__(self, rotatingMachine0=None, *args, **kw_args): + """Initialises a new 'MechanicalLoad' instance. @param rotatingMachine0: """ self._rotatingMachine0 = [] self.rotatingMachine0 = [] if rotatingMachine0 is None else rotatingMachine0 - super(MechanicalLoad, self).__init__(**kw_args) + super(MechanicalLoad, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["rotatingMachine0"] + _many_refs = ["rotatingMachine0"] def getrotatingMachine0(self): diff --git a/schemata/CIM14/Dynamics/Motors/MotorAsync.py b/schemata/CIM14/Dynamics/Motors/MotorAsync.py index 3a6b7a5..893825a 100644 --- a/schemata/CIM14/Dynamics/Motors/MotorAsync.py +++ b/schemata/CIM14/Dynamics/Motors/MotorAsync.py @@ -20,9 +20,16 @@ class MotorAsync(AsynchronousMachine): """An asynchronous (induction) motor with no external connection to the rotor windings, e.g., a squirrel-cage induction motor. """ - def __init__(self, **kw_args): - """Initializes a new 'MotorAsync' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'MotorAsync' instance. """ - super(MotorAsync, self).__init__(**kw_args) + super(MotorAsync, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/Motors/MotorSync.py b/schemata/CIM14/Dynamics/Motors/MotorSync.py index bb7731c..e0d4f31 100644 --- a/schemata/CIM14/Dynamics/Motors/MotorSync.py +++ b/schemata/CIM14/Dynamics/Motors/MotorSync.py @@ -20,13 +20,20 @@ class MotorSync(SynchronousMachine): """A large industrial motor or group of similar motors. They are represented as generators with negative Pgen in the static (power flow) data. """ - def __init__(self, synchronousMotorType='salientPole', **kw_args): - """Initializes a new 'MotorSync' instance. + def __init__(self, synchronousMotorType="salientPole", *args, **kw_args): + """Initialises a new 'MotorSync' instance. @param synchronousMotorType: The type of synchronous motor, such as round rotor or salient pole. Values are: "salientPole", "roundRotor" """ - #: The type of synchronous motor, such as round rotor or salient pole.Values are: "salientPole", "roundRotor" + #: The type of synchronous motor, such as round rotor or salient pole. Values are: "salientPole", "roundRotor" self.synchronousMotorType = synchronousMotorType - super(MotorSync, self).__init__(**kw_args) + super(MotorSync, self).__init__(*args, **kw_args) + + _attrs = ["synchronousMotorType"] + _attr_types = {"synchronousMotorType": str} + _defaults = {"synchronousMotorType": "salientPole"} + _enums = {"synchronousMotorType": "SynchronousMotorType"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PowerSystemStabilizer.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PowerSystemStabilizer.py index 3fcfafc..8ca9156 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PowerSystemStabilizer.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PowerSystemStabilizer.py @@ -20,9 +20,16 @@ class PowerSystemStabilizer(PowerSystemResource): """A PSS provides an input (Vs) to the excitation system model to improve damping of system oscillations. A variety of input signals may be used depending on the particular design. """ - def __init__(self, **kw_args): - """Initializes a new 'PowerSystemStabilizer' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PowerSystemStabilizer' instance. """ - super(PowerSystemStabilizer, self).__init__(**kw_args) + super(PowerSystemStabilizer, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE1A.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE1A.py index 33c4b98..750065a 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE1A.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE1A.py @@ -20,9 +20,16 @@ class PssIEEE1A(PowerSystemStabilizer): """PSS type IEEE PSS1A """ - def __init__(self, **kw_args): - """Initializes a new 'PssIEEE1A' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssIEEE1A' instance. """ - super(PssIEEE1A, self).__init__(**kw_args) + super(PssIEEE1A, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE2B.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE2B.py index bc99758..bf3bfc7 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE2B.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE2B.py @@ -20,8 +20,8 @@ class PssIEEE2B(PowerSystemStabilizer): """IEEE (2005) PSS2B Model This stabilizer model is designed to represent a variety of dual-input stabilizers, which normally use combinations of power and speed or frequency to derive the stabilizing signal. """ - def __init__(self, t11=0.0, vsi1max=0.0, t3=0.0, tw3=0.0, vstmax=0.0, t2=0.0, n=0, vsi1min=0.0, t9=0.0, ks2=0.0, vstmin=0.0, j1=0, tw1=0.0, tb=0.0, t7=0.0, vsi2max=0.0, t6=0.0, t1=0.0, m=0, vsi2min=0.0, a=0.0, t4=0.0, tw4=0.0, ks4=0.0, ta=0.0, ks3=0.0, t10=0.0, tw2=0.0, j2=0, ks1=0.0, t8=0.0, **kw_args): - """Initializes a new 'PssIEEE2B' instance. + def __init__(self, t11=0.0, vsi1max=0.0, t3=0.0, tw3=0.0, vstmax=0.0, t2=0.0, n=0, vsi1min=0.0, t9=0.0, ks2=0.0, vstmin=0.0, j1=0, tw1=0.0, tb=0.0, t7=0.0, vsi2max=0.0, t6=0.0, t1=0.0, m=0, vsi2min=0.0, a=0.0, t4=0.0, tw4=0.0, ks4=0.0, ta=0.0, ks3=0.0, t10=0.0, tw2=0.0, j2=0, ks1=0.0, t8=0.0, *args, **kw_args): + """Initialises a new 'PssIEEE2B' instance. @param t11: Lead/lag time constant @param vsi1max: Input signal #1 max limit @@ -148,5 +148,12 @@ class PssIEEE2B(PowerSystemStabilizer): #: Lead of ramp tracking filter self.t8 = t8 - super(PssIEEE2B, self).__init__(**kw_args) + super(PssIEEE2B, self).__init__(*args, **kw_args) + + _attrs = ["t11", "vsi1max", "t3", "tw3", "vstmax", "t2", "n", "vsi1min", "t9", "ks2", "vstmin", "j1", "tw1", "tb", "t7", "vsi2max", "t6", "t1", "m", "vsi2min", "a", "t4", "tw4", "ks4", "ta", "ks3", "t10", "tw2", "j2", "ks1", "t8"] + _attr_types = {"t11": float, "vsi1max": float, "t3": float, "tw3": float, "vstmax": float, "t2": float, "n": int, "vsi1min": float, "t9": float, "ks2": float, "vstmin": float, "j1": int, "tw1": float, "tb": float, "t7": float, "vsi2max": float, "t6": float, "t1": float, "m": int, "vsi2min": float, "a": float, "t4": float, "tw4": float, "ks4": float, "ta": float, "ks3": float, "t10": float, "tw2": float, "j2": int, "ks1": float, "t8": float} + _defaults = {"t11": 0.0, "vsi1max": 0.0, "t3": 0.0, "tw3": 0.0, "vstmax": 0.0, "t2": 0.0, "n": 0, "vsi1min": 0.0, "t9": 0.0, "ks2": 0.0, "vstmin": 0.0, "j1": 0, "tw1": 0.0, "tb": 0.0, "t7": 0.0, "vsi2max": 0.0, "t6": 0.0, "t1": 0.0, "m": 0, "vsi2min": 0.0, "a": 0.0, "t4": 0.0, "tw4": 0.0, "ks4": 0.0, "ta": 0.0, "ks3": 0.0, "t10": 0.0, "tw2": 0.0, "j2": 0, "ks1": 0.0, "t8": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE3B.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE3B.py index 0cafc2f..3e0558f 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE3B.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE3B.py @@ -20,9 +20,16 @@ class PssIEEE3B(PowerSystemStabilizer): """PSS type IEEE PSS3B """ - def __init__(self, **kw_args): - """Initializes a new 'PssIEEE3B' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssIEEE3B' instance. """ - super(PssIEEE3B, self).__init__(**kw_args) + super(PssIEEE3B, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE4B.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE4B.py index 1b5bb66..9b1d312 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE4B.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssIEEE4B.py @@ -20,9 +20,16 @@ class PssIEEE4B(PowerSystemStabilizer): """PSS type IEEE PSS4B """ - def __init__(self, **kw_args): - """Initializes a new 'PssIEEE4B' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssIEEE4B' instance. """ - super(PssIEEE4B, self).__init__(**kw_args) + super(PssIEEE4B, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST1.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST1.py index 354afdb..62c66eb 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST1.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST1.py @@ -20,9 +20,16 @@ class PssPTIST1(PowerSystemStabilizer): """PTI microprocessor-based stabilizer model type 1 """ - def __init__(self, **kw_args): - """Initializes a new 'PssPTIST1' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssPTIST1' instance. """ - super(PssPTIST1, self).__init__(**kw_args) + super(PssPTIST1, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST3.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST3.py index 7833f01..953d610 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST3.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssPTIST3.py @@ -20,9 +20,16 @@ class PssPTIST3(PowerSystemStabilizer): """PTI microprocessor-based stabilizer model type 3 """ - def __init__(self, **kw_args): - """Initializes a new 'PssPTIST3' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssPTIST3' instance. """ - super(PssPTIST3, self).__init__(**kw_args) + super(PssPTIST3, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB.py index 6642583..713a0ef 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB.py @@ -20,9 +20,16 @@ class PssSB(PowerSystemStabilizer): """Dual input PSS, pss2a and transient stabilizer """ - def __init__(self, **kw_args): - """Initializes a new 'PssSB' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssSB' instance. """ - super(PssSB, self).__init__(**kw_args) + super(PssSB, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB4.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB4.py index ef9ee5b..0a62ec5 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB4.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSB4.py @@ -20,9 +20,16 @@ class PssSB4(PowerSystemStabilizer): """Power sensitive stabilizer model """ - def __init__(self, **kw_args): - """Initializes a new 'PssSB4' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssSB4' instance. """ - super(PssSB4, self).__init__(**kw_args) + super(PssSB4, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSH.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSH.py index 12ceb58..8ceb0a3 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSH.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSH.py @@ -20,9 +20,16 @@ class PssSH(PowerSystemStabilizer): """Siemens H infinity PSS """ - def __init__(self, **kw_args): - """Initializes a new 'PssSH' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssSH' instance. """ - super(PssSH, self).__init__(**kw_args) + super(PssSH, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSK.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSK.py index f844d90..b998b4a 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSK.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssSK.py @@ -20,9 +20,16 @@ class PssSK(PowerSystemStabilizer): """PSS Slovakian type – three inputs """ - def __init__(self, **kw_args): - """Initializes a new 'PssSK' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssSK' instance. """ - super(PssSK, self).__init__(**kw_args) + super(PssSK, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssWSCC.py b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssWSCC.py index 4615da6..0504e1f 100644 --- a/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssWSCC.py +++ b/schemata/CIM14/Dynamics/PowerSystemStabilizers/PssWSCC.py @@ -20,9 +20,16 @@ class PssWSCC(PowerSystemStabilizer): """Dual input PSS """ - def __init__(self, **kw_args): - """Initializes a new 'PssWSCC' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'PssWSCC' instance. """ - super(PssWSCC, self).__init__(**kw_args) + super(PssWSCC, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/ProtectiveDevice.py b/schemata/CIM14/Dynamics/ProtectiveDevice.py index 3c61429..7c39a49 100644 --- a/schemata/CIM14/Dynamics/ProtectiveDevice.py +++ b/schemata/CIM14/Dynamics/ProtectiveDevice.py @@ -18,9 +18,16 @@ from CIM14.Element import Element class ProtectiveDevice(Element): - def __init__(self, **kw_args): - """Initializes a new 'ProtectiveDevice' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ProtectiveDevice' instance. """ - super(ProtectiveDevice, self).__init__(**kw_args) + super(ProtectiveDevice, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/RotatingMachine.py b/schemata/CIM14/Dynamics/RotatingMachine.py index 6c61b3b..ee5a808 100644 --- a/schemata/CIM14/Dynamics/RotatingMachine.py +++ b/schemata/CIM14/Dynamics/RotatingMachine.py @@ -20,8 +20,8 @@ class RotatingMachine(RegulatingCondEq): """A rotating machine which may be used as a generator or motor. """ - def __init__(self, parametersFormType='timeConstantReactance', d=0.0, rs=0.0, h=0.0, s12=0.0, ratedS=0.0, s1=0.0, xls=0.0, mechanicalLoad0=None, **kw_args): - """Initializes a new 'RotatingMachine' instance. + def __init__(self, parametersFormType="timeConstantReactance", d=0.0, rs=0.0, h=0.0, s12=0.0, ratedS=0.0, s1=0.0, xls=0.0, mechanicalLoad0=None, *args, **kw_args): + """Initialises a new 'RotatingMachine' instance. @param parametersFormType: Values are: "timeConstantReactance", "equivalentCircuit" @param d: Damping torque coefficient. D represents a linearized approximation of damping torque effects. This value is often zero when the sources of damping torques (generator damper windings, load damping effects, etc.) are modeled in detail @@ -60,7 +60,14 @@ class RotatingMachine(RegulatingCondEq): self._mechanicalLoad0 = [] self.mechanicalLoad0 = [] if mechanicalLoad0 is None else mechanicalLoad0 - super(RotatingMachine, self).__init__(**kw_args) + super(RotatingMachine, self).__init__(*args, **kw_args) + + _attrs = ["parametersFormType", "d", "rs", "h", "s12", "ratedS", "s1", "xls"] + _attr_types = {"parametersFormType": str, "d": float, "rs": float, "h": float, "s12": float, "ratedS": float, "s1": float, "xls": float} + _defaults = {"parametersFormType": "timeConstantReactance", "d": 0.0, "rs": 0.0, "h": 0.0, "s12": 0.0, "ratedS": 0.0, "s1": 0.0, "xls": 0.0} + _enums = {"parametersFormType": "ParametersFormType"} + _refs = ["mechanicalLoad0"] + _many_refs = ["mechanicalLoad0"] def getmechanicalLoad0(self): diff --git a/schemata/CIM14/Dynamics/Slot.py b/schemata/CIM14/Dynamics/Slot.py index 7ba7664..dafe775 100644 --- a/schemata/CIM14/Dynamics/Slot.py +++ b/schemata/CIM14/Dynamics/Slot.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class Slot(IdentifiedObject): - def __init__(self, blockType0=None, slotReference0=None, slotOutput0=None, connectionFrame0=None, slotInput0=None, **kw_args): - """Initializes a new 'Slot' instance. + def __init__(self, blockType0=None, slotReference0=None, slotOutput0=None, connectionFrame0=None, slotInput0=None, *args, **kw_args): + """Initialises a new 'Slot' instance. @param blockType0: @param slotReference0: @@ -42,7 +42,14 @@ class Slot(IdentifiedObject): self._slotInput0 = [] self.slotInput0 = [] if slotInput0 is None else slotInput0 - super(Slot, self).__init__(**kw_args) + super(Slot, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["blockType0", "slotReference0", "slotOutput0", "connectionFrame0", "slotInput0"] + _many_refs = ["slotReference0", "slotOutput0", "slotInput0"] def getblockType0(self): diff --git a/schemata/CIM14/Dynamics/SlotConnection.py b/schemata/CIM14/Dynamics/SlotConnection.py index 1aa4179..0534fc9 100644 --- a/schemata/CIM14/Dynamics/SlotConnection.py +++ b/schemata/CIM14/Dynamics/SlotConnection.py @@ -20,8 +20,8 @@ class SlotConnection(IdentifiedObject): """Standard connectivity if not specified at the instance level.. """ - def __init__(self, connectionFrame0=None, slotInput0=None, slotOutput0=None, **kw_args): - """Initializes a new 'SlotConnection' instance. + def __init__(self, connectionFrame0=None, slotInput0=None, slotOutput0=None, *args, **kw_args): + """Initialises a new 'SlotConnection' instance. @param connectionFrame0: @param slotInput0: @@ -36,7 +36,14 @@ class SlotConnection(IdentifiedObject): self._slotOutput0 = None self.slotOutput0 = slotOutput0 - super(SlotConnection, self).__init__(**kw_args) + super(SlotConnection, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["connectionFrame0", "slotInput0", "slotOutput0"] + _many_refs = [] def getconnectionFrame0(self): diff --git a/schemata/CIM14/Dynamics/SlotInput.py b/schemata/CIM14/Dynamics/SlotInput.py index 0d14c8d..9d45279 100644 --- a/schemata/CIM14/Dynamics/SlotInput.py +++ b/schemata/CIM14/Dynamics/SlotInput.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class SlotInput(IdentifiedObject): - def __init__(self, blockInputType0=None, slotConnection0=None, slot0=None, **kw_args): - """Initializes a new 'SlotInput' instance. + def __init__(self, blockInputType0=None, slotConnection0=None, slot0=None, *args, **kw_args): + """Initialises a new 'SlotInput' instance. @param blockInputType0: @param slotConnection0: @@ -34,7 +34,14 @@ class SlotInput(IdentifiedObject): self._slot0 = None self.slot0 = slot0 - super(SlotInput, self).__init__(**kw_args) + super(SlotInput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["blockInputType0", "slotConnection0", "slot0"] + _many_refs = [] def getblockInputType0(self): diff --git a/schemata/CIM14/Dynamics/SlotOutput.py b/schemata/CIM14/Dynamics/SlotOutput.py index 489df17..67ccc2c 100644 --- a/schemata/CIM14/Dynamics/SlotOutput.py +++ b/schemata/CIM14/Dynamics/SlotOutput.py @@ -18,8 +18,8 @@ from CIM14.IEC61970.Core.IdentifiedObject import IdentifiedObject class SlotOutput(IdentifiedObject): - def __init__(self, slot0=None, slotConnection0=None, blockOutputType0=None, **kw_args): - """Initializes a new 'SlotOutput' instance. + def __init__(self, slot0=None, slotConnection0=None, blockOutputType0=None, *args, **kw_args): + """Initialises a new 'SlotOutput' instance. @param slot0: @param slotConnection0: @@ -34,7 +34,14 @@ class SlotOutput(IdentifiedObject): self._blockOutputType0 = None self.blockOutputType0 = blockOutputType0 - super(SlotOutput, self).__init__(**kw_args) + super(SlotOutput, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slot0", "slotConnection0", "blockOutputType0"] + _many_refs = ["slotConnection0"] def getslot0(self): diff --git a/schemata/CIM14/Dynamics/SlotReference.py b/schemata/CIM14/Dynamics/SlotReference.py index 145d3fb..234c0e2 100644 --- a/schemata/CIM14/Dynamics/SlotReference.py +++ b/schemata/CIM14/Dynamics/SlotReference.py @@ -20,8 +20,8 @@ class SlotReference(IdentifiedObject): """The specific role the block usage is playing in a connection frame. This allows connections to be established at the meta dynamics level and not at the instance level. """ - def __init__(self, slot0=None, block0=None, compositeModel0=None, **kw_args): - """Initializes a new 'SlotReference' instance. + def __init__(self, slot0=None, block0=None, compositeModel0=None, *args, **kw_args): + """Initialises a new 'SlotReference' instance. @param slot0: @param block0: @@ -36,7 +36,14 @@ class SlotReference(IdentifiedObject): self._compositeModel0 = [] self.compositeModel0 = [] if compositeModel0 is None else compositeModel0 - super(SlotReference, self).__init__(**kw_args) + super(SlotReference, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["slot0", "block0", "compositeModel0"] + _many_refs = ["block0", "compositeModel0"] def getslot0(self): diff --git a/schemata/CIM14/Dynamics/SourceModels.py b/schemata/CIM14/Dynamics/SourceModels.py index db93e59..34f469e 100644 --- a/schemata/CIM14/Dynamics/SourceModels.py +++ b/schemata/CIM14/Dynamics/SourceModels.py @@ -18,9 +18,16 @@ from CIM14.Element import Element class SourceModels(Element): - def __init__(self, **kw_args): - """Initializes a new 'SourceModels' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'SourceModels' instance. """ - super(SourceModels, self).__init__(**kw_args) + super(SourceModels, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/StaticVarDevice.py b/schemata/CIM14/Dynamics/StaticVarDevice.py index 42359c4..e874f0d 100644 --- a/schemata/CIM14/Dynamics/StaticVarDevice.py +++ b/schemata/CIM14/Dynamics/StaticVarDevice.py @@ -18,9 +18,16 @@ from CIM14.Element import Element class StaticVarDevice(Element): - def __init__(self, **kw_args): - """Initializes a new 'StaticVarDevice' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'StaticVarDevice' instance. """ - super(StaticVarDevice, self).__init__(**kw_args) + super(StaticVarDevice, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TieToMeasurement.py b/schemata/CIM14/Dynamics/TieToMeasurement.py index f276bc9..2297b2a 100644 --- a/schemata/CIM14/Dynamics/TieToMeasurement.py +++ b/schemata/CIM14/Dynamics/TieToMeasurement.py @@ -20,8 +20,8 @@ class TieToMeasurement(IdentifiedObject): """Ties a block input to a specific state variable measurment. Thus giving a unit type, a location in the network (typically a terminal). A specific value is not given, just enough information to obtain the value from the model during a solution. This has nothing to do with SCADA. """ - def __init__(self, measurement0=None, block0=None, metaBlockInput0=None, **kw_args): - """Initializes a new 'TieToMeasurement' instance. + def __init__(self, measurement0=None, block0=None, metaBlockInput0=None, *args, **kw_args): + """Initialises a new 'TieToMeasurement' instance. @param measurement0: @param block0: @@ -36,7 +36,14 @@ class TieToMeasurement(IdentifiedObject): self._metaBlockInput0 = None self.metaBlockInput0 = metaBlockInput0 - super(TieToMeasurement, self).__init__(**kw_args) + super(TieToMeasurement, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["measurement0", "block0", "metaBlockInput0"] + _many_refs = [] def getmeasurement0(self): diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/Class1.py b/schemata/CIM14/Dynamics/TurbineGovernors/Class1.py index 36d664f..0ad3016 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/Class1.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/Class1.py @@ -18,9 +18,16 @@ from CIM14.Element import Element class Class1(Element): - def __init__(self, **kw_args): - """Initializes a new 'Class1' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Class1' instance. """ - super(Class1, self).__init__(**kw_args) + super(Class1, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovCT1.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovCT1.py index b1b6c2d..4ae0220 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovCT1.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovCT1.py @@ -20,8 +20,8 @@ class GovCT1(TurbineGovernor): """General model for any prime mover with a PID governor, used primarily for combustion turbine and combined cycle units. """ - def __init__(self, tdgov=0.0, tb=0.0, kdgov=0.0, db=0.0, vmin=0.0, kturb=0.0, teng=0.0, minerr=0.0, aset=0.0, maxerr=0.0, tsa=0.0, mwbase=0.0, wfspd=False, kiload=0.0, kpgov=0.0, ldref=0.0, vmax=0.0, rup=0.0, r=0.0, tpelec=0.0, ta=0.0, ropen=0.0, kimw=0.0, ka=0.0, rdown=0.0, rclose=0.0, dm=0.0, tsb=0.0, kigov=0.0, kpload=0.0, tfload=0.0, tact=0.0, tc=0.0, wfnl=0.0, pmwset=0.0, rselect=False, **kw_args): - """Initializes a new 'GovCT1' instance. + def __init__(self, tdgov=0.0, tb=0.0, kdgov=0.0, db=0.0, vmin=0.0, kturb=0.0, teng=0.0, minerr=0.0, aset=0.0, maxerr=0.0, tsa=0.0, mwbase=0.0, wfspd=False, kiload=0.0, kpgov=0.0, ldref=0.0, vmax=0.0, rup=0.0, r=0.0, tpelec=0.0, ta=0.0, ropen=0.0, kimw=0.0, ka=0.0, rdown=0.0, rclose=0.0, dm=0.0, tsb=0.0, kigov=0.0, kpload=0.0, tfload=0.0, tact=0.0, tc=0.0, wfnl=0.0, pmwset=0.0, rselect=False, *args, **kw_args): + """Initialises a new 'GovCT1' instance. @param tdgov: Governor derivative controller time constant @param tb: Turbine lag time constant, sec. (>0.) @@ -168,5 +168,12 @@ class GovCT1(TurbineGovernor): #: Feedback signal for droop = 1 electrical power = 0 none (isochronous governor) = -1 fuel valve stroke ( true stroke) = -2 governor output ( requested stroke) self.rselect = rselect - super(GovCT1, self).__init__(**kw_args) + super(GovCT1, self).__init__(*args, **kw_args) + + _attrs = ["tdgov", "tb", "kdgov", "db", "vmin", "kturb", "teng", "minerr", "aset", "maxerr", "tsa", "mwbase", "wfspd", "kiload", "kpgov", "ldref", "vmax", "rup", "r", "tpelec", "ta", "ropen", "kimw", "ka", "rdown", "rclose", "dm", "tsb", "kigov", "kpload", "tfload", "tact", "tc", "wfnl", "pmwset", "rselect"] + _attr_types = {"tdgov": float, "tb": float, "kdgov": float, "db": float, "vmin": float, "kturb": float, "teng": float, "minerr": float, "aset": float, "maxerr": float, "tsa": float, "mwbase": float, "wfspd": bool, "kiload": float, "kpgov": float, "ldref": float, "vmax": float, "rup": float, "r": float, "tpelec": float, "ta": float, "ropen": float, "kimw": float, "ka": float, "rdown": float, "rclose": float, "dm": float, "tsb": float, "kigov": float, "kpload": float, "tfload": float, "tact": float, "tc": float, "wfnl": float, "pmwset": float, "rselect": bool} + _defaults = {"tdgov": 0.0, "tb": 0.0, "kdgov": 0.0, "db": 0.0, "vmin": 0.0, "kturb": 0.0, "teng": 0.0, "minerr": 0.0, "aset": 0.0, "maxerr": 0.0, "tsa": 0.0, "mwbase": 0.0, "wfspd": False, "kiload": 0.0, "kpgov": 0.0, "ldref": 0.0, "vmax": 0.0, "rup": 0.0, "r": 0.0, "tpelec": 0.0, "ta": 0.0, "ropen": 0.0, "kimw": 0.0, "ka": 0.0, "rdown": 0.0, "rclose": 0.0, "dm": 0.0, "tsb": 0.0, "kigov": 0.0, "kpload": 0.0, "tfload": 0.0, "tact": 0.0, "tc": 0.0, "wfnl": 0.0, "pmwset": 0.0, "rselect": False} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovCT2.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovCT2.py index 155d4f4..1f42bed 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovCT2.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovCT2.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovCT2(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovCT2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovCT2' instance. """ - super(GovCT2, self).__init__(**kw_args) + super(GovCT2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovDUM.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovDUM.py index c3393f7..85b6d21 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovDUM.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovDUM.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovDUM(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovDUM' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovDUM' instance. """ - super(GovDUM, self).__init__(**kw_args) + super(GovDUM, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovGASM.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovGASM.py index 59665a5..4c5a82e 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovGASM.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovGASM.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovGASM(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovGASM' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovGASM' instance. """ - super(GovGASM, self).__init__(**kw_args) + super(GovGASM, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST.py index 2ca6cd4..a8cef61 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovGAST(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovGAST' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovGAST' instance. """ - super(GovGAST, self).__init__(**kw_args) + super(GovGAST, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST2.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST2.py index 91d5c7e..555c49d 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST2.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovGAST2.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovGAST2(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovGAST2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovGAST2' instance. """ - super(GovGAST2, self).__init__(**kw_args) + super(GovGAST2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovGASTWD.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovGASTWD.py index ca69f04..29e4678 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovGASTWD.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovGASTWD.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovGASTWD(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovGASTWD' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovGASTWD' instance. """ - super(GovGASTWD, self).__init__(**kw_args) + super(GovGASTWD, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro0.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro0.py index 9ad0015..8426432 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro0.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro0.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydro0(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydro0' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydro0' instance. """ - super(GovHydro0, self).__init__(**kw_args) + super(GovHydro0, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro1.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro1.py index 5e38914..711d5f1 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro1.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro1.py @@ -20,8 +20,8 @@ class GovHydro1(TurbineGovernor): """Hydro turbine-governor model. """ - def __init__(self, tf=0.0, velm=0.0, mwbase=0.0, gmin=0.0, gmax=0.0, rperm=0.0, tr=0.0, rtemp=0.0, qnl=0.0, tg=0.0, dturb=0.0, at=0.0, tw=0.0, HydroTurbine=None, synchronousMachine0=None, **kw_args): - """Initializes a new 'GovHydro1' instance. + def __init__(self, tf=0.0, velm=0.0, mwbase=0.0, gmin=0.0, gmax=0.0, rperm=0.0, tr=0.0, rtemp=0.0, qnl=0.0, tg=0.0, dturb=0.0, at=0.0, tw=0.0, HydroTurbine=None, synchronousMachine0=None, *args, **kw_args): + """Initialises a new 'GovHydro1' instance. @param tf: Filter time constant (>0) @param velm: Maximum gate velocity (>0) @@ -84,7 +84,14 @@ class GovHydro1(TurbineGovernor): self._synchronousMachine0 = [] self.synchronousMachine0 = [] if synchronousMachine0 is None else synchronousMachine0 - super(GovHydro1, self).__init__(**kw_args) + super(GovHydro1, self).__init__(*args, **kw_args) + + _attrs = ["tf", "velm", "mwbase", "gmin", "gmax", "rperm", "tr", "rtemp", "qnl", "tg", "dturb", "at", "tw"] + _attr_types = {"tf": float, "velm": float, "mwbase": float, "gmin": float, "gmax": float, "rperm": float, "tr": float, "rtemp": float, "qnl": float, "tg": float, "dturb": float, "at": float, "tw": float} + _defaults = {"tf": 0.0, "velm": 0.0, "mwbase": 0.0, "gmin": 0.0, "gmax": 0.0, "rperm": 0.0, "tr": 0.0, "rtemp": 0.0, "qnl": 0.0, "tg": 0.0, "dturb": 0.0, "at": 0.0, "tw": 0.0} + _enums = {} + _refs = ["HydroTurbine", "synchronousMachine0"] + _many_refs = ["synchronousMachine0"] def getHydroTurbine(self): diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro2.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro2.py index be17a29..44b5d85 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro2.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro2.py @@ -18,8 +18,8 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydro2(TurbineGovernor): - def __init__(self, tg=0.0, uc=0.0, gv1=0.0, db1=0.0, pmax=0.0, pgv4=0.0, gv5=0.0, uo=0.0, rperm=0.0, db2=0.0, pgv5=0.0, tw=0.0, pgv2=0.0, gv3=0.0, gv2=0.0, rtemp=0.0, mwbase=0.0, aturb=0.0, kturb=0.0, pgv3=0.0, pmin=0.0, tr=0.0, eps=0.0, gv6=0.0, pgv1=0.0, tp=0.0, pgv6=0.0, gv4=0.0, bturb=0.0, **kw_args): - """Initializes a new 'GovHydro2' instance. + def __init__(self, tg=0.0, uc=0.0, gv1=0.0, db1=0.0, pmax=0.0, pgv4=0.0, gv5=0.0, uo=0.0, rperm=0.0, db2=0.0, pgv5=0.0, tw=0.0, pgv2=0.0, gv3=0.0, gv2=0.0, rtemp=0.0, mwbase=0.0, aturb=0.0, kturb=0.0, pgv3=0.0, pmin=0.0, tr=0.0, eps=0.0, gv6=0.0, pgv1=0.0, tp=0.0, pgv6=0.0, gv4=0.0, bturb=0.0, *args, **kw_args): + """Initialises a new 'GovHydro2' instance. @param tg: Gate servo time constant @param uc: Maximum gate closing velocity (<0.) @@ -138,5 +138,12 @@ class GovHydro2(TurbineGovernor): #: Turbine denominator multiplier self.bturb = bturb - super(GovHydro2, self).__init__(**kw_args) + super(GovHydro2, self).__init__(*args, **kw_args) + + _attrs = ["tg", "uc", "gv1", "db1", "pmax", "pgv4", "gv5", "uo", "rperm", "db2", "pgv5", "tw", "pgv2", "gv3", "gv2", "rtemp", "mwbase", "aturb", "kturb", "pgv3", "pmin", "tr", "eps", "gv6", "pgv1", "tp", "pgv6", "gv4", "bturb"] + _attr_types = {"tg": float, "uc": float, "gv1": float, "db1": float, "pmax": float, "pgv4": float, "gv5": float, "uo": float, "rperm": float, "db2": float, "pgv5": float, "tw": float, "pgv2": float, "gv3": float, "gv2": float, "rtemp": float, "mwbase": float, "aturb": float, "kturb": float, "pgv3": float, "pmin": float, "tr": float, "eps": float, "gv6": float, "pgv1": float, "tp": float, "pgv6": float, "gv4": float, "bturb": float} + _defaults = {"tg": 0.0, "uc": 0.0, "gv1": 0.0, "db1": 0.0, "pmax": 0.0, "pgv4": 0.0, "gv5": 0.0, "uo": 0.0, "rperm": 0.0, "db2": 0.0, "pgv5": 0.0, "tw": 0.0, "pgv2": 0.0, "gv3": 0.0, "gv2": 0.0, "rtemp": 0.0, "mwbase": 0.0, "aturb": 0.0, "kturb": 0.0, "pgv3": 0.0, "pmin": 0.0, "tr": 0.0, "eps": 0.0, "gv6": 0.0, "pgv1": 0.0, "tp": 0.0, "pgv6": 0.0, "gv4": 0.0, "bturb": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro3.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro3.py index b032bf0..d5fdbbc 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro3.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro3.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydro3(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydro3' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydro3' instance. """ - super(GovHydro3, self).__init__(**kw_args) + super(GovHydro3, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro4.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro4.py index e9ed12a..b10406c 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro4.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydro4.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydro4(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydro4' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydro4' instance. """ - super(GovHydro4, self).__init__(**kw_args) + super(GovHydro4, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroDD.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroDD.py index a83bb08..a574cfe 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroDD.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroDD.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroDD(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroDD' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroDD' instance. """ - super(GovHydroDD, self).__init__(**kw_args) + super(GovHydroDD, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID.py index afbbd07..94e9df8 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroPID(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroPID' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroPID' instance. """ - super(GovHydroPID, self).__init__(**kw_args) + super(GovHydroPID, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID2.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID2.py index 64b9d28..8d2e253 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID2.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroPID2.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroPID2(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroPID2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroPID2' instance. """ - super(GovHydroPID2, self).__init__(**kw_args) + super(GovHydroPID2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroR.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroR.py index 54d4c2a..61ec0d0 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroR.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroR.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroR(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroR' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroR' instance. """ - super(GovHydroR, self).__init__(**kw_args) + super(GovHydroR, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWEH.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWEH.py index cbb4f68..31a95a0 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWEH.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWEH.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroWEH(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroWEH' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroWEH' instance. """ - super(GovHydroWEH, self).__init__(**kw_args) + super(GovHydroWEH, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWPID.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWPID.py index 8893126..ebf748d 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWPID.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovHydroWPID.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovHydroWPID(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovHydroWPID' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovHydroWPID' instance. """ - super(GovHydroWPID, self).__init__(**kw_args) + super(GovHydroWPID, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovRAV.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovRAV.py index ccddfde..738c3fb 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovRAV.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovRAV.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovRAV(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovRAV' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovRAV' instance. """ - super(GovRAV, self).__init__(**kw_args) + super(GovRAV, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam0.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam0.py index 9071450..c9a982a 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam0.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam0.py @@ -20,8 +20,8 @@ class GovSteam0(TurbineGovernor): """A simplified steam turbine-governor model. """ - def __init__(self, t2=0.0, t1=0.0, vmin=0.0, dt=0.0, vmax=0.0, mwbase=0.0, r=0.0, t3=0.0, **kw_args): - """Initializes a new 'GovSteam0' instance. + def __init__(self, t2=0.0, t1=0.0, vmin=0.0, dt=0.0, vmax=0.0, mwbase=0.0, r=0.0, t3=0.0, *args, **kw_args): + """Initialises a new 'GovSteam0' instance. @param t2: Numerator time constant of T2/T3 block @param t1: Steam bowl time constant @@ -56,5 +56,12 @@ class GovSteam0(TurbineGovernor): #: Reheater time constant self.t3 = t3 - super(GovSteam0, self).__init__(**kw_args) + super(GovSteam0, self).__init__(*args, **kw_args) + + _attrs = ["t2", "t1", "vmin", "dt", "vmax", "mwbase", "r", "t3"] + _attr_types = {"t2": float, "t1": float, "vmin": float, "dt": float, "vmax": float, "mwbase": float, "r": float, "t3": float} + _defaults = {"t2": 0.0, "t1": 0.0, "vmin": 0.0, "dt": 0.0, "vmax": 0.0, "mwbase": 0.0, "r": 0.0, "t3": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam1.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam1.py index fe55928..34798ff 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam1.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteam1.py @@ -20,8 +20,8 @@ class GovSteam1(TurbineGovernor): """IEEE steam turbine/governor model (with optional deadband and nonlinear valve gain added) """ - def __init__(self, gv1=0.0, pgv3=0.0, uo=0.0, k1=0.0, mwbase=0.0, k8=0.0, uc=0.0, gv5=0.0, k7=0.0, gv4=0.0, k=0.0, gv2=0.0, db2=0.0, pgv4=0.0, t6=0.0, k2=0.0, db1=0.0, t5=0.0, k5=0.0, pgv2=0.0, pgv1=0.0, t3=0.0, t1=0.0, k6=0.0, gv3=0.0, eps=0.0, gv6=0.0, t4=0.0, pgv6=0.0, pmin=0.0, k4=0.0, pgv5=0.0, pmax=0.0, t7=0.0, k3=0.0, t2=0.0, **kw_args): - """Initializes a new 'GovSteam1' instance. + def __init__(self, gv1=0.0, pgv3=0.0, uo=0.0, k1=0.0, mwbase=0.0, k8=0.0, uc=0.0, gv5=0.0, k7=0.0, gv4=0.0, k=0.0, gv2=0.0, db2=0.0, pgv4=0.0, t6=0.0, k2=0.0, db1=0.0, t5=0.0, k5=0.0, pgv2=0.0, pgv1=0.0, t3=0.0, t1=0.0, k6=0.0, gv3=0.0, eps=0.0, gv6=0.0, t4=0.0, pgv6=0.0, pmin=0.0, k4=0.0, pgv5=0.0, pmax=0.0, t7=0.0, k3=0.0, t2=0.0, *args, **kw_args): + """Initialises a new 'GovSteam1' instance. @param gv1: Nonlinear gain valve position point 1 @param pgv3: Nonlinear gain power value point 3 @@ -168,5 +168,12 @@ class GovSteam1(TurbineGovernor): #: Governor lead time constant self.t2 = t2 - super(GovSteam1, self).__init__(**kw_args) + super(GovSteam1, self).__init__(*args, **kw_args) + + _attrs = ["gv1", "pgv3", "uo", "k1", "mwbase", "k8", "uc", "gv5", "k7", "gv4", "k", "gv2", "db2", "pgv4", "t6", "k2", "db1", "t5", "k5", "pgv2", "pgv1", "t3", "t1", "k6", "gv3", "eps", "gv6", "t4", "pgv6", "pmin", "k4", "pgv5", "pmax", "t7", "k3", "t2"] + _attr_types = {"gv1": float, "pgv3": float, "uo": float, "k1": float, "mwbase": float, "k8": float, "uc": float, "gv5": float, "k7": float, "gv4": float, "k": float, "gv2": float, "db2": float, "pgv4": float, "t6": float, "k2": float, "db1": float, "t5": float, "k5": float, "pgv2": float, "pgv1": float, "t3": float, "t1": float, "k6": float, "gv3": float, "eps": float, "gv6": float, "t4": float, "pgv6": float, "pmin": float, "k4": float, "pgv5": float, "pmax": float, "t7": float, "k3": float, "t2": float} + _defaults = {"gv1": 0.0, "pgv3": 0.0, "uo": 0.0, "k1": 0.0, "mwbase": 0.0, "k8": 0.0, "uc": 0.0, "gv5": 0.0, "k7": 0.0, "gv4": 0.0, "k": 0.0, "gv2": 0.0, "db2": 0.0, "pgv4": 0.0, "t6": 0.0, "k2": 0.0, "db1": 0.0, "t5": 0.0, "k5": 0.0, "pgv2": 0.0, "pgv1": 0.0, "t3": 0.0, "t1": 0.0, "k6": 0.0, "gv3": 0.0, "eps": 0.0, "gv6": 0.0, "t4": 0.0, "pgv6": 0.0, "pmin": 0.0, "k4": 0.0, "pgv5": 0.0, "pmax": 0.0, "t7": 0.0, "k3": 0.0, "t2": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamCC.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamCC.py index b0a7c36..84da55a 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamCC.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamCC.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovSteamCC(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovSteamCC' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovSteamCC' instance. """ - super(GovSteamCC, self).__init__(**kw_args) + super(GovSteamCC, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamEU.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamEU.py index 7bbbb64..cabde96 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamEU.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamEU.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovSteamEU(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovSteamEU' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovSteamEU' instance. """ - super(GovSteamEU, self).__init__(**kw_args) + super(GovSteamEU, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV2.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV2.py index d8d5adb..a110c1d 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV2.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV2.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovSteamFV2(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovSteamFV2' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovSteamFV2' instance. """ - super(GovSteamFV2, self).__init__(**kw_args) + super(GovSteamFV2, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV3.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV3.py index ecaedfa..d6d48b5 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV3.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamFV3.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovSteamFV3(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovSteamFV3' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovSteamFV3' instance. """ - super(GovSteamFV3, self).__init__(**kw_args) + super(GovSteamFV3, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamSGO.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamSGO.py index 11ad4b1..9f99e93 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamSGO.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovSteamSGO.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovSteamSGO(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovSteamSGO' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovSteamSGO' instance. """ - super(GovSteamSGO, self).__init__(**kw_args) + super(GovSteamSGO, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1P.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1P.py index c6b3593..653709f 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1P.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1P.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT1P(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT1P' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT1P' instance. """ - super(GovWT1P, self).__init__(**kw_args) + super(GovWT1P, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1T.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1T.py index b7129f3..20195b1 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1T.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT1T.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT1T(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT1T' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT1T' instance. """ - super(GovWT1T, self).__init__(**kw_args) + super(GovWT1T, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2P.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2P.py index 0e9476d..4053f35 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2P.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2P.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT2P(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT2P' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT2P' instance. """ - super(GovWT2P, self).__init__(**kw_args) + super(GovWT2P, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2T.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2T.py index ba2b664..1211f39 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2T.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT2T.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT2T(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT2T' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT2T' instance. """ - super(GovWT2T, self).__init__(**kw_args) + super(GovWT2T, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3P.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3P.py index 99f760d..c9aa4a0 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3P.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3P.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT3P(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT3P' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT3P' instance. """ - super(GovWT3P, self).__init__(**kw_args) + super(GovWT3P, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3T.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3T.py index 0f8e89b..234538f 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3T.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT3T.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT3T(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT3T' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT3T' instance. """ - super(GovWT3T, self).__init__(**kw_args) + super(GovWT3T, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4P.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4P.py index 7c6dd6b..067fc28 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4P.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4P.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT4P(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT4P' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT4P' instance. """ - super(GovWT4P, self).__init__(**kw_args) + super(GovWT4P, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4T.py b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4T.py index a61c93a..8755fd4 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4T.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/GovWT4T.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class GovWT4T(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'GovWT4T' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GovWT4T' instance. """ - super(GovWT4T, self).__init__(**kw_args) + super(GovWT4T, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/TLCFB1.py b/schemata/CIM14/Dynamics/TurbineGovernors/TLCFB1.py index 45bbd85..c4b3e88 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/TLCFB1.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/TLCFB1.py @@ -18,9 +18,16 @@ from CIM14.Dynamics.TurbineGovernors.TurbineGovernor import TurbineGovernor class TLCFB1(TurbineGovernor): - def __init__(self, **kw_args): - """Initializes a new 'TLCFB1' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'TLCFB1' instance. """ - super(TLCFB1, self).__init__(**kw_args) + super(TLCFB1, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/TurbineGovernors/TurbineGovernor.py b/schemata/CIM14/Dynamics/TurbineGovernors/TurbineGovernor.py index e77ee31..6295ec1 100644 --- a/schemata/CIM14/Dynamics/TurbineGovernors/TurbineGovernor.py +++ b/schemata/CIM14/Dynamics/TurbineGovernors/TurbineGovernor.py @@ -20,9 +20,16 @@ class TurbineGovernor(PowerSystemResource): """The turbine-governor determines the mechanical power (Pm) supplied to the generator model """ - def __init__(self, **kw_args): - """Initializes a new 'TurbineGovernor' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'TurbineGovernor' instance. """ - super(TurbineGovernor, self).__init__(**kw_args) + super(TurbineGovernor, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/UserBlockParameter.py b/schemata/CIM14/Dynamics/UserBlockParameter.py index bef7296..ef3eae6 100644 --- a/schemata/CIM14/Dynamics/UserBlockParameter.py +++ b/schemata/CIM14/Dynamics/UserBlockParameter.py @@ -20,15 +20,22 @@ class UserBlockParameter(MetaBlockParameter): """Concrete class intended to obtain a parameter value from a user of the block in the parameter list at the instance level. """ - def __init__(self, BlockUsageParameter=None, **kw_args): - """Initializes a new 'UserBlockParameter' instance. + def __init__(self, BlockUsageParameter=None, *args, **kw_args): + """Initialises a new 'UserBlockParameter' instance. @param BlockUsageParameter: """ self._BlockUsageParameter = [] self.BlockUsageParameter = [] if BlockUsageParameter is None else BlockUsageParameter - super(UserBlockParameter, self).__init__(**kw_args) + super(UserBlockParameter, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["BlockUsageParameter"] + _many_refs = ["BlockUsageParameter"] def getBlockUsageParameter(self): diff --git a/schemata/CIM14/Dynamics/VoltageCompensator/VcompCross.py b/schemata/CIM14/Dynamics/VoltageCompensator/VcompCross.py index 40a22f4..cdc4862 100644 --- a/schemata/CIM14/Dynamics/VoltageCompensator/VcompCross.py +++ b/schemata/CIM14/Dynamics/VoltageCompensator/VcompCross.py @@ -20,8 +20,8 @@ class VcompCross(VoltageCompensator): """Voltage Compensation Model for Cross-Compound Generating Unit """ - def __init__(self, xcomp2=0.0, rcomp2=0.0, **kw_args): - """Initializes a new 'VcompCross' instance. + def __init__(self, xcomp2=0.0, rcomp2=0.0, *args, **kw_args): + """Initialises a new 'VcompCross' instance. @param xcomp2: Cross-Compensating (compounding) reactance @param rcomp2: Cross-Compensating (compounding) resistance @@ -32,5 +32,12 @@ class VcompCross(VoltageCompensator): #: Cross-Compensating (compounding) resistance self.rcomp2 = rcomp2 - super(VcompCross, self).__init__(**kw_args) + super(VcompCross, self).__init__(*args, **kw_args) + + _attrs = ["xcomp2", "rcomp2"] + _attr_types = {"xcomp2": float, "rcomp2": float} + _defaults = {"xcomp2": 0.0, "rcomp2": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/VoltageCompensator/VcompIEEE.py b/schemata/CIM14/Dynamics/VoltageCompensator/VcompIEEE.py index 0ed4dc1..fc3babd 100644 --- a/schemata/CIM14/Dynamics/VoltageCompensator/VcompIEEE.py +++ b/schemata/CIM14/Dynamics/VoltageCompensator/VcompIEEE.py @@ -20,8 +20,8 @@ class VcompIEEE(VoltageCompensator): """IEEE Voltage Compensation Model """ - def __init__(self, xcomp=0.0, rcomp=0.0, **kw_args): - """Initializes a new 'VcompIEEE' instance. + def __init__(self, xcomp=0.0, rcomp=0.0, *args, **kw_args): + """Initialises a new 'VcompIEEE' instance. @param xcomp: Compensating (compounding) reactance @param rcomp: Compensating (compounding) resistance @@ -32,5 +32,12 @@ class VcompIEEE(VoltageCompensator): #: Compensating (compounding) resistance self.rcomp = rcomp - super(VcompIEEE, self).__init__(**kw_args) + super(VcompIEEE, self).__init__(*args, **kw_args) + + _attrs = ["xcomp", "rcomp"] + _attr_types = {"xcomp": float, "rcomp": float} + _defaults = {"xcomp": 0.0, "rcomp": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Dynamics/VoltageCompensator/VoltageCompensator.py b/schemata/CIM14/Dynamics/VoltageCompensator/VoltageCompensator.py index 8e40b4b..365553f 100644 --- a/schemata/CIM14/Dynamics/VoltageCompensator/VoltageCompensator.py +++ b/schemata/CIM14/Dynamics/VoltageCompensator/VoltageCompensator.py @@ -20,9 +20,16 @@ class VoltageCompensator(PowerSystemResource): """A voltage compensator adjusts the terminal voltage feedback to the excitation system by adding a quantity that is proportional to the terminal current of the generator. It is linked to a specific generator by the Bus number and Unit ID """ - def __init__(self, **kw_args): - """Initializes a new 'VoltageCompensator' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'VoltageCompensator' instance. """ - super(VoltageCompensator, self).__init__(**kw_args) + super(VoltageCompensator, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/Element.py b/schemata/CIM14/Element.py index 7b53523..5759d93 100644 --- a/schemata/CIM14/Element.py +++ b/schemata/CIM14/Element.py @@ -18,11 +18,18 @@ class Element(object): def __init__(self, UUID=''): - """Initializes a new 'Element' instance. + """Initialises a new 'Element' instance. - @param UUID: + @param UUID: """ self.UUID = UUID + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] + diff --git a/schemata/CIM14/IEC61968/AssetModels/AssetModel.py b/schemata/CIM14/IEC61968/AssetModels/AssetModel.py index fd0f5de..4844803 100644 --- a/schemata/CIM14/IEC61968/AssetModels/AssetModel.py +++ b/schemata/CIM14/IEC61968/AssetModels/AssetModel.py @@ -20,8 +20,8 @@ class AssetModel(IdentifiedObject): """Documentation for a particular product model made by a manufacturer. There are typically many instances of an asset associated with a single asset model. """ - def __init__(self, usageKind='streetlight', corporateStandardKind='other', modelNumber='', weightTotal=0.0, modelVersion='', **kw_args): - """Initializes a new 'AssetModel' instance. + def __init__(self, usageKind="streetlight", corporateStandardKind="other", modelNumber='', weightTotal=0.0, modelVersion='', *args, **kw_args): + """Initialises a new 'AssetModel' instance. @param usageKind: Intended usage for this asset model. Values are: "streetlight", "other", "unknown", "substation", "distributionOverhead", "customerSubstation", "transmission", "distributionUnderground" @param corporateStandardKind: Kind of corporate standard for this asset model. Values are: "other", "standard", "experimental", "underEvaluation" @@ -29,10 +29,10 @@ class AssetModel(IdentifiedObject): @param weightTotal: Total manufactured weight of asset. @param modelVersion: Version number for product model, which indicates vintage of the product. """ - #: Intended usage for this asset model.Values are: "streetlight", "other", "unknown", "substation", "distributionOverhead", "customerSubstation", "transmission", "distributionUnderground" + #: Intended usage for this asset model. Values are: "streetlight", "other", "unknown", "substation", "distributionOverhead", "customerSubstation", "transmission", "distributionUnderground" self.usageKind = usageKind - #: Kind of corporate standard for this asset model.Values are: "other", "standard", "experimental", "underEvaluation" + #: Kind of corporate standard for this asset model. Values are: "other", "standard", "experimental", "underEvaluation" self.corporateStandardKind = corporateStandardKind #: Manufacturer's model number. @@ -44,5 +44,12 @@ class AssetModel(IdentifiedObject): #: Version number for product model, which indicates vintage of the product. self.modelVersion = modelVersion - super(AssetModel, self).__init__(**kw_args) + super(AssetModel, self).__init__(*args, **kw_args) + + _attrs = ["usageKind", "corporateStandardKind", "modelNumber", "weightTotal", "modelVersion"] + _attr_types = {"usageKind": str, "corporateStandardKind": str, "modelNumber": str, "weightTotal": float, "modelVersion": str} + _defaults = {"usageKind": "streetlight", "corporateStandardKind": "other", "modelNumber": '', "weightTotal": 0.0, "modelVersion": ''} + _enums = {"usageKind": "AssetModelUsageKind", "corporateStandardKind": "CorporateStandardKind"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/AssetModels/CableInfo.py b/schemata/CIM14/IEC61968/AssetModels/CableInfo.py index 8191274..8460cb2 100644 --- a/schemata/CIM14/IEC61968/AssetModels/CableInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/CableInfo.py @@ -20,8 +20,8 @@ class CableInfo(ConductorInfo): """Cable data. """ - def __init__(self, constructionKind='sector', shieldMaterial='steel', outerJacketKind='polyethylene', isStrandFill=False, diameterOverScreen=0.0, diameterOverInsulation=0.0, diameterOverJacket=0.0, nominalTemperature=0.0, diameterOverCore=0.0, sheathAsNeutral=False, **kw_args): - """Initializes a new 'CableInfo' instance. + def __init__(self, constructionKind="sector", shieldMaterial="steel", outerJacketKind="polyethylene", isStrandFill=False, diameterOverScreen=0.0, diameterOverInsulation=0.0, diameterOverJacket=0.0, nominalTemperature=0.0, diameterOverCore=0.0, sheathAsNeutral=False, *args, **kw_args): + """Initialises a new 'CableInfo' instance. @param constructionKind: Kind of construction of this cable. Values are: "sector", "compressed", "segmental", "solid", "stranded", "compacted", "other" @param shieldMaterial: Material of the shield. Values are: "steel", "lead", "aluminum", "other", "copper" @@ -34,13 +34,13 @@ class CableInfo(ConductorInfo): @param diameterOverCore: Diameter over the core, including any semi-con screen; should be the insulating layer's inside diameter. @param sheathAsNeutral: True if sheath / shield is used as a neutral (i.e., bonded). """ - #: Kind of construction of this cable.Values are: "sector", "compressed", "segmental", "solid", "stranded", "compacted", "other" + #: Kind of construction of this cable. Values are: "sector", "compressed", "segmental", "solid", "stranded", "compacted", "other" self.constructionKind = constructionKind - #: Material of the shield.Values are: "steel", "lead", "aluminum", "other", "copper" + #: Material of the shield. Values are: "steel", "lead", "aluminum", "other", "copper" self.shieldMaterial = shieldMaterial - #: Kind of outer jacket of this cable.Values are: "polyethylene", "pvc", "none", "linearLowDensityPolyethylene", "other", "insulating", "semiconducting" + #: Kind of outer jacket of this cable. Values are: "polyethylene", "pvc", "none", "linearLowDensityPolyethylene", "other", "insulating", "semiconducting" self.outerJacketKind = outerJacketKind #: True if wire strands are extruded in a way to fill the voids in the cable. @@ -64,5 +64,12 @@ class CableInfo(ConductorInfo): #: True if sheath / shield is used as a neutral (i.e., bonded). self.sheathAsNeutral = sheathAsNeutral - super(CableInfo, self).__init__(**kw_args) + super(CableInfo, self).__init__(*args, **kw_args) + + _attrs = ["constructionKind", "shieldMaterial", "outerJacketKind", "isStrandFill", "diameterOverScreen", "diameterOverInsulation", "diameterOverJacket", "nominalTemperature", "diameterOverCore", "sheathAsNeutral"] + _attr_types = {"constructionKind": str, "shieldMaterial": str, "outerJacketKind": str, "isStrandFill": bool, "diameterOverScreen": float, "diameterOverInsulation": float, "diameterOverJacket": float, "nominalTemperature": float, "diameterOverCore": float, "sheathAsNeutral": bool} + _defaults = {"constructionKind": "sector", "shieldMaterial": "steel", "outerJacketKind": "polyethylene", "isStrandFill": False, "diameterOverScreen": 0.0, "diameterOverInsulation": 0.0, "diameterOverJacket": 0.0, "nominalTemperature": 0.0, "diameterOverCore": 0.0, "sheathAsNeutral": False} + _enums = {"constructionKind": "CableConstructionKind", "shieldMaterial": "CableShieldMaterialKind", "outerJacketKind": "CableOuterJacketKind"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/AssetModels/ConcentricNeutralCableInfo.py b/schemata/CIM14/IEC61968/AssetModels/ConcentricNeutralCableInfo.py index 206d087..2ea8df7 100644 --- a/schemata/CIM14/IEC61968/AssetModels/ConcentricNeutralCableInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/ConcentricNeutralCableInfo.py @@ -20,8 +20,8 @@ class ConcentricNeutralCableInfo(CableInfo): """Concentric neutral cable data. """ - def __init__(self, diameterOverNeutral=0.0, neutralStrandCount=0, WireType=None, **kw_args): - """Initializes a new 'ConcentricNeutralCableInfo' instance. + def __init__(self, diameterOverNeutral=0.0, neutralStrandCount=0, WireType=None, *args, **kw_args): + """Initialises a new 'ConcentricNeutralCableInfo' instance. @param diameterOverNeutral: Diameter over the concentric neutral strands. @param neutralStrandCount: Number of concentric neutral strands. @@ -36,7 +36,14 @@ class ConcentricNeutralCableInfo(CableInfo): self._WireType = None self.WireType = WireType - super(ConcentricNeutralCableInfo, self).__init__(**kw_args) + super(ConcentricNeutralCableInfo, self).__init__(*args, **kw_args) + + _attrs = ["diameterOverNeutral", "neutralStrandCount"] + _attr_types = {"diameterOverNeutral": float, "neutralStrandCount": int} + _defaults = {"diameterOverNeutral": 0.0, "neutralStrandCount": 0} + _enums = {} + _refs = ["WireType"] + _many_refs = [] def getWireType(self): """Wire type used for this concentric neutral cable. diff --git a/schemata/CIM14/IEC61968/AssetModels/ConductorInfo.py b/schemata/CIM14/IEC61968/AssetModels/ConductorInfo.py index 5fb8ec9..ccf34da 100644 --- a/schemata/CIM14/IEC61968/AssetModels/ConductorInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/ConductorInfo.py @@ -20,8 +20,8 @@ class ConductorInfo(IdentifiedObject): """Conductor data. """ - def __init__(self, usage='distribution', insulationMaterial='crosslinkedPolyethylene', insulated=False, insulationThickness=0.0, phaseCount=0, ConductorSegments=None, WireArrangements=None, **kw_args): - """Initializes a new 'ConductorInfo' instance. + def __init__(self, usage="distribution", insulationMaterial="crosslinkedPolyethylene", insulated=False, insulationThickness=0.0, phaseCount=0, ConductorSegments=None, WireArrangements=None, *args, **kw_args): + """Initialises a new 'ConductorInfo' instance. @param usage: Usage of this conductor. Values are: "distribution", "secondary", "transmission", "other" @param insulationMaterial: (if insulated conductor) Material used for insulation. Values are: "crosslinkedPolyethylene", "ozoneResistantRubber", "highMolecularWeightPolyethylene", "unbeltedPilc", "treeRetardantCrosslinkedPolyethylene", "butyl", "rubber", "asbestosAndVarnishedCambric", "beltedPilc", "varnishedDacronGlass", "other", "treeResistantHighMolecularWeightPolyethylene", "lowCapacitanceRubber", "varnishedCambricCloth", "highPressureFluidFilled", "ethylenePropyleneRubber", "siliconRubber", "oilPaper" @@ -31,10 +31,10 @@ class ConductorInfo(IdentifiedObject): @param ConductorSegments: All conductor segments described by this conductor data. @param WireArrangements: All wire arrangements (single wires) that make this conductor. """ - #: Usage of this conductor.Values are: "distribution", "secondary", "transmission", "other" + #: Usage of this conductor. Values are: "distribution", "secondary", "transmission", "other" self.usage = usage - #: (if insulated conductor) Material used for insulation.Values are: "crosslinkedPolyethylene", "ozoneResistantRubber", "highMolecularWeightPolyethylene", "unbeltedPilc", "treeRetardantCrosslinkedPolyethylene", "butyl", "rubber", "asbestosAndVarnishedCambric", "beltedPilc", "varnishedDacronGlass", "other", "treeResistantHighMolecularWeightPolyethylene", "lowCapacitanceRubber", "varnishedCambricCloth", "highPressureFluidFilled", "ethylenePropyleneRubber", "siliconRubber", "oilPaper" + #: (if insulated conductor) Material used for insulation. Values are: "crosslinkedPolyethylene", "ozoneResistantRubber", "highMolecularWeightPolyethylene", "unbeltedPilc", "treeRetardantCrosslinkedPolyethylene", "butyl", "rubber", "asbestosAndVarnishedCambric", "beltedPilc", "varnishedDacronGlass", "other", "treeResistantHighMolecularWeightPolyethylene", "lowCapacitanceRubber", "varnishedCambricCloth", "highPressureFluidFilled", "ethylenePropyleneRubber", "siliconRubber", "oilPaper" self.insulationMaterial = insulationMaterial #: True if conductor is insulated. @@ -52,7 +52,14 @@ class ConductorInfo(IdentifiedObject): self._WireArrangements = [] self.WireArrangements = [] if WireArrangements is None else WireArrangements - super(ConductorInfo, self).__init__(**kw_args) + super(ConductorInfo, self).__init__(*args, **kw_args) + + _attrs = ["usage", "insulationMaterial", "insulated", "insulationThickness", "phaseCount"] + _attr_types = {"usage": str, "insulationMaterial": str, "insulated": bool, "insulationThickness": float, "phaseCount": int} + _defaults = {"usage": "distribution", "insulationMaterial": "crosslinkedPolyethylene", "insulated": False, "insulationThickness": 0.0, "phaseCount": 0} + _enums = {"usage": "ConductorUsageKind", "insulationMaterial": "ConductorInsulationKind"} + _refs = ["ConductorSegments", "WireArrangements"] + _many_refs = ["ConductorSegments", "WireArrangements"] def getConductorSegments(self): """All conductor segments described by this conductor data. diff --git a/schemata/CIM14/IEC61968/AssetModels/DistributionWindingTest.py b/schemata/CIM14/IEC61968/AssetModels/DistributionWindingTest.py index cdb38b5..c49ea9d 100644 --- a/schemata/CIM14/IEC61968/AssetModels/DistributionWindingTest.py +++ b/schemata/CIM14/IEC61968/AssetModels/DistributionWindingTest.py @@ -20,8 +20,8 @@ class DistributionWindingTest(IdentifiedObject): """Test results for one or more transformer windings. These may include short-circuit or open-circuit (excitation) tests. Short-circuit test results include load losses and leakage impedances. Open-circuit test results may include no-load losses, exciting current, phase shifts, and induced voltage. For three-phase windings, the excitation can be positive sequence (the default) or zero sequence. """ - def __init__(self, fromTapStep=0, FromWinding=None, **kw_args): - """Initializes a new 'DistributionWindingTest' instance. + def __init__(self, fromTapStep=0, FromWinding=None, *args, **kw_args): + """Initialises a new 'DistributionWindingTest' instance. @param fromTapStep: Tap step number for the 'from' winding of the test pair. @param FromWinding: Winding that voltage or current is applied to during the test. @@ -32,7 +32,14 @@ class DistributionWindingTest(IdentifiedObject): self._FromWinding = None self.FromWinding = FromWinding - super(DistributionWindingTest, self).__init__(**kw_args) + super(DistributionWindingTest, self).__init__(*args, **kw_args) + + _attrs = ["fromTapStep"] + _attr_types = {"fromTapStep": int} + _defaults = {"fromTapStep": 0} + _enums = {} + _refs = ["FromWinding"] + _many_refs = [] def getFromWinding(self): """Winding that voltage or current is applied to during the test. diff --git a/schemata/CIM14/IEC61968/AssetModels/EndDeviceModel.py b/schemata/CIM14/IEC61968/AssetModels/EndDeviceModel.py index af74022..fe2deca 100644 --- a/schemata/CIM14/IEC61968/AssetModels/EndDeviceModel.py +++ b/schemata/CIM14/IEC61968/AssetModels/EndDeviceModel.py @@ -20,15 +20,22 @@ class EndDeviceModel(AssetModel): """Documentation for particular end device product model made by a manufacturer. """ - def __init__(self, EndDeviceAssets=None, **kw_args): - """Initializes a new 'EndDeviceModel' instance. + def __init__(self, EndDeviceAssets=None, *args, **kw_args): + """Initialises a new 'EndDeviceModel' instance. @param EndDeviceAssets: All end device assets being of this model. """ self._EndDeviceAssets = [] self.EndDeviceAssets = [] if EndDeviceAssets is None else EndDeviceAssets - super(EndDeviceModel, self).__init__(**kw_args) + super(EndDeviceModel, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["EndDeviceAssets"] + _many_refs = ["EndDeviceAssets"] def getEndDeviceAssets(self): """All end device assets being of this model. diff --git a/schemata/CIM14/IEC61968/AssetModels/OpenCircuitTest.py b/schemata/CIM14/IEC61968/AssetModels/OpenCircuitTest.py index 07e7a5b..ea7003e 100644 --- a/schemata/CIM14/IEC61968/AssetModels/OpenCircuitTest.py +++ b/schemata/CIM14/IEC61968/AssetModels/OpenCircuitTest.py @@ -20,8 +20,8 @@ class OpenCircuitTest(DistributionWindingTest): """Open-circuit test results may include no-load losses, exciting current, phase shifts, and induced voltage. For three-phase windings, the excitation can be positive sequence (the default) or zero sequence. For induced voltage and phase shifts, use the associated ToWindingSpec class. """ - def __init__(self, excitingCurrentZero=0.0, noLoadLossZero=0.0, noLoadLoss=0.0, excitingCurrent=0.0, MeasuredWindingSpecs=None, **kw_args): - """Initializes a new 'OpenCircuitTest' instance. + def __init__(self, excitingCurrentZero=0.0, noLoadLossZero=0.0, noLoadLoss=0.0, excitingCurrent=0.0, MeasuredWindingSpecs=None, *args, **kw_args): + """Initialises a new 'OpenCircuitTest' instance. @param excitingCurrentZero: Exciting current measured from a zero-sequence open-circuit (excitation) test. @param noLoadLossZero: Losses measured from a zero-sequence open-circuit (excitation) test. @@ -44,7 +44,14 @@ class OpenCircuitTest(DistributionWindingTest): self._MeasuredWindingSpecs = [] self.MeasuredWindingSpecs = [] if MeasuredWindingSpecs is None else MeasuredWindingSpecs - super(OpenCircuitTest, self).__init__(**kw_args) + super(OpenCircuitTest, self).__init__(*args, **kw_args) + + _attrs = ["excitingCurrentZero", "noLoadLossZero", "noLoadLoss", "excitingCurrent"] + _attr_types = {"excitingCurrentZero": float, "noLoadLossZero": float, "noLoadLoss": float, "excitingCurrent": float} + _defaults = {"excitingCurrentZero": 0.0, "noLoadLossZero": 0.0, "noLoadLoss": 0.0, "excitingCurrent": 0.0} + _enums = {} + _refs = ["MeasuredWindingSpecs"] + _many_refs = ["MeasuredWindingSpecs"] def getMeasuredWindingSpecs(self): """All other windings measured during this test. diff --git a/schemata/CIM14/IEC61968/AssetModels/OverheadConductorInfo.py b/schemata/CIM14/IEC61968/AssetModels/OverheadConductorInfo.py index c361c9d..e13e7b5 100644 --- a/schemata/CIM14/IEC61968/AssetModels/OverheadConductorInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/OverheadConductorInfo.py @@ -20,8 +20,8 @@ class OverheadConductorInfo(ConductorInfo): """Overhead conductor data. """ - def __init__(self, neutralInsulationThickness=0.0, phaseConductorSpacing=0.0, phaseConductorCount=0, **kw_args): - """Initializes a new 'OverheadConductorInfo' instance. + def __init__(self, neutralInsulationThickness=0.0, phaseConductorSpacing=0.0, phaseConductorCount=0, *args, **kw_args): + """Initialises a new 'OverheadConductorInfo' instance. @param neutralInsulationThickness: (if applicable) Insulation thickness of the neutral conductor. @param phaseConductorSpacing: Distance between conductor strands in a symmetrical bundle. @@ -36,5 +36,12 @@ class OverheadConductorInfo(ConductorInfo): #: Number of conductor strands in the symmetrical bundle (1-12). self.phaseConductorCount = phaseConductorCount - super(OverheadConductorInfo, self).__init__(**kw_args) + super(OverheadConductorInfo, self).__init__(*args, **kw_args) + + _attrs = ["neutralInsulationThickness", "phaseConductorSpacing", "phaseConductorCount"] + _attr_types = {"neutralInsulationThickness": float, "phaseConductorSpacing": float, "phaseConductorCount": int} + _defaults = {"neutralInsulationThickness": 0.0, "phaseConductorSpacing": 0.0, "phaseConductorCount": 0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/AssetModels/ShortCircuitTest.py b/schemata/CIM14/IEC61968/AssetModels/ShortCircuitTest.py index 967f6d2..98ead20 100644 --- a/schemata/CIM14/IEC61968/AssetModels/ShortCircuitTest.py +++ b/schemata/CIM14/IEC61968/AssetModels/ShortCircuitTest.py @@ -20,8 +20,8 @@ class ShortCircuitTest(DistributionWindingTest): """Short-circuit test results include load losses and leakage impedances. For three-phase windings, the excitation can be positive sequence (the default) or zero sequence. There must be at least one short-circuited ('to') winding. """ - def __init__(self, loadLossZero=0.0, leakageImpedanceZero=0.0, leakageImpedance=0.0, loadLoss=0.0, ShortedWindingSpecs=None, **kw_args): - """Initializes a new 'ShortCircuitTest' instance. + def __init__(self, loadLossZero=0.0, leakageImpedanceZero=0.0, leakageImpedance=0.0, loadLoss=0.0, ShortedWindingSpecs=None, *args, **kw_args): + """Initialises a new 'ShortCircuitTest' instance. @param loadLossZero: Load losses from a zero-sequence short-circuit test. @param leakageImpedanceZero: Leakage impedance measured from a zero-sequence short-circuit test. @@ -44,7 +44,14 @@ class ShortCircuitTest(DistributionWindingTest): self._ShortedWindingSpecs = [] self.ShortedWindingSpecs = [] if ShortedWindingSpecs is None else ShortedWindingSpecs - super(ShortCircuitTest, self).__init__(**kw_args) + super(ShortCircuitTest, self).__init__(*args, **kw_args) + + _attrs = ["loadLossZero", "leakageImpedanceZero", "leakageImpedance", "loadLoss"] + _attr_types = {"loadLossZero": float, "leakageImpedanceZero": float, "leakageImpedance": float, "loadLoss": float} + _defaults = {"loadLossZero": 0.0, "leakageImpedanceZero": 0.0, "leakageImpedance": 0.0, "loadLoss": 0.0} + _enums = {} + _refs = ["ShortedWindingSpecs"] + _many_refs = ["ShortedWindingSpecs"] def getShortedWindingSpecs(self): """All windings short-circuited during this test. diff --git a/schemata/CIM14/IEC61968/AssetModels/TapeShieldCableInfo.py b/schemata/CIM14/IEC61968/AssetModels/TapeShieldCableInfo.py index 7512f63..9d62665 100644 --- a/schemata/CIM14/IEC61968/AssetModels/TapeShieldCableInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/TapeShieldCableInfo.py @@ -20,8 +20,8 @@ class TapeShieldCableInfo(CableInfo): """Tape shield cable data. """ - def __init__(self, tapeThickness=0.0, tapeLap=0.0, **kw_args): - """Initializes a new 'TapeShieldCableInfo' instance. + def __init__(self, tapeThickness=0.0, tapeLap=0.0, *args, **kw_args): + """Initialises a new 'TapeShieldCableInfo' instance. @param tapeThickness: Thickness of the tape shield, before wrapping. @param tapeLap: Percentage of the tape shield width that overlaps in each wrap, typically 10% to 25%. @@ -32,5 +32,12 @@ class TapeShieldCableInfo(CableInfo): #: Percentage of the tape shield width that overlaps in each wrap, typically 10% to 25%. self.tapeLap = tapeLap - super(TapeShieldCableInfo, self).__init__(**kw_args) + super(TapeShieldCableInfo, self).__init__(*args, **kw_args) + + _attrs = ["tapeThickness", "tapeLap"] + _attr_types = {"tapeThickness": float, "tapeLap": float} + _defaults = {"tapeThickness": 0.0, "tapeLap": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/AssetModels/ToWindingSpec.py b/schemata/CIM14/IEC61968/AssetModels/ToWindingSpec.py index 8037fef..cf3b2fe 100644 --- a/schemata/CIM14/IEC61968/AssetModels/ToWindingSpec.py +++ b/schemata/CIM14/IEC61968/AssetModels/ToWindingSpec.py @@ -20,8 +20,8 @@ class ToWindingSpec(IdentifiedObject): """For short-circuit tests, specifies the winding and tap for all short-circuited windings. For open-circuit tests, specifies the winding, tap, induced voltage, and induced angle for any non-excited windings that were measured during the test. This won't apply if only the exciting current and no-load losses were measured. """ - def __init__(self, voltage=0.0, phaseShift=0.0, toTapStep=0, ToWinding=None, OpenCircuitTests=None, ShortCircuitTests=None, **kw_args): - """Initializes a new 'ToWindingSpec' instance. + def __init__(self, voltage=0.0, phaseShift=0.0, toTapStep=0, ToWinding=None, OpenCircuitTests=None, ShortCircuitTests=None, *args, **kw_args): + """Initialises a new 'ToWindingSpec' instance. @param voltage: (if open-circuit test) Voltage measured at the open-circuited 'to' winding, with the 'from' winding set to the 'from' winding's rated voltage and all other windings open-circuited. @param phaseShift: (if open-circuit test) Phase shift measured at the open-circuited 'to' winding, with the 'from' winding set to the 'from' winding's rated voltage and all other windings open-circuited. @@ -48,7 +48,14 @@ class ToWindingSpec(IdentifiedObject): self._ShortCircuitTests = [] self.ShortCircuitTests = [] if ShortCircuitTests is None else ShortCircuitTests - super(ToWindingSpec, self).__init__(**kw_args) + super(ToWindingSpec, self).__init__(*args, **kw_args) + + _attrs = ["voltage", "phaseShift", "toTapStep"] + _attr_types = {"voltage": float, "phaseShift": float, "toTapStep": int} + _defaults = {"voltage": 0.0, "phaseShift": 0.0, "toTapStep": 0} + _enums = {} + _refs = ["ToWinding", "OpenCircuitTests", "ShortCircuitTests"] + _many_refs = ["OpenCircuitTests", "ShortCircuitTests"] def getToWinding(self): """Winding short-circuited in a short-circuit test, or measured for induced voltage and angle in an open-circuit test. diff --git a/schemata/CIM14/IEC61968/AssetModels/TransformerInfo.py b/schemata/CIM14/IEC61968/AssetModels/TransformerInfo.py index f9d442c..533eb37 100644 --- a/schemata/CIM14/IEC61968/AssetModels/TransformerInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/TransformerInfo.py @@ -20,8 +20,8 @@ class TransformerInfo(IdentifiedObject): """Set of transformer data, from an equipment library. """ - def __init__(self, WindingInfos=None, Transformers=None, **kw_args): - """Initializes a new 'TransformerInfo' instance. + def __init__(self, WindingInfos=None, Transformers=None, *args, **kw_args): + """Initialises a new 'TransformerInfo' instance. @param WindingInfos: Data for all the windings described by this transformer data. @param Transformers: All transformers that can be described with this transformer data. @@ -32,7 +32,14 @@ class TransformerInfo(IdentifiedObject): self._Transformers = [] self.Transformers = [] if Transformers is None else Transformers - super(TransformerInfo, self).__init__(**kw_args) + super(TransformerInfo, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["WindingInfos", "Transformers"] + _many_refs = ["WindingInfos", "Transformers"] def getWindingInfos(self): """Data for all the windings described by this transformer data. diff --git a/schemata/CIM14/IEC61968/AssetModels/WindingInfo.py b/schemata/CIM14/IEC61968/AssetModels/WindingInfo.py index 955d30f..04f6330 100644 --- a/schemata/CIM14/IEC61968/AssetModels/WindingInfo.py +++ b/schemata/CIM14/IEC61968/AssetModels/WindingInfo.py @@ -20,8 +20,8 @@ class WindingInfo(IdentifiedObject): """Winding data. """ - def __init__(self, connectionKind='Yn', r=0.0, phaseAngle=0, emergencyS=0.0, ratedU=0.0, insulationU=0.0, ratedS=0.0, sequenceNumber=0, shortTermS=0.0, Windings=None, WindingTests=None, TransformerInfo=None, ToWindingSpecs=None, **kw_args): - """Initializes a new 'WindingInfo' instance. + def __init__(self, connectionKind="Yn", r=0.0, phaseAngle=0, emergencyS=0.0, ratedU=0.0, insulationU=0.0, ratedS=0.0, sequenceNumber=0, shortTermS=0.0, Windings=None, WindingTests=None, TransformerInfo=None, ToWindingSpecs=None, *args, **kw_args): + """Initialises a new 'WindingInfo' instance. @param connectionKind: Kind of connection of this winding. Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" @param r: DC resistance of this winding. @@ -37,7 +37,7 @@ class WindingInfo(IdentifiedObject): @param TransformerInfo: Transformer data that this winding description is part of. @param ToWindingSpecs: Tap steps and induced voltage/angle measurements for tests in which this winding was not excited. """ - #: Kind of connection of this winding.Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" + #: Kind of connection of this winding. Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" self.connectionKind = connectionKind #: DC resistance of this winding. @@ -76,7 +76,14 @@ class WindingInfo(IdentifiedObject): self._ToWindingSpecs = [] self.ToWindingSpecs = [] if ToWindingSpecs is None else ToWindingSpecs - super(WindingInfo, self).__init__(**kw_args) + super(WindingInfo, self).__init__(*args, **kw_args) + + _attrs = ["connectionKind", "r", "phaseAngle", "emergencyS", "ratedU", "insulationU", "ratedS", "sequenceNumber", "shortTermS"] + _attr_types = {"connectionKind": str, "r": float, "phaseAngle": int, "emergencyS": float, "ratedU": float, "insulationU": float, "ratedS": float, "sequenceNumber": int, "shortTermS": float} + _defaults = {"connectionKind": "Yn", "r": 0.0, "phaseAngle": 0, "emergencyS": 0.0, "ratedU": 0.0, "insulationU": 0.0, "ratedS": 0.0, "sequenceNumber": 0, "shortTermS": 0.0} + _enums = {"connectionKind": "WindingConnection"} + _refs = ["Windings", "WindingTests", "TransformerInfo", "ToWindingSpecs"] + _many_refs = ["Windings", "WindingTests", "ToWindingSpecs"] def getWindings(self): """All windings described by this winding data. diff --git a/schemata/CIM14/IEC61968/AssetModels/WireArrangement.py b/schemata/CIM14/IEC61968/AssetModels/WireArrangement.py index 04fc7f0..51135a9 100644 --- a/schemata/CIM14/IEC61968/AssetModels/WireArrangement.py +++ b/schemata/CIM14/IEC61968/AssetModels/WireArrangement.py @@ -20,8 +20,8 @@ class WireArrangement(IdentifiedObject): """Identification, spacing and configuration of the wires of a Conductor, with reference to their type. """ - def __init__(self, position=0, mountingPointX=0.0, mountingPointY=0.0, WireType=None, ConductorInfo=None, **kw_args): - """Initializes a new 'WireArrangement' instance. + def __init__(self, position=0, mountingPointX=0.0, mountingPointY=0.0, WireType=None, ConductorInfo=None, *args, **kw_args): + """Initialises a new 'WireArrangement' instance. @param position: Position number on the structure corresponding to this wire. For example, use 1..3 for phases and 4 for the neutral on a 3-phase structure. The individual phase assignments matter; for example, ABC will produce a different set of unbalanced line parameters, by phase, than BAC. @param mountingPointX: Signed horizontal distance from the first wire to a common reference point. @@ -44,7 +44,14 @@ class WireArrangement(IdentifiedObject): self._ConductorInfo = None self.ConductorInfo = ConductorInfo - super(WireArrangement, self).__init__(**kw_args) + super(WireArrangement, self).__init__(*args, **kw_args) + + _attrs = ["position", "mountingPointX", "mountingPointY"] + _attr_types = {"position": int, "mountingPointX": float, "mountingPointY": float} + _defaults = {"position": 0, "mountingPointX": 0.0, "mountingPointY": 0.0} + _enums = {} + _refs = ["WireType", "ConductorInfo"] + _many_refs = [] def getWireType(self): """Wire type used for this wire arrangement. diff --git a/schemata/CIM14/IEC61968/AssetModels/WireType.py b/schemata/CIM14/IEC61968/AssetModels/WireType.py index a8d3478..dbc5f12 100644 --- a/schemata/CIM14/IEC61968/AssetModels/WireType.py +++ b/schemata/CIM14/IEC61968/AssetModels/WireType.py @@ -20,8 +20,8 @@ class WireType(IdentifiedObject): """Wire conductor (per IEEE specs). A specific type of wire or combination of wires, not insulated from each other, suitable for carrying electrical current. """ - def __init__(self, material='acsr', rAC25=0.0, sizeDescription='', rAC75=0.0, radius=0.0, coreRadius=0.0, rAC50=0.0, gmr=0.0, rDC20=0.0, ratedCurrent=0.0, coreStrandCount=0, strandCount=0, WireArrangements=None, ConcentricNeutralCableInfos=None, **kw_args): - """Initializes a new 'WireType' instance. + def __init__(self, material="acsr", rAC25=0.0, sizeDescription='', rAC75=0.0, radius=0.0, coreRadius=0.0, rAC50=0.0, gmr=0.0, rDC20=0.0, ratedCurrent=0.0, coreStrandCount=0, strandCount=0, WireArrangements=None, ConcentricNeutralCableInfos=None, *args, **kw_args): + """Initialises a new 'WireType' instance. @param material: Wire material. Values are: "acsr", "steel", "aluminum", "copper", "other" @param rAC25: AC resistance per unit length of the conductor at 25 degrees C. @@ -38,7 +38,7 @@ class WireType(IdentifiedObject): @param WireArrangements: All wire arrangements using this wire type. @param ConcentricNeutralCableInfos: All concentric neutral cables using this wire type. """ - #: Wire material.Values are: "acsr", "steel", "aluminum", "copper", "other" + #: Wire material. Values are: "acsr", "steel", "aluminum", "copper", "other" self.material = material #: AC resistance per unit length of the conductor at 25 degrees C. @@ -80,7 +80,14 @@ class WireType(IdentifiedObject): self._ConcentricNeutralCableInfos = [] self.ConcentricNeutralCableInfos = [] if ConcentricNeutralCableInfos is None else ConcentricNeutralCableInfos - super(WireType, self).__init__(**kw_args) + super(WireType, self).__init__(*args, **kw_args) + + _attrs = ["material", "rAC25", "sizeDescription", "rAC75", "radius", "coreRadius", "rAC50", "gmr", "rDC20", "ratedCurrent", "coreStrandCount", "strandCount"] + _attr_types = {"material": str, "rAC25": float, "sizeDescription": str, "rAC75": float, "radius": float, "coreRadius": float, "rAC50": float, "gmr": float, "rDC20": float, "ratedCurrent": float, "coreStrandCount": int, "strandCount": int} + _defaults = {"material": "acsr", "rAC25": 0.0, "sizeDescription": '', "rAC75": 0.0, "radius": 0.0, "coreRadius": 0.0, "rAC50": 0.0, "gmr": 0.0, "rDC20": 0.0, "ratedCurrent": 0.0, "coreStrandCount": 0, "strandCount": 0} + _enums = {"material": "ConductorMaterialKind"} + _refs = ["WireArrangements", "ConcentricNeutralCableInfos"] + _many_refs = ["WireArrangements", "ConcentricNeutralCableInfos"] def getWireArrangements(self): """All wire arrangements using this wire type. diff --git a/schemata/CIM14/IEC61968/Assets/AcceptanceTest.py b/schemata/CIM14/IEC61968/Assets/AcceptanceTest.py index 0d523bb..58b9890 100644 --- a/schemata/CIM14/IEC61968/Assets/AcceptanceTest.py +++ b/schemata/CIM14/IEC61968/Assets/AcceptanceTest.py @@ -20,8 +20,8 @@ class AcceptanceTest(Element): """Acceptance test for assets. """ - def __init__(self, success=False, type='', dateTime='', **kw_args): - """Initializes a new 'AcceptanceTest' instance. + def __init__(self, success=False, type='', dateTime='', *args, **kw_args): + """Initialises a new 'AcceptanceTest' instance. @param success: True if asset has passed acceptance test and may be placed in or is in service. It is set to false if asset is removed from service and is required to be tested again before being placed back in service, possibly in a new location. Since asset may go through multiple tests during its life cycle, the date of each acceptance test may be recorded in Asset.ActivityRecord.status.dateTime. @param type: Type of test or group of tests that was conducted on 'dateTime'. @@ -36,5 +36,12 @@ class AcceptanceTest(Element): #: Date and time the asset was last tested using the 'type' of test and yielding the current status in 'success' attribute. self.dateTime = dateTime - super(AcceptanceTest, self).__init__(**kw_args) + super(AcceptanceTest, self).__init__(*args, **kw_args) + + _attrs = ["success", "type", "dateTime"] + _attr_types = {"success": bool, "type": str, "dateTime": str} + _defaults = {"success": False, "type": '', "dateTime": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Assets/Asset.py b/schemata/CIM14/IEC61968/Assets/Asset.py index ec701f1..56281f4 100644 --- a/schemata/CIM14/IEC61968/Assets/Asset.py +++ b/schemata/CIM14/IEC61968/Assets/Asset.py @@ -20,8 +20,8 @@ class Asset(IdentifiedObject): """Tangible resource of the utility, including power system equipment, cabinets, buildings, etc. For electrical network equipment, the role of the asset is defined through PowerSystemResource and its subclasses, defined mainly in the Wires model (refer to IEC61970-301 and model package IEC61970::Wires). Asset description places emphasis on the physical characteristics of the equipment fulfilling that role. """ - def __init__(self, category='', serialNumber='', manufacturedDate='', lotNumber='', critical=False, application='', initialLossOfLife=0.0, corporateCode='', purchasePrice=0.0, utcNumber='', installationDate='', initialCondition='', PowerSystemResources=None, Properties=None, acceptanceTest=None, ActivityRecords=None, Location=None, AssetFunctions=None, Measurements=None, AssetContainer=None, status=None, Ratings=None, electronicAddress=None, **kw_args): - """Initializes a new 'Asset' instance. + def __init__(self, category='', serialNumber='', manufacturedDate='', lotNumber='', critical=False, application='', initialLossOfLife=0.0, corporateCode='', purchasePrice=0.0, utcNumber='', installationDate='', initialCondition='', PowerSystemResources=None, Properties=None, acceptanceTest=None, ActivityRecords=None, Location=None, AssetFunctions=None, Measurements=None, AssetContainer=None, status=None, Ratings=None, electronicAddress=None, *args, **kw_args): + """Initialises a new 'Asset' instance. @param category: Extension mechanism to accommodate utility-specific categorisation of Asset and its subtypes, according to their corporate standards, practices, and existing IT systems (e.g., for management of assets, maintenance, work, outage, customers, etc.). @param serialNumber: Serial number of this asset. @@ -113,7 +113,14 @@ class Asset(IdentifiedObject): self.electronicAddress = electronicAddress - super(Asset, self).__init__(**kw_args) + super(Asset, self).__init__(*args, **kw_args) + + _attrs = ["category", "serialNumber", "manufacturedDate", "lotNumber", "critical", "application", "initialLossOfLife", "corporateCode", "purchasePrice", "utcNumber", "installationDate", "initialCondition"] + _attr_types = {"category": str, "serialNumber": str, "manufacturedDate": str, "lotNumber": str, "critical": bool, "application": str, "initialLossOfLife": float, "corporateCode": str, "purchasePrice": float, "utcNumber": str, "installationDate": str, "initialCondition": str} + _defaults = {"category": '', "serialNumber": '', "manufacturedDate": '', "lotNumber": '', "critical": False, "application": '', "initialLossOfLife": 0.0, "corporateCode": '', "purchasePrice": 0.0, "utcNumber": '', "installationDate": '', "initialCondition": ''} + _enums = {} + _refs = ["PowerSystemResources", "Properties", "acceptanceTest", "ActivityRecords", "Location", "AssetFunctions", "Measurements", "AssetContainer", "status", "Ratings", "electronicAddress"] + _many_refs = ["PowerSystemResources", "Properties", "ActivityRecords", "AssetFunctions", "Measurements", "Ratings"] def getPowerSystemResources(self): """All power system resources used to electrically model this asset. For example, transformer asset is electrically modelled with a transformer and its windings and tap changer. diff --git a/schemata/CIM14/IEC61968/Assets/AssetContainer.py b/schemata/CIM14/IEC61968/Assets/AssetContainer.py index 4998823..a95cd25 100644 --- a/schemata/CIM14/IEC61968/Assets/AssetContainer.py +++ b/schemata/CIM14/IEC61968/Assets/AssetContainer.py @@ -20,8 +20,8 @@ class AssetContainer(Asset): """Asset that is aggregation of other assets such as conductors, transformers, switchgear, land, fences, buildings, equipment, vehicles, etc. """ - def __init__(self, Seals=None, Assets=None, **kw_args): - """Initializes a new 'AssetContainer' instance. + def __init__(self, Seals=None, Assets=None, *args, **kw_args): + """Initialises a new 'AssetContainer' instance. @param Seals: All seals applied to this asset container. @param Assets: @@ -32,7 +32,14 @@ class AssetContainer(Asset): self._Assets = [] self.Assets = [] if Assets is None else Assets - super(AssetContainer, self).__init__(**kw_args) + super(AssetContainer, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Seals", "Assets"] + _many_refs = ["Seals", "Assets"] def getSeals(self): """All seals applied to this asset container. diff --git a/schemata/CIM14/IEC61968/Assets/AssetFunction.py b/schemata/CIM14/IEC61968/Assets/AssetFunction.py index 5c2bd11..cbe0191 100644 --- a/schemata/CIM14/IEC61968/Assets/AssetFunction.py +++ b/schemata/CIM14/IEC61968/Assets/AssetFunction.py @@ -20,8 +20,8 @@ class AssetFunction(IdentifiedObject): """Function performed by an asset. """ - def __init__(self, configID='', programID='', firmwareID='', password='', hardwareID='', Asset=None, **kw_args): - """Initializes a new 'AssetFunction' instance. + def __init__(self, configID='', programID='', firmwareID='', password='', hardwareID='', Asset=None, *args, **kw_args): + """Initialises a new 'AssetFunction' instance. @param configID: Configuration specified for this function. @param programID: Name of program. @@ -48,7 +48,14 @@ class AssetFunction(IdentifiedObject): self._Asset = None self.Asset = Asset - super(AssetFunction, self).__init__(**kw_args) + super(AssetFunction, self).__init__(*args, **kw_args) + + _attrs = ["configID", "programID", "firmwareID", "password", "hardwareID"] + _attr_types = {"configID": str, "programID": str, "firmwareID": str, "password": str, "hardwareID": str} + _defaults = {"configID": '', "programID": '', "firmwareID": '', "password": '', "hardwareID": ''} + _enums = {} + _refs = ["Asset"] + _many_refs = [] def getAsset(self): diff --git a/schemata/CIM14/IEC61968/Assets/ComMediaAsset.py b/schemata/CIM14/IEC61968/Assets/ComMediaAsset.py index 7339721..0a0777e 100644 --- a/schemata/CIM14/IEC61968/Assets/ComMediaAsset.py +++ b/schemata/CIM14/IEC61968/Assets/ComMediaAsset.py @@ -20,9 +20,16 @@ class ComMediaAsset(Asset): """Communication media such as fibre optic cable, power-line, telephone, etc. """ - def __init__(self, **kw_args): - """Initializes a new 'ComMediaAsset' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'ComMediaAsset' instance. """ - super(ComMediaAsset, self).__init__(**kw_args) + super(ComMediaAsset, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Assets/Seal.py b/schemata/CIM14/IEC61968/Assets/Seal.py index 27d1987..affff26 100644 --- a/schemata/CIM14/IEC61968/Assets/Seal.py +++ b/schemata/CIM14/IEC61968/Assets/Seal.py @@ -20,8 +20,8 @@ class Seal(IdentifiedObject): """Physically controls access to AssetContainers. """ - def __init__(self, kind='other', condition='open', sealNumber='', appliedDateTime='', AssetContainer=None, **kw_args): - """Initializes a new 'Seal' instance. + def __init__(self, kind="other", condition="open", sealNumber='', appliedDateTime='', AssetContainer=None, *args, **kw_args): + """Initialises a new 'Seal' instance. @param kind: Kind of seal. Values are: "other", "lead", "steel", "lock" @param condition: Condition of seal. Values are: "open", "broken", "missing", "other", "locked" @@ -29,10 +29,10 @@ class Seal(IdentifiedObject): @param appliedDateTime: Date and time this seal has been applied. @param AssetContainer: Asset container to which this seal is applied. """ - #: Kind of seal.Values are: "other", "lead", "steel", "lock" + #: Kind of seal. Values are: "other", "lead", "steel", "lock" self.kind = kind - #: Condition of seal.Values are: "open", "broken", "missing", "other", "locked" + #: Condition of seal. Values are: "open", "broken", "missing", "other", "locked" self.condition = condition #: (reserved word) Seal number. @@ -44,7 +44,14 @@ class Seal(IdentifiedObject): self._AssetContainer = None self.AssetContainer = AssetContainer - super(Seal, self).__init__(**kw_args) + super(Seal, self).__init__(*args, **kw_args) + + _attrs = ["kind", "condition", "sealNumber", "appliedDateTime"] + _attr_types = {"kind": str, "condition": str, "sealNumber": str, "appliedDateTime": str} + _defaults = {"kind": "other", "condition": "open", "sealNumber": '', "appliedDateTime": ''} + _enums = {"kind": "SealKind", "condition": "SealConditionKind"} + _refs = ["AssetContainer"] + _many_refs = [] def getAssetContainer(self): """Asset container to which this seal is applied. diff --git a/schemata/CIM14/IEC61968/Common/ActivityRecord.py b/schemata/CIM14/IEC61968/Common/ActivityRecord.py index 5608749..0365d7a 100644 --- a/schemata/CIM14/IEC61968/Common/ActivityRecord.py +++ b/schemata/CIM14/IEC61968/Common/ActivityRecord.py @@ -20,8 +20,8 @@ class ActivityRecord(IdentifiedObject): """Records activity for an entity at a point in time; activity may be for an event that has already occurred or for a planned activity. """ - def __init__(self, reason='', createdDateTime='', severity='', category='', Documents=None, Assets=None, status=None, **kw_args): - """Initializes a new 'ActivityRecord' instance. + def __init__(self, reason='', createdDateTime='', severity='', category='', Documents=None, Assets=None, status=None, *args, **kw_args): + """Initialises a new 'ActivityRecord' instance. @param reason: Reason for event resulting in this activity record, typically supplied when user initiated. @param createdDateTime: Date and time this activity record has been created (different from the 'status.dateTime', which is the time of a status change of the associated object, if applicable). @@ -51,7 +51,14 @@ class ActivityRecord(IdentifiedObject): self.status = status - super(ActivityRecord, self).__init__(**kw_args) + super(ActivityRecord, self).__init__(*args, **kw_args) + + _attrs = ["reason", "createdDateTime", "severity", "category"] + _attr_types = {"reason": str, "createdDateTime": str, "severity": str, "category": str} + _defaults = {"reason": '', "createdDateTime": '', "severity": '', "category": ''} + _enums = {} + _refs = ["Documents", "Assets", "status"] + _many_refs = ["Documents", "Assets"] def getDocuments(self): """All documents for which this activity record has been created. diff --git a/schemata/CIM14/IEC61968/Common/Agreement.py b/schemata/CIM14/IEC61968/Common/Agreement.py index 45871b4..bffdfb6 100644 --- a/schemata/CIM14/IEC61968/Common/Agreement.py +++ b/schemata/CIM14/IEC61968/Common/Agreement.py @@ -20,8 +20,8 @@ class Agreement(Document): """Formal agreement between two parties defining the terms and conditions for a set of services. The specifics of the services are, in turn, defined via one or more service agreements. """ - def __init__(self, signDate='', validityInterval=None, **kw_args): - """Initializes a new 'Agreement' instance. + def __init__(self, signDate='', validityInterval=None, *args, **kw_args): + """Initialises a new 'Agreement' instance. @param signDate: Date this agreement was consummated among associated persons and/or organisations. @param validityInterval: Date and time interval this agreement is valid (from going into effect to termination). @@ -31,7 +31,14 @@ class Agreement(Document): self.validityInterval = validityInterval - super(Agreement, self).__init__(**kw_args) + super(Agreement, self).__init__(*args, **kw_args) + + _attrs = ["signDate"] + _attr_types = {"signDate": str} + _defaults = {"signDate": ''} + _enums = {} + _refs = ["validityInterval"] + _many_refs = [] # Date and time interval this agreement is valid (from going into effect to termination). validityInterval = None diff --git a/schemata/CIM14/IEC61968/Common/CoordinateSystem.py b/schemata/CIM14/IEC61968/Common/CoordinateSystem.py index 58c7148..13321a1 100644 --- a/schemata/CIM14/IEC61968/Common/CoordinateSystem.py +++ b/schemata/CIM14/IEC61968/Common/CoordinateSystem.py @@ -20,8 +20,8 @@ class CoordinateSystem(Element): """Coordinate reference system. """ - def __init__(self, name='', Location=None, PositionPoints=None, **kw_args): - """Initializes a new 'CoordinateSystem' instance. + def __init__(self, name='', Location=None, PositionPoints=None, *args, **kw_args): + """Initialises a new 'CoordinateSystem' instance. @param name: Name of this coordinate system. @param Location: Location described by using position points in this coordinate system. @@ -36,7 +36,14 @@ class CoordinateSystem(Element): self._PositionPoints = [] self.PositionPoints = [] if PositionPoints is None else PositionPoints - super(CoordinateSystem, self).__init__(**kw_args) + super(CoordinateSystem, self).__init__(*args, **kw_args) + + _attrs = ["name"] + _attr_types = {"name": str} + _defaults = {"name": ''} + _enums = {} + _refs = ["Location", "PositionPoints"] + _many_refs = ["PositionPoints"] def getLocation(self): """Location described by using position points in this coordinate system. diff --git a/schemata/CIM14/IEC61968/Common/DateTimeInterval.py b/schemata/CIM14/IEC61968/Common/DateTimeInterval.py index 06057cf..b92580e 100644 --- a/schemata/CIM14/IEC61968/Common/DateTimeInterval.py +++ b/schemata/CIM14/IEC61968/Common/DateTimeInterval.py @@ -20,8 +20,8 @@ class DateTimeInterval(Element): """Interval of date and time. """ - def __init__(self, end='', start='', **kw_args): - """Initializes a new 'DateTimeInterval' instance. + def __init__(self, end='', start='', *args, **kw_args): + """Initialises a new 'DateTimeInterval' instance. @param end: Date and time that this interval ended. @param start: Date and time that this interval started. @@ -32,5 +32,12 @@ class DateTimeInterval(Element): #: Date and time that this interval started. self.start = start - super(DateTimeInterval, self).__init__(**kw_args) + super(DateTimeInterval, self).__init__(*args, **kw_args) + + _attrs = ["end", "start"] + _attr_types = {"end": str, "start": str} + _defaults = {"end": '', "start": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Common/Document.py b/schemata/CIM14/IEC61968/Common/Document.py index 4d064dd..e19e5d5 100644 --- a/schemata/CIM14/IEC61968/Common/Document.py +++ b/schemata/CIM14/IEC61968/Common/Document.py @@ -20,8 +20,8 @@ class Document(IdentifiedObject): """Parent class for different groupings of information collected and managed as a part of a business process. It will frequently contain references to other objects, such as assets, people and power system resources. """ - def __init__(self, revisionNumber='', subject='', createdDateTime='', title='', category='', lastModifiedDateTime='', electronicAddress=None, status=None, ActivityRecords=None, docStatus=None, Measurements=None, **kw_args): - """Initializes a new 'Document' instance. + def __init__(self, revisionNumber='', subject='', createdDateTime='', title='', category='', lastModifiedDateTime='', electronicAddress=None, status=None, ActivityRecords=None, docStatus=None, Measurements=None, *args, **kw_args): + """Initialises a new 'Document' instance. @param revisionNumber: Revision number for this document. @param subject: Document subject. @@ -65,7 +65,14 @@ class Document(IdentifiedObject): self._Measurements = [] self.Measurements = [] if Measurements is None else Measurements - super(Document, self).__init__(**kw_args) + super(Document, self).__init__(*args, **kw_args) + + _attrs = ["revisionNumber", "subject", "createdDateTime", "title", "category", "lastModifiedDateTime"] + _attr_types = {"revisionNumber": str, "subject": str, "createdDateTime": str, "title": str, "category": str, "lastModifiedDateTime": str} + _defaults = {"revisionNumber": '', "subject": '', "createdDateTime": '', "title": '', "category": '', "lastModifiedDateTime": ''} + _enums = {} + _refs = ["electronicAddress", "status", "ActivityRecords", "docStatus", "Measurements"] + _many_refs = ["ActivityRecords", "Measurements"] # Electronic address. electronicAddress = None diff --git a/schemata/CIM14/IEC61968/Common/ElectronicAddress.py b/schemata/CIM14/IEC61968/Common/ElectronicAddress.py index 5ae1dc2..fca3c6b 100644 --- a/schemata/CIM14/IEC61968/Common/ElectronicAddress.py +++ b/schemata/CIM14/IEC61968/Common/ElectronicAddress.py @@ -20,8 +20,8 @@ class ElectronicAddress(Element): """Electronic address information. """ - def __init__(self, password='', email='', radio='', userID='', lan='', web='', status=None, **kw_args): - """Initializes a new 'ElectronicAddress' instance. + def __init__(self, password='', email='', radio='', userID='', lan='', web='', status=None, *args, **kw_args): + """Initialises a new 'ElectronicAddress' instance. @param password: Password needed to log in. @param email: Email address. @@ -51,7 +51,14 @@ class ElectronicAddress(Element): self.status = status - super(ElectronicAddress, self).__init__(**kw_args) + super(ElectronicAddress, self).__init__(*args, **kw_args) + + _attrs = ["password", "email", "radio", "userID", "lan", "web"] + _attr_types = {"password": str, "email": str, "radio": str, "userID": str, "lan": str, "web": str} + _defaults = {"password": '', "email": '', "radio": '', "userID": '', "lan": '', "web": ''} + _enums = {} + _refs = ["status"] + _many_refs = [] # Status of this electronic address. status = None diff --git a/schemata/CIM14/IEC61968/Common/Location.py b/schemata/CIM14/IEC61968/Common/Location.py index a5cacf1..25b9bfd 100644 --- a/schemata/CIM14/IEC61968/Common/Location.py +++ b/schemata/CIM14/IEC61968/Common/Location.py @@ -20,8 +20,8 @@ class Location(IdentifiedObject): """The place, scene, or point of something where someone or something has been, is, and/or will be at a given moment in time. It is defined with one or more postition points (coordinates) in a given coordinate system. """ - def __init__(self, geoInfoReference='', corporateCode='', direction='', category='', PositionPoints=None, PowerSystemResources=None, CoordinateSystems=None, Measurements=None, secondaryAddress=None, Assets=None, phone2=None, electronicAddress=None, phone1=None, mainAddress=None, status=None, **kw_args): - """Initializes a new 'Location' instance. + def __init__(self, geoInfoReference='', corporateCode='', direction='', category='', PositionPoints=None, PowerSystemResources=None, CoordinateSystems=None, Measurements=None, secondaryAddress=None, Assets=None, phone2=None, electronicAddress=None, phone1=None, mainAddress=None, status=None, *args, **kw_args): + """Initialises a new 'Location' instance. @param geoInfoReference: (if applicable) Reference to geographical information source, often external to the utility. @param corporateCode: Utility-specific code for the location. @@ -78,7 +78,14 @@ class Location(IdentifiedObject): self.status = status - super(Location, self).__init__(**kw_args) + super(Location, self).__init__(*args, **kw_args) + + _attrs = ["geoInfoReference", "corporateCode", "direction", "category"] + _attr_types = {"geoInfoReference": str, "corporateCode": str, "direction": str, "category": str} + _defaults = {"geoInfoReference": '', "corporateCode": '', "direction": '', "category": ''} + _enums = {} + _refs = ["PositionPoints", "PowerSystemResources", "CoordinateSystems", "Measurements", "secondaryAddress", "Assets", "phone2", "electronicAddress", "phone1", "mainAddress", "status"] + _many_refs = ["PositionPoints", "PowerSystemResources", "CoordinateSystems", "Measurements", "Assets"] def getPositionPoints(self): """Sequence of position points describing this location. diff --git a/schemata/CIM14/IEC61968/Common/Organisation.py b/schemata/CIM14/IEC61968/Common/Organisation.py index 6da8498..7b2395a 100644 --- a/schemata/CIM14/IEC61968/Common/Organisation.py +++ b/schemata/CIM14/IEC61968/Common/Organisation.py @@ -20,8 +20,8 @@ class Organisation(IdentifiedObject): """Organisation that might have roles as utility, contractor, supplier, manufacturer, customer, etc. """ - def __init__(self, electronicAddress=None, streetAddress=None, phone2=None, phone1=None, postalAddress=None, **kw_args): - """Initializes a new 'Organisation' instance. + def __init__(self, electronicAddress=None, streetAddress=None, phone2=None, phone1=None, postalAddress=None, *args, **kw_args): + """Initialises a new 'Organisation' instance. @param electronicAddress: Electronic address. @param streetAddress: Street address. @@ -39,7 +39,14 @@ class Organisation(IdentifiedObject): self.postalAddress = postalAddress - super(Organisation, self).__init__(**kw_args) + super(Organisation, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["electronicAddress", "streetAddress", "phone2", "phone1", "postalAddress"] + _many_refs = [] # Electronic address. electronicAddress = None diff --git a/schemata/CIM14/IEC61968/Common/PositionPoint.py b/schemata/CIM14/IEC61968/Common/PositionPoint.py index c5ff53d..aa704bf 100644 --- a/schemata/CIM14/IEC61968/Common/PositionPoint.py +++ b/schemata/CIM14/IEC61968/Common/PositionPoint.py @@ -20,8 +20,8 @@ class PositionPoint(Element): """Set of spatial coordinates that determine a point. Use a single position point instance to desribe a point-oriented location. Use a sequence of position points to describe a line-oriented object (physical location of non-point oriented objects like cables or lines), or area of an object (like a substation or a geographical zone - in this case, have first and last position point with the same values). """ - def __init__(self, xPosition='', zPosition='', sequenceNumber=0, yPosition='', Location=None, CoordinateSystem=None, **kw_args): - """Initializes a new 'PositionPoint' instance. + def __init__(self, xPosition='', zPosition='', sequenceNumber=0, yPosition='', Location=None, CoordinateSystem=None, *args, **kw_args): + """Initialises a new 'PositionPoint' instance. @param xPosition: X axis position. @param zPosition: (if applicable) Z axis position. @@ -48,7 +48,14 @@ class PositionPoint(Element): self._CoordinateSystem = None self.CoordinateSystem = CoordinateSystem - super(PositionPoint, self).__init__(**kw_args) + super(PositionPoint, self).__init__(*args, **kw_args) + + _attrs = ["xPosition", "zPosition", "sequenceNumber", "yPosition"] + _attr_types = {"xPosition": str, "zPosition": str, "sequenceNumber": int, "yPosition": str} + _defaults = {"xPosition": '', "zPosition": '', "sequenceNumber": 0, "yPosition": ''} + _enums = {} + _refs = ["Location", "CoordinateSystem"] + _many_refs = [] def getLocation(self): """Location that this position point describes. diff --git a/schemata/CIM14/IEC61968/Common/PostalAddress.py b/schemata/CIM14/IEC61968/Common/PostalAddress.py index d475c05..d584686 100644 --- a/schemata/CIM14/IEC61968/Common/PostalAddress.py +++ b/schemata/CIM14/IEC61968/Common/PostalAddress.py @@ -20,8 +20,8 @@ class PostalAddress(Element): """General purpose postal address information. """ - def __init__(self, poBox='', postalCode='', streetDetail=None, townDetail=None, **kw_args): - """Initializes a new 'PostalAddress' instance. + def __init__(self, poBox='', postalCode='', streetDetail=None, townDetail=None, *args, **kw_args): + """Initialises a new 'PostalAddress' instance. @param poBox: Post office box. @param postalCode: Postal code for the address. @@ -38,7 +38,14 @@ class PostalAddress(Element): self.townDetail = townDetail - super(PostalAddress, self).__init__(**kw_args) + super(PostalAddress, self).__init__(*args, **kw_args) + + _attrs = ["poBox", "postalCode"] + _attr_types = {"poBox": str, "postalCode": str} + _defaults = {"poBox": '', "postalCode": ''} + _enums = {} + _refs = ["streetDetail", "townDetail"] + _many_refs = [] # Street detail. streetDetail = None diff --git a/schemata/CIM14/IEC61968/Common/Status.py b/schemata/CIM14/IEC61968/Common/Status.py index 18b5761..319ea7e 100644 --- a/schemata/CIM14/IEC61968/Common/Status.py +++ b/schemata/CIM14/IEC61968/Common/Status.py @@ -20,8 +20,8 @@ class Status(Element): """Current status information relevant to an entity. """ - def __init__(self, reason='', remark='', value='', dateTime='', **kw_args): - """Initializes a new 'Status' instance. + def __init__(self, reason='', remark='', value='', dateTime='', *args, **kw_args): + """Initialises a new 'Status' instance. @param reason: Reason code or explanation for why an object went to the current status 'value'. @param remark: Pertinent information regarding the current 'value', as free form text. @@ -40,5 +40,12 @@ class Status(Element): #: Date and time for which status 'value' applies. self.dateTime = dateTime - super(Status, self).__init__(**kw_args) + super(Status, self).__init__(*args, **kw_args) + + _attrs = ["reason", "remark", "value", "dateTime"] + _attr_types = {"reason": str, "remark": str, "value": str, "dateTime": str} + _defaults = {"reason": '', "remark": '', "value": '', "dateTime": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Common/StreetAddress.py b/schemata/CIM14/IEC61968/Common/StreetAddress.py index 697827b..be924b6 100644 --- a/schemata/CIM14/IEC61968/Common/StreetAddress.py +++ b/schemata/CIM14/IEC61968/Common/StreetAddress.py @@ -20,8 +20,8 @@ class StreetAddress(Element): """General purpose street address information. """ - def __init__(self, status=None, townDetail=None, streetDetail=None, **kw_args): - """Initializes a new 'StreetAddress' instance. + def __init__(self, status=None, townDetail=None, streetDetail=None, *args, **kw_args): + """Initialises a new 'StreetAddress' instance. @param status: Status of this address. @param townDetail: Town detail. @@ -33,7 +33,14 @@ class StreetAddress(Element): self.streetDetail = streetDetail - super(StreetAddress, self).__init__(**kw_args) + super(StreetAddress, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["status", "townDetail", "streetDetail"] + _many_refs = [] # Status of this address. status = None diff --git a/schemata/CIM14/IEC61968/Common/StreetDetail.py b/schemata/CIM14/IEC61968/Common/StreetDetail.py index 367d429..be328bb 100644 --- a/schemata/CIM14/IEC61968/Common/StreetDetail.py +++ b/schemata/CIM14/IEC61968/Common/StreetDetail.py @@ -20,8 +20,8 @@ class StreetDetail(Element): """Street details, in the context of address. """ - def __init__(self, number='', type='', suiteNumber='', addressGeneral='', buildingName='', name='', withinTownLimits=False, suffix='', code='', prefix='', **kw_args): - """Initializes a new 'StreetDetail' instance. + def __init__(self, number='', type='', suiteNumber='', addressGeneral='', buildingName='', name='', withinTownLimits=False, suffix='', code='', prefix='', *args, **kw_args): + """Initialises a new 'StreetDetail' instance. @param number: Designator of the specific location on the street. @param type: Type of street. Examples include: street, circle, boulevard, avenue, road, drive, etc. @@ -64,5 +64,12 @@ class StreetDetail(Element): #: Prefix to the street name. For example: North, South, East, West. self.prefix = prefix - super(StreetDetail, self).__init__(**kw_args) + super(StreetDetail, self).__init__(*args, **kw_args) + + _attrs = ["number", "type", "suiteNumber", "addressGeneral", "buildingName", "name", "withinTownLimits", "suffix", "code", "prefix"] + _attr_types = {"number": str, "type": str, "suiteNumber": str, "addressGeneral": str, "buildingName": str, "name": str, "withinTownLimits": bool, "suffix": str, "code": str, "prefix": str} + _defaults = {"number": '', "type": '', "suiteNumber": '', "addressGeneral": '', "buildingName": '', "name": '', "withinTownLimits": False, "suffix": '', "code": '', "prefix": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Common/TelephoneNumber.py b/schemata/CIM14/IEC61968/Common/TelephoneNumber.py index 6181092..de4267e 100644 --- a/schemata/CIM14/IEC61968/Common/TelephoneNumber.py +++ b/schemata/CIM14/IEC61968/Common/TelephoneNumber.py @@ -20,8 +20,8 @@ class TelephoneNumber(Element): """Telephone number. """ - def __init__(self, countryCode='', cityCode='', areaCode='', localNumber='', extension='', **kw_args): - """Initializes a new 'TelephoneNumber' instance. + def __init__(self, countryCode='', cityCode='', areaCode='', localNumber='', extension='', *args, **kw_args): + """Initialises a new 'TelephoneNumber' instance. @param countryCode: Country code. @param cityCode: (if applicable) City code. @@ -44,5 +44,12 @@ class TelephoneNumber(Element): #: (if applicable) Extension for this telephone number. self.extension = extension - super(TelephoneNumber, self).__init__(**kw_args) + super(TelephoneNumber, self).__init__(*args, **kw_args) + + _attrs = ["countryCode", "cityCode", "areaCode", "localNumber", "extension"] + _attr_types = {"countryCode": str, "cityCode": str, "areaCode": str, "localNumber": str, "extension": str} + _defaults = {"countryCode": '', "cityCode": '', "areaCode": '', "localNumber": '', "extension": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Common/TimePoint.py b/schemata/CIM14/IEC61968/Common/TimePoint.py index 0aa9829..9c141d9 100644 --- a/schemata/CIM14/IEC61968/Common/TimePoint.py +++ b/schemata/CIM14/IEC61968/Common/TimePoint.py @@ -20,8 +20,8 @@ class TimePoint(IdentifiedObject): """A point in time within a sequence of points in time relative to a TimeSchedule. """ - def __init__(self, relativeTimeInterval=0.0, sequenceNumber=0, dateTime='', TimeSchedule=None, status=None, window=None, **kw_args): - """Initializes a new 'TimePoint' instance. + def __init__(self, relativeTimeInterval=0.0, sequenceNumber=0, dateTime='', TimeSchedule=None, status=None, window=None, *args, **kw_args): + """Initialises a new 'TimePoint' instance. @param relativeTimeInterval: (if interval-based) A point in time relative to scheduled start time in 'TimeSchedule.scheduleInterval.start'. @param sequenceNumber: (if sequence-based) Relative sequence number for this time point. @@ -46,7 +46,14 @@ class TimePoint(IdentifiedObject): self.window = window - super(TimePoint, self).__init__(**kw_args) + super(TimePoint, self).__init__(*args, **kw_args) + + _attrs = ["relativeTimeInterval", "sequenceNumber", "dateTime"] + _attr_types = {"relativeTimeInterval": float, "sequenceNumber": int, "dateTime": str} + _defaults = {"relativeTimeInterval": 0.0, "sequenceNumber": 0, "dateTime": ''} + _enums = {} + _refs = ["TimeSchedule", "status", "window"] + _many_refs = [] def getTimeSchedule(self): """Time schedule owning this time point. diff --git a/schemata/CIM14/IEC61968/Common/TimeSchedule.py b/schemata/CIM14/IEC61968/Common/TimeSchedule.py index 7de720f..8111dbd 100644 --- a/schemata/CIM14/IEC61968/Common/TimeSchedule.py +++ b/schemata/CIM14/IEC61968/Common/TimeSchedule.py @@ -20,8 +20,8 @@ class TimeSchedule(Document): """Description of anything that changes through time. Time schedule is used to perform a single-valued function of time. Use inherited 'category' attribute to give additional information on this schedule, such as: periodic (hourly, daily, weekly, monthly, etc.), day of the month, by date, calendar (specific times and dates). """ - def __init__(self, recurrencePeriod=0.0, disabled=False, offset=0.0, recurrencePattern='', TimePoints=None, scheduleInterval=None, **kw_args): - """Initializes a new 'TimeSchedule' instance. + def __init__(self, recurrencePeriod=0.0, disabled=False, offset=0.0, recurrencePattern='', TimePoints=None, scheduleInterval=None, *args, **kw_args): + """Initialises a new 'TimeSchedule' instance. @param recurrencePeriod: Duration between time points, from the beginning of one period to the beginning of the next period. Note that a device like a meter may have multiple interval periods (e.g., 1 min, 5 min, 15 min, 30 min, or 60 min). @param disabled: True if this schedule is deactivated (disabled). @@ -47,7 +47,14 @@ class TimeSchedule(Document): self.scheduleInterval = scheduleInterval - super(TimeSchedule, self).__init__(**kw_args) + super(TimeSchedule, self).__init__(*args, **kw_args) + + _attrs = ["recurrencePeriod", "disabled", "offset", "recurrencePattern"] + _attr_types = {"recurrencePeriod": float, "disabled": bool, "offset": float, "recurrencePattern": str} + _defaults = {"recurrencePeriod": 0.0, "disabled": False, "offset": 0.0, "recurrencePattern": ''} + _enums = {} + _refs = ["TimePoints", "scheduleInterval"] + _many_refs = ["TimePoints"] def getTimePoints(self): """Sequence of time points belonging to this time schedule. diff --git a/schemata/CIM14/IEC61968/Common/TownDetail.py b/schemata/CIM14/IEC61968/Common/TownDetail.py index 2e6acca..fe8bcca 100644 --- a/schemata/CIM14/IEC61968/Common/TownDetail.py +++ b/schemata/CIM14/IEC61968/Common/TownDetail.py @@ -20,8 +20,8 @@ class TownDetail(Element): """Town details, in the context of address. """ - def __init__(self, code='', country='', stateOrProvince='', name='', section='', **kw_args): - """Initializes a new 'TownDetail' instance. + def __init__(self, code='', country='', stateOrProvince='', name='', section='', *args, **kw_args): + """Initialises a new 'TownDetail' instance. @param code: Town code. @param country: Name of the country. @@ -44,5 +44,12 @@ class TownDetail(Element): #: Town section. For example, it is common for there to be 36 sections per township. self.section = section - super(TownDetail, self).__init__(**kw_args) + super(TownDetail, self).__init__(*args, **kw_args) + + _attrs = ["code", "country", "stateOrProvince", "name", "section"] + _attr_types = {"code": str, "country": str, "stateOrProvince": str, "name": str, "section": str} + _defaults = {"code": '', "country": '', "stateOrProvince": '', "name": '', "section": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Common/UserAttribute.py b/schemata/CIM14/IEC61968/Common/UserAttribute.py index 116e37b..c23df51 100644 --- a/schemata/CIM14/IEC61968/Common/UserAttribute.py +++ b/schemata/CIM14/IEC61968/Common/UserAttribute.py @@ -20,8 +20,8 @@ class UserAttribute(Element): """Generic name-value pair class, with optional sequence number and units for value; can be used to model parts of information exchange when concrete types are not known in advance. """ - def __init__(self, value='', sequenceNumber=0, name='', PropertyAssets=None, Transaction=None, RatingAssets=None, **kw_args): - """Initializes a new 'UserAttribute' instance. + def __init__(self, value='', sequenceNumber=0, name='', PropertyAssets=None, Transaction=None, RatingAssets=None, *args, **kw_args): + """Initialises a new 'UserAttribute' instance. @param value: Value of an attribute, including unit information. @param sequenceNumber: Sequence number for this attribute in a list of attributes. @@ -48,7 +48,14 @@ class UserAttribute(Element): self._RatingAssets = [] self.RatingAssets = [] if RatingAssets is None else RatingAssets - super(UserAttribute, self).__init__(**kw_args) + super(UserAttribute, self).__init__(*args, **kw_args) + + _attrs = ["value", "sequenceNumber", "name"] + _attr_types = {"value": str, "sequenceNumber": int, "name": str} + _defaults = {"value": '', "sequenceNumber": 0, "name": ''} + _enums = {} + _refs = ["PropertyAssets", "Transaction", "RatingAssets"] + _many_refs = ["PropertyAssets", "RatingAssets"] def getPropertyAssets(self): diff --git a/schemata/CIM14/IEC61968/Customers/Customer.py b/schemata/CIM14/IEC61968/Customers/Customer.py index 4fdd8cf..6510cde 100644 --- a/schemata/CIM14/IEC61968/Customers/Customer.py +++ b/schemata/CIM14/IEC61968/Customers/Customer.py @@ -20,8 +20,8 @@ class Customer(Organisation): """Organisation receiving services from ServiceSupplier. """ - def __init__(self, kind='residentialAndCommercial', pucNumber='', specialNeed='', vip=False, status=None, Works=None, CustomerAgreements=None, EndDeviceAssets=None, **kw_args): - """Initializes a new 'Customer' instance. + def __init__(self, kind="residentialAndCommercial", pucNumber='', specialNeed='', vip=False, status=None, Works=None, CustomerAgreements=None, EndDeviceAssets=None, *args, **kw_args): + """Initialises a new 'Customer' instance. @param kind: Kind of customer. Values are: "residentialAndCommercial", "residentialStreetlightOthers", "residentialAndStreetlight", "pumpingLoad", "energyServiceSupplier", "windMachine", "residential", "internalUse", "residentialFarmService", "other", "energyServiceScheduler", "commercialIndustrial" @param pucNumber: (if applicable) Public Utility Commission identification number. @@ -32,7 +32,7 @@ class Customer(Organisation): @param CustomerAgreements: All agreements of this customer. @param EndDeviceAssets: All end device assets of this customer. """ - #: Kind of customer.Values are: "residentialAndCommercial", "residentialStreetlightOthers", "residentialAndStreetlight", "pumpingLoad", "energyServiceSupplier", "windMachine", "residential", "internalUse", "residentialFarmService", "other", "energyServiceScheduler", "commercialIndustrial" + #: Kind of customer. Values are: "residentialAndCommercial", "residentialStreetlightOthers", "residentialAndStreetlight", "pumpingLoad", "energyServiceSupplier", "windMachine", "residential", "internalUse", "residentialFarmService", "other", "energyServiceScheduler", "commercialIndustrial" self.kind = kind #: (if applicable) Public Utility Commission identification number. @@ -55,7 +55,14 @@ class Customer(Organisation): self._EndDeviceAssets = [] self.EndDeviceAssets = [] if EndDeviceAssets is None else EndDeviceAssets - super(Customer, self).__init__(**kw_args) + super(Customer, self).__init__(*args, **kw_args) + + _attrs = ["kind", "pucNumber", "specialNeed", "vip"] + _attr_types = {"kind": str, "pucNumber": str, "specialNeed": str, "vip": bool} + _defaults = {"kind": "residentialAndCommercial", "pucNumber": '', "specialNeed": '', "vip": False} + _enums = {"kind": "CustomerKind"} + _refs = ["status", "Works", "CustomerAgreements", "EndDeviceAssets"] + _many_refs = ["Works", "CustomerAgreements", "EndDeviceAssets"] # Status of this customer. status = None diff --git a/schemata/CIM14/IEC61968/Customers/CustomerAccount.py b/schemata/CIM14/IEC61968/Customers/CustomerAccount.py index 9797cb9..b3118c2 100644 --- a/schemata/CIM14/IEC61968/Customers/CustomerAccount.py +++ b/schemata/CIM14/IEC61968/Customers/CustomerAccount.py @@ -20,8 +20,8 @@ class CustomerAccount(Document): """Assignment of a group of products and services purchased by the Customer through a CustomerAgreement, used as a mechanism for customer billing and payment. It contains common information from the various types of CustomerAgreements to create billings (invoices) for a Customer and receive payment. """ - def __init__(self, PaymentTransactions=None, CustomerAgreements=None, **kw_args): - """Initializes a new 'CustomerAccount' instance. + def __init__(self, PaymentTransactions=None, CustomerAgreements=None, *args, **kw_args): + """Initialises a new 'CustomerAccount' instance. @param PaymentTransactions: All payment transactions for this customer account. @param CustomerAgreements: All agreements for this customer account. @@ -32,7 +32,14 @@ class CustomerAccount(Document): self._CustomerAgreements = [] self.CustomerAgreements = [] if CustomerAgreements is None else CustomerAgreements - super(CustomerAccount, self).__init__(**kw_args) + super(CustomerAccount, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["PaymentTransactions", "CustomerAgreements"] + _many_refs = ["PaymentTransactions", "CustomerAgreements"] def getPaymentTransactions(self): """All payment transactions for this customer account. diff --git a/schemata/CIM14/IEC61968/Customers/CustomerAgreement.py b/schemata/CIM14/IEC61968/Customers/CustomerAgreement.py index ca6d5e5..c06d841 100644 --- a/schemata/CIM14/IEC61968/Customers/CustomerAgreement.py +++ b/schemata/CIM14/IEC61968/Customers/CustomerAgreement.py @@ -20,8 +20,8 @@ class CustomerAgreement(Agreement): """Agreement between the Customer and the ServiceSupplier to pay for service at a specific ServiceLocation. It records certain billing information about the type of service provided at the ServiceLocation and is used during charge creation to determine the type of service. """ - def __init__(self, loadMgmt='', budgetBill='', billingCycle='', DemandResponseProgram=None, ServiceSupplier=None, PricingStructures=None, ServiceLocations=None, ServiceCategory=None, MeterReadings=None, CustomerAccount=None, AuxiliaryAgreements=None, EndDeviceControls=None, Customer=None, ServiceDeliveryPoints=None, Equipments=None, **kw_args): - """Initializes a new 'CustomerAgreement' instance. + def __init__(self, loadMgmt='', budgetBill='', billingCycle='', DemandResponseProgram=None, ServiceSupplier=None, PricingStructures=None, ServiceLocations=None, ServiceCategory=None, MeterReadings=None, CustomerAccount=None, AuxiliaryAgreements=None, EndDeviceControls=None, Customer=None, ServiceDeliveryPoints=None, Equipments=None, *args, **kw_args): + """Initialises a new 'CustomerAgreement' instance. @param loadMgmt: Load management code. @param budgetBill: Budget bill code. @@ -84,7 +84,14 @@ class CustomerAgreement(Agreement): self._Equipments = [] self.Equipments = [] if Equipments is None else Equipments - super(CustomerAgreement, self).__init__(**kw_args) + super(CustomerAgreement, self).__init__(*args, **kw_args) + + _attrs = ["loadMgmt", "budgetBill", "billingCycle"] + _attr_types = {"loadMgmt": str, "budgetBill": str, "billingCycle": str} + _defaults = {"loadMgmt": '', "budgetBill": '', "billingCycle": ''} + _enums = {} + _refs = ["DemandResponseProgram", "ServiceSupplier", "PricingStructures", "ServiceLocations", "ServiceCategory", "MeterReadings", "CustomerAccount", "AuxiliaryAgreements", "EndDeviceControls", "Customer", "ServiceDeliveryPoints", "Equipments"] + _many_refs = ["PricingStructures", "ServiceLocations", "MeterReadings", "AuxiliaryAgreements", "EndDeviceControls", "ServiceDeliveryPoints", "Equipments"] def getDemandResponseProgram(self): """Demand response program for this customer agreement. diff --git a/schemata/CIM14/IEC61968/Customers/PricingStructure.py b/schemata/CIM14/IEC61968/Customers/PricingStructure.py index bb7fbde..8eedc12 100644 --- a/schemata/CIM14/IEC61968/Customers/PricingStructure.py +++ b/schemata/CIM14/IEC61968/Customers/PricingStructure.py @@ -20,8 +20,8 @@ class PricingStructure(Document): """Grouping of pricing components and prices used in the creation of customer charges and the eligibility criteria under which these terms may be offered to a customer. The reasons for grouping include state, customer classification, site characteristics, classification (i.e. fee price structure, deposit price structure, electric service price structure, etc.) and accounting requirements. """ - def __init__(self, revenueKind='industrial', code='', dailyFloorUsage=0, taxExemption=False, dailyEstimatedUsage=0, dailyCeilingUsage=0, Transactions=None, ServiceDeliveryPoints=None, CustomerAgreements=None, ServiceCategory=None, Tariffs=None, **kw_args): - """Initializes a new 'PricingStructure' instance. + def __init__(self, revenueKind="industrial", code='', dailyFloorUsage=0, taxExemption=False, dailyEstimatedUsage=0, dailyCeilingUsage=0, Transactions=None, ServiceDeliveryPoints=None, CustomerAgreements=None, ServiceCategory=None, Tariffs=None, *args, **kw_args): + """Initialises a new 'PricingStructure' instance. @param revenueKind: (Accounting) Kind of revenue, often used to determine the grace period allowed, before collection actions are taken on a customer (grace periods vary between revenue classes). Values are: "industrial", "streetLight", "other", "nonResidential", "irrigation", "residential", "commercial" @param code: Unique user-allocated key for this pricing structure, used by company representatives to identify the correct price structure for allocating to a customer. For rate schedules it is often prefixed by a state code. @@ -35,7 +35,7 @@ class PricingStructure(Document): @param ServiceCategory: Service category to which this pricing structure applies. @param Tariffs: All tariffs used by this pricing structure. """ - #: (Accounting) Kind of revenue, often used to determine the grace period allowed, before collection actions are taken on a customer (grace periods vary between revenue classes).Values are: "industrial", "streetLight", "other", "nonResidential", "irrigation", "residential", "commercial" + #: (Accounting) Kind of revenue, often used to determine the grace period allowed, before collection actions are taken on a customer (grace periods vary between revenue classes). Values are: "industrial", "streetLight", "other", "nonResidential", "irrigation", "residential", "commercial" self.revenueKind = revenueKind #: Unique user-allocated key for this pricing structure, used by company representatives to identify the correct price structure for allocating to a customer. For rate schedules it is often prefixed by a state code. @@ -68,7 +68,14 @@ class PricingStructure(Document): self._Tariffs = [] self.Tariffs = [] if Tariffs is None else Tariffs - super(PricingStructure, self).__init__(**kw_args) + super(PricingStructure, self).__init__(*args, **kw_args) + + _attrs = ["revenueKind", "code", "dailyFloorUsage", "taxExemption", "dailyEstimatedUsage", "dailyCeilingUsage"] + _attr_types = {"revenueKind": str, "code": str, "dailyFloorUsage": int, "taxExemption": bool, "dailyEstimatedUsage": int, "dailyCeilingUsage": int} + _defaults = {"revenueKind": "industrial", "code": '', "dailyFloorUsage": 0, "taxExemption": False, "dailyEstimatedUsage": 0, "dailyCeilingUsage": 0} + _enums = {"revenueKind": "RevenueKind"} + _refs = ["Transactions", "ServiceDeliveryPoints", "CustomerAgreements", "ServiceCategory", "Tariffs"] + _many_refs = ["Transactions", "ServiceDeliveryPoints", "CustomerAgreements", "Tariffs"] def getTransactions(self): """All transactions applying this pricing structure. diff --git a/schemata/CIM14/IEC61968/Customers/ServiceCategory.py b/schemata/CIM14/IEC61968/Customers/ServiceCategory.py index ca7e406..b10968c 100644 --- a/schemata/CIM14/IEC61968/Customers/ServiceCategory.py +++ b/schemata/CIM14/IEC61968/Customers/ServiceCategory.py @@ -20,15 +20,15 @@ class ServiceCategory(IdentifiedObject): """Category of service provided to the customer. """ - def __init__(self, kind='water', CustomerAgreements=None, PricingStructures=None, ServiceDeliveryPoints=None, **kw_args): - """Initializes a new 'ServiceCategory' instance. + def __init__(self, kind="water", CustomerAgreements=None, PricingStructures=None, ServiceDeliveryPoints=None, *args, **kw_args): + """Initialises a new 'ServiceCategory' instance. @param kind: Kind of service. Values are: "water", "time", "electricity", "heat", "rates", "gas", "internet", "refuse", "other", "tvLicence", "sewerage" @param CustomerAgreements: @param PricingStructures: All pricing structures applicable to this service category. @param ServiceDeliveryPoints: All service delivery points that deliver this category of service. """ - #: Kind of service.Values are: "water", "time", "electricity", "heat", "rates", "gas", "internet", "refuse", "other", "tvLicence", "sewerage" + #: Kind of service. Values are: "water", "time", "electricity", "heat", "rates", "gas", "internet", "refuse", "other", "tvLicence", "sewerage" self.kind = kind self._CustomerAgreements = [] @@ -40,7 +40,14 @@ class ServiceCategory(IdentifiedObject): self._ServiceDeliveryPoints = [] self.ServiceDeliveryPoints = [] if ServiceDeliveryPoints is None else ServiceDeliveryPoints - super(ServiceCategory, self).__init__(**kw_args) + super(ServiceCategory, self).__init__(*args, **kw_args) + + _attrs = ["kind"] + _attr_types = {"kind": str} + _defaults = {"kind": "water"} + _enums = {"kind": "ServiceKind"} + _refs = ["CustomerAgreements", "PricingStructures", "ServiceDeliveryPoints"] + _many_refs = ["CustomerAgreements", "PricingStructures", "ServiceDeliveryPoints"] def getCustomerAgreements(self): diff --git a/schemata/CIM14/IEC61968/Customers/ServiceLocation.py b/schemata/CIM14/IEC61968/Customers/ServiceLocation.py index cfff511..85308f8 100644 --- a/schemata/CIM14/IEC61968/Customers/ServiceLocation.py +++ b/schemata/CIM14/IEC61968/Customers/ServiceLocation.py @@ -20,8 +20,8 @@ class ServiceLocation(Location): """A customer ServiceLocation has one or more ServiceDeliveryPoint(s), which in turn relate to Meters. The location may be a point or a polygon, depending on the specific circumstances. For distribution, the ServiceLocation is typically the location of the utility customer's premise. Because a customer's premise may have one or more meters, the ServiceDeliveryPoint is used to define the actual conducting equipment that the EndDeviceAsset attaches to at the utility customer's ServiceLocation. For transmission, it is the point(s) of interconnection on the transmission provider's transmission system where capacity and/or energy transmitted by the transmission provider is made available to the receiving party. """ - def __init__(self, siteAccessProblem='', accessMethod='', needsInspection=False, EndDeviceAssets=None, CustomerAgreements=None, ServiceDeliveryPoints=None, **kw_args): - """Initializes a new 'ServiceLocation' instance. + def __init__(self, siteAccessProblem='', accessMethod='', needsInspection=False, EndDeviceAssets=None, CustomerAgreements=None, ServiceDeliveryPoints=None, *args, **kw_args): + """Initialises a new 'ServiceLocation' instance. @param siteAccessProblem: Problems previously encountered when visiting or performing work on this site. Examples include: bad dog, violent customer, verbally abusive occupant, obstructions, safety hazards, etc. @param accessMethod: Method for the service person to access the appropriate service locations. For example, a description of where to obtain a key if the facility is unmanned and secured. @@ -48,7 +48,14 @@ class ServiceLocation(Location): self._ServiceDeliveryPoints = [] self.ServiceDeliveryPoints = [] if ServiceDeliveryPoints is None else ServiceDeliveryPoints - super(ServiceLocation, self).__init__(**kw_args) + super(ServiceLocation, self).__init__(*args, **kw_args) + + _attrs = ["siteAccessProblem", "accessMethod", "needsInspection"] + _attr_types = {"siteAccessProblem": str, "accessMethod": str, "needsInspection": bool} + _defaults = {"siteAccessProblem": '', "accessMethod": '', "needsInspection": False} + _enums = {} + _refs = ["EndDeviceAssets", "CustomerAgreements", "ServiceDeliveryPoints"] + _many_refs = ["EndDeviceAssets", "CustomerAgreements", "ServiceDeliveryPoints"] def getEndDeviceAssets(self): """All end device assets that measure the service delivered to this service location. diff --git a/schemata/CIM14/IEC61968/Customers/Tariff.py b/schemata/CIM14/IEC61968/Customers/Tariff.py index 3101d12..292d565 100644 --- a/schemata/CIM14/IEC61968/Customers/Tariff.py +++ b/schemata/CIM14/IEC61968/Customers/Tariff.py @@ -20,8 +20,8 @@ class Tariff(Document): """Document, approved by the responsible regulatory agency, listing the terms and conditions, including a schedule of prices, under which utility services will be provided. It has a unique number within the state or province. For Rate Schedules it is frequently allocated by the affiliated Public Utilities Commission. """ - def __init__(self, startDate='', endDate='', TariffProfiles=None, PricingStructures=None, **kw_args): - """Initializes a new 'Tariff' instance. + def __init__(self, startDate='', endDate='', TariffProfiles=None, PricingStructures=None, *args, **kw_args): + """Initialises a new 'Tariff' instance. @param startDate: Date tariff was activated. @param endDate: (if tariff became inactive) Date tariff was terminated. @@ -40,7 +40,14 @@ class Tariff(Document): self._PricingStructures = [] self.PricingStructures = [] if PricingStructures is None else PricingStructures - super(Tariff, self).__init__(**kw_args) + super(Tariff, self).__init__(*args, **kw_args) + + _attrs = ["startDate", "endDate"] + _attr_types = {"startDate": str, "endDate": str} + _defaults = {"startDate": '', "endDate": ''} + _enums = {} + _refs = ["TariffProfiles", "PricingStructures"] + _many_refs = ["TariffProfiles", "PricingStructures"] def getTariffProfiles(self): """All tariff profiles using this tariff. diff --git a/schemata/CIM14/IEC61968/IEC61968CIMVersion.py b/schemata/CIM14/IEC61968/IEC61968CIMVersion.py index 4ee3b1e..5fc2095 100644 --- a/schemata/CIM14/IEC61968/IEC61968CIMVersion.py +++ b/schemata/CIM14/IEC61968/IEC61968CIMVersion.py @@ -20,8 +20,8 @@ class IEC61968CIMVersion(Element): """IEC 61968 version number assigned to this UML model. """ - def __init__(self, date='', version='', **kw_args): - """Initializes a new 'IEC61968CIMVersion' instance. + def __init__(self, date='', version='', *args, **kw_args): + """Initialises a new 'IEC61968CIMVersion' instance. @param date: Form is YYYY-MM-DD for example for January 5, 2009 it is 2009-01-05. @param version: Form is IEC61968CIMXXvYY where XX is the major CIM package version and the YY is the minor version. For example IEC61968CIM10v17. @@ -32,5 +32,12 @@ class IEC61968CIMVersion(Element): #: Form is IEC61968CIMXXvYY where XX is the major CIM package version and the YY is the minor version. For example IEC61968CIM10v17. self.version = version - super(IEC61968CIMVersion, self).__init__(**kw_args) + super(IEC61968CIMVersion, self).__init__(*args, **kw_args) + + _attrs = ["date", "version"] + _attr_types = {"date": str, "version": str} + _defaults = {"date": '', "version": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/LoadControl/ConnectDisconnectFunction.py b/schemata/CIM14/IEC61968/LoadControl/ConnectDisconnectFunction.py index d39c5c9..239bb29 100644 --- a/schemata/CIM14/IEC61968/LoadControl/ConnectDisconnectFunction.py +++ b/schemata/CIM14/IEC61968/LoadControl/ConnectDisconnectFunction.py @@ -20,8 +20,8 @@ class ConnectDisconnectFunction(DeviceFunction): """A function that will disconnect or reconnect the customer's load under defined conditions. """ - def __init__(self, isLocalAutoReconOp=False, isLocalAutoDisconOp=False, isRemoteAutoReconOp=False, isRemoteAutoDisconOp=False, isConnected=False, eventCount=0, isDelayedDiscon=False, rcdInfo=None, Switches=None, **kw_args): - """Initializes a new 'ConnectDisconnectFunction' instance. + def __init__(self, isLocalAutoReconOp=False, isLocalAutoDisconOp=False, isRemoteAutoReconOp=False, isRemoteAutoDisconOp=False, isConnected=False, eventCount=0, isDelayedDiscon=False, rcdInfo=None, Switches=None, *args, **kw_args): + """Initialises a new 'ConnectDisconnectFunction' instance. @param isLocalAutoReconOp: If set true and if reconnection can be operated locally, then the operation happens automatically. Otherwise, it is manually. @param isLocalAutoDisconOp: (if disconnection can be operated locally) If set true, the operation happens automatically, otherwise it happens manually. @@ -59,7 +59,14 @@ class ConnectDisconnectFunction(DeviceFunction): self._Switches = [] self.Switches = [] if Switches is None else Switches - super(ConnectDisconnectFunction, self).__init__(**kw_args) + super(ConnectDisconnectFunction, self).__init__(*args, **kw_args) + + _attrs = ["isLocalAutoReconOp", "isLocalAutoDisconOp", "isRemoteAutoReconOp", "isRemoteAutoDisconOp", "isConnected", "eventCount", "isDelayedDiscon"] + _attr_types = {"isLocalAutoReconOp": bool, "isLocalAutoDisconOp": bool, "isRemoteAutoReconOp": bool, "isRemoteAutoDisconOp": bool, "isConnected": bool, "eventCount": int, "isDelayedDiscon": bool} + _defaults = {"isLocalAutoReconOp": False, "isLocalAutoDisconOp": False, "isRemoteAutoReconOp": False, "isRemoteAutoDisconOp": False, "isConnected": False, "eventCount": 0, "isDelayedDiscon": False} + _enums = {} + _refs = ["rcdInfo", "Switches"] + _many_refs = ["Switches"] # Information on remote connect disconnect switch. rcdInfo = None diff --git a/schemata/CIM14/IEC61968/LoadControl/RemoteConnectDisconnectInfo.py b/schemata/CIM14/IEC61968/LoadControl/RemoteConnectDisconnectInfo.py index 7968b4d..b5e38cd 100644 --- a/schemata/CIM14/IEC61968/LoadControl/RemoteConnectDisconnectInfo.py +++ b/schemata/CIM14/IEC61968/LoadControl/RemoteConnectDisconnectInfo.py @@ -20,8 +20,8 @@ class RemoteConnectDisconnectInfo(Element): """Details of remote connect disconnect function. """ - def __init__(self, needsPowerLimitCheck=False, isEnergyLimiting=False, isArmConnect=False, energyUsageWarning=0.0, armedTimeout=0.0, energyUsageStartDateTime='', isArmDisconnect=False, needsVoltageLimitCheck=False, powerLimit=0.0, usePushbutton=False, customerVoltageLimit=0.0, energyLimit=0.0, **kw_args): - """Initializes a new 'RemoteConnectDisconnectInfo' instance. + def __init__(self, needsPowerLimitCheck=False, isEnergyLimiting=False, isArmConnect=False, energyUsageWarning=0.0, armedTimeout=0.0, energyUsageStartDateTime='', isArmDisconnect=False, needsVoltageLimitCheck=False, powerLimit=0.0, usePushbutton=False, customerVoltageLimit=0.0, energyLimit=0.0, *args, **kw_args): + """Initialises a new 'RemoteConnectDisconnectInfo' instance. @param needsPowerLimitCheck: True if load limit must be checked to issue an immediate disconnect (after a connect) if load is over the limit. @param isEnergyLimiting: True if the energy usage is limited and the customer will be disconnected if they go over the limit. @@ -72,5 +72,12 @@ class RemoteConnectDisconnectInfo(Element): #: Limit of energy before disconnect. self.energyLimit = energyLimit - super(RemoteConnectDisconnectInfo, self).__init__(**kw_args) + super(RemoteConnectDisconnectInfo, self).__init__(*args, **kw_args) + + _attrs = ["needsPowerLimitCheck", "isEnergyLimiting", "isArmConnect", "energyUsageWarning", "armedTimeout", "energyUsageStartDateTime", "isArmDisconnect", "needsVoltageLimitCheck", "powerLimit", "usePushbutton", "customerVoltageLimit", "energyLimit"] + _attr_types = {"needsPowerLimitCheck": bool, "isEnergyLimiting": bool, "isArmConnect": bool, "energyUsageWarning": float, "armedTimeout": float, "energyUsageStartDateTime": str, "isArmDisconnect": bool, "needsVoltageLimitCheck": bool, "powerLimit": float, "usePushbutton": bool, "customerVoltageLimit": float, "energyLimit": float} + _defaults = {"needsPowerLimitCheck": False, "isEnergyLimiting": False, "isArmConnect": False, "energyUsageWarning": 0.0, "armedTimeout": 0.0, "energyUsageStartDateTime": '', "isArmDisconnect": False, "needsVoltageLimitCheck": False, "powerLimit": 0.0, "usePushbutton": False, "customerVoltageLimit": 0.0, "energyLimit": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Metering/ComFunction.py b/schemata/CIM14/IEC61968/Metering/ComFunction.py index b6f5385..3a19e48 100644 --- a/schemata/CIM14/IEC61968/Metering/ComFunction.py +++ b/schemata/CIM14/IEC61968/Metering/ComFunction.py @@ -20,8 +20,8 @@ class ComFunction(DeviceFunction): """Communication function of communication equipment or a device such as a meter. """ - def __init__(self, amrRouter='', twoWay=False, amrAddress='', **kw_args): - """Initializes a new 'ComFunction' instance. + def __init__(self, amrRouter='', twoWay=False, amrAddress='', *args, **kw_args): + """Initialises a new 'ComFunction' instance. @param amrRouter: Communication ID number (e.g. port number, serial number, data collector ID, etc.) of the parent device associated to this AMR module. Note: If someone swaps out a meter, they may inadvertently disrupt the AMR system. Some technologies route readings from nearby meters through a common collection point on an electricity meter. Removal of such a meter disrupts AMR for numerous nearby meters. @param twoWay: True when the AMR module can both send and receive messages. Default is false (i.e., module can only send). @@ -36,5 +36,12 @@ class ComFunction(DeviceFunction): #: Communication ID number (e.g. serial number, IP address, telephone number, etc.) of the AMR module which serves this meter. self.amrAddress = amrAddress - super(ComFunction, self).__init__(**kw_args) + super(ComFunction, self).__init__(*args, **kw_args) + + _attrs = ["amrRouter", "twoWay", "amrAddress"] + _attr_types = {"amrRouter": str, "twoWay": bool, "amrAddress": str} + _defaults = {"amrRouter": '', "twoWay": False, "amrAddress": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Metering/DemandResponseProgram.py b/schemata/CIM14/IEC61968/Metering/DemandResponseProgram.py index 64bee4c..4da4635 100644 --- a/schemata/CIM14/IEC61968/Metering/DemandResponseProgram.py +++ b/schemata/CIM14/IEC61968/Metering/DemandResponseProgram.py @@ -20,8 +20,8 @@ class DemandResponseProgram(IdentifiedObject): """Demand response program. """ - def __init__(self, type='', CustomerAgreements=None, EndDeviceControls=None, validityInterval=None, EndDeviceGroups=None, **kw_args): - """Initializes a new 'DemandResponseProgram' instance. + def __init__(self, type='', CustomerAgreements=None, EndDeviceControls=None, validityInterval=None, EndDeviceGroups=None, *args, **kw_args): + """Initialises a new 'DemandResponseProgram' instance. @param type: Type of demand response program; examples are CPP (critical-peak pricing), RTP (real-time pricing), DLC (direct load control), DBP (demand bidding program), BIP (base interruptible program). Note that possible types change a lot and it would be impossible to enumerate them all. @param CustomerAgreements: All customer agreements with this demand response program. @@ -43,7 +43,14 @@ class DemandResponseProgram(IdentifiedObject): self._EndDeviceGroups = [] self.EndDeviceGroups = [] if EndDeviceGroups is None else EndDeviceGroups - super(DemandResponseProgram, self).__init__(**kw_args) + super(DemandResponseProgram, self).__init__(*args, **kw_args) + + _attrs = ["type"] + _attr_types = {"type": str} + _defaults = {"type": ''} + _enums = {} + _refs = ["CustomerAgreements", "EndDeviceControls", "validityInterval", "EndDeviceGroups"] + _many_refs = ["CustomerAgreements", "EndDeviceControls", "EndDeviceGroups"] def getCustomerAgreements(self): """All customer agreements with this demand response program. diff --git a/schemata/CIM14/IEC61968/Metering/DeviceFunction.py b/schemata/CIM14/IEC61968/Metering/DeviceFunction.py index 3931250..8388b50 100644 --- a/schemata/CIM14/IEC61968/Metering/DeviceFunction.py +++ b/schemata/CIM14/IEC61968/Metering/DeviceFunction.py @@ -20,8 +20,8 @@ class DeviceFunction(AssetFunction): """Function performed by a device such as a meter, communication equipment, controllers, etc. """ - def __init__(self, disabled=False, EndDeviceAsset=None, Registers=None, EndDeviceEvents=None, **kw_args): - """Initializes a new 'DeviceFunction' instance. + def __init__(self, disabled=False, EndDeviceAsset=None, Registers=None, EndDeviceEvents=None, *args, **kw_args): + """Initialises a new 'DeviceFunction' instance. @param disabled: True if the device function is disabled (deactivated). Default is false (i.e., function is enabled). @param EndDeviceAsset: End device asset that performs this function. @@ -40,7 +40,14 @@ class DeviceFunction(AssetFunction): self._EndDeviceEvents = [] self.EndDeviceEvents = [] if EndDeviceEvents is None else EndDeviceEvents - super(DeviceFunction, self).__init__(**kw_args) + super(DeviceFunction, self).__init__(*args, **kw_args) + + _attrs = ["disabled"] + _attr_types = {"disabled": bool} + _defaults = {"disabled": False} + _enums = {} + _refs = ["EndDeviceAsset", "Registers", "EndDeviceEvents"] + _many_refs = ["Registers", "EndDeviceEvents"] def getEndDeviceAsset(self): """End device asset that performs this function. diff --git a/schemata/CIM14/IEC61968/Metering/DynamicDemand.py b/schemata/CIM14/IEC61968/Metering/DynamicDemand.py index c3c9799..8a42c32 100644 --- a/schemata/CIM14/IEC61968/Metering/DynamicDemand.py +++ b/schemata/CIM14/IEC61968/Metering/DynamicDemand.py @@ -20,14 +20,14 @@ class DynamicDemand(Element): """Dynamic demand description. The formula by which demand is measured is an important underlying definition to the measurement. Generally speaking, all of the meters in a given utility will be configured to measure demand the same way. Nevertheless, it must be defined. An 'interval' of 60, 30, 15, 10, or 5 minutes must be defined to describe the interval of time over which usage is measured. When demand is defined to be DemandKind.rollingBlock, both an 'interval' and a 'subinterval' must be defined, where the 'subinterval' must be a multiple of the 'interval' which contains it. A common setting is '15-minute rolling block with 5-minute subintervals.' """ - def __init__(self, kind='logarithmic', interval=0.0, subInterval=0.0, **kw_args): - """Initializes a new 'DynamicDemand' instance. + def __init__(self, kind="logarithmic", interval=0.0, subInterval=0.0, *args, **kw_args): + """Initialises a new 'DynamicDemand' instance. @param kind: Kind of demand. Values are: "logarithmic", "fixedBlock", "rollingBlock" @param interval: Demand interval. @param subInterval: (if 'kind'=rollingBlock) Subinterval, must be multiple of 'interval' that contains it. """ - #: Kind of demand.Values are: "logarithmic", "fixedBlock", "rollingBlock" + #: Kind of demand. Values are: "logarithmic", "fixedBlock", "rollingBlock" self.kind = kind #: Demand interval. @@ -36,5 +36,12 @@ class DynamicDemand(Element): #: (if 'kind'=rollingBlock) Subinterval, must be multiple of 'interval' that contains it. self.subInterval = subInterval - super(DynamicDemand, self).__init__(**kw_args) + super(DynamicDemand, self).__init__(*args, **kw_args) + + _attrs = ["kind", "interval", "subInterval"] + _attr_types = {"kind": str, "interval": float, "subInterval": float} + _defaults = {"kind": "logarithmic", "interval": 0.0, "subInterval": 0.0} + _enums = {"kind": "DemandKind"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Metering/ElectricMeteringFunction.py b/schemata/CIM14/IEC61968/Metering/ElectricMeteringFunction.py index a21fb80..55e6198 100644 --- a/schemata/CIM14/IEC61968/Metering/ElectricMeteringFunction.py +++ b/schemata/CIM14/IEC61968/Metering/ElectricMeteringFunction.py @@ -20,8 +20,8 @@ class ElectricMeteringFunction(DeviceFunction): """Functionality performed by an electric meter. """ - def __init__(self, billingMultiplierApplied=False, kWMultiplier=0, demandMultiplier=0.0, demandMultiplierApplied=False, transformerRatiosApplied=False, voltageRating=0.0, billingMultiplier=0.0, transformerVTRatio=0.0, kWhMultiplier=0, transformerCTRatio=0.0, currentRating=0.0, **kw_args): - """Initializes a new 'ElectricMeteringFunction' instance. + def __init__(self, billingMultiplierApplied=False, kWMultiplier=0, demandMultiplier=0.0, demandMultiplierApplied=False, transformerRatiosApplied=False, voltageRating=0.0, billingMultiplier=0.0, transformerVTRatio=0.0, kWhMultiplier=0, transformerCTRatio=0.0, currentRating=0.0, *args, **kw_args): + """Initialises a new 'ElectricMeteringFunction' instance. @param billingMultiplierApplied: True if the billingMultiplier ratio has already been applied to the associated quantities. @param kWMultiplier: Meter kW (pulse) multiplier, used as a multiplier for a meter register reading to determine the actual amount of usage for which to bill a customer. @@ -68,5 +68,12 @@ class ElectricMeteringFunction(DeviceFunction): #: The current class of the meter. Typical current classes in North America are 10 A, 20 A, 100 A, 200 A, or 320 A. self.currentRating = currentRating - super(ElectricMeteringFunction, self).__init__(**kw_args) + super(ElectricMeteringFunction, self).__init__(*args, **kw_args) + + _attrs = ["billingMultiplierApplied", "kWMultiplier", "demandMultiplier", "demandMultiplierApplied", "transformerRatiosApplied", "voltageRating", "billingMultiplier", "transformerVTRatio", "kWhMultiplier", "transformerCTRatio", "currentRating"] + _attr_types = {"billingMultiplierApplied": bool, "kWMultiplier": int, "demandMultiplier": float, "demandMultiplierApplied": bool, "transformerRatiosApplied": bool, "voltageRating": float, "billingMultiplier": float, "transformerVTRatio": float, "kWhMultiplier": int, "transformerCTRatio": float, "currentRating": float} + _defaults = {"billingMultiplierApplied": False, "kWMultiplier": 0, "demandMultiplier": 0.0, "demandMultiplierApplied": False, "transformerRatiosApplied": False, "voltageRating": 0.0, "billingMultiplier": 0.0, "transformerVTRatio": 0.0, "kWhMultiplier": 0, "transformerCTRatio": 0.0, "currentRating": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/Metering/EndDeviceAsset.py b/schemata/CIM14/IEC61968/Metering/EndDeviceAsset.py index 9216f17..5c1f9f9 100644 --- a/schemata/CIM14/IEC61968/Metering/EndDeviceAsset.py +++ b/schemata/CIM14/IEC61968/Metering/EndDeviceAsset.py @@ -20,8 +20,8 @@ class EndDeviceAsset(AssetContainer): """AssetContainer that performs one or more end device functions. One type of EndDeviceAsset is a MeterAsset which can perform metering, load management, connect/disconnect, accounting functions, etc. Some EndDeviceAssets, such as ones monitoring and controlling air conditioner, refrigerator, pool pumps may be connected to a MeterAsset. All EndDeviceAssets may have communication capability defined by the associated ComFunction(s). An EndDeviceAsset may be owned by a consumer, a service provider, utility or otherwise. There may be a related end device function that identifies a sensor or control point within a metering application or communications systems (e.g., water, gas, electricity). Some devices may use an optical port that conforms to the ANSI C12.18 standard for communications. """ - def __init__(self, readRequest=False, demandResponse=False, relayCapable=False, amrSystem='', ratedCurrent=0.0, phaseCount=0, reverseFlowHandling=False, metrology=False, timeZoneOffset=0.0, outageReport=False, dstEnabled=False, disconnect=False, ratedVoltage=0.0, loadControl=False, EndDeviceGroups=None, ServiceLocation=None, EndDeviceModel=None, DeviceFunctions=None, ServiceDeliveryPoint=None, Readings=None, EndDeviceControls=None, Customer=None, **kw_args): - """Initializes a new 'EndDeviceAsset' instance. + def __init__(self, readRequest=False, demandResponse=False, relayCapable=False, amrSystem='', ratedCurrent=0.0, phaseCount=0, reverseFlowHandling=False, metrology=False, timeZoneOffset=0.0, outageReport=False, dstEnabled=False, disconnect=False, ratedVoltage=0.0, loadControl=False, EndDeviceGroups=None, ServiceLocation=None, EndDeviceModel=None, DeviceFunctions=None, ServiceDeliveryPoint=None, Readings=None, EndDeviceControls=None, Customer=None, *args, **kw_args): + """Initialises a new 'EndDeviceAsset' instance. @param readRequest: True if this end device asset is capable of supporting on-request reads for this end device. @param demandResponse: True if this end device asset is capable of supporting demand response functions. To determine whether this functionality is installed and enabled, check the 'DeviceFunction.disabled' attribute of the respective function contained by this end device asset. @@ -112,7 +112,14 @@ class EndDeviceAsset(AssetContainer): self._Customer = None self.Customer = Customer - super(EndDeviceAsset, self).__init__(**kw_args) + super(EndDeviceAsset, self).__init__(*args, **kw_args) + + _attrs = ["readRequest", "demandResponse", "relayCapable", "amrSystem", "ratedCurrent", "phaseCount", "reverseFlowHandling", "metrology", "timeZoneOffset", "outageReport", "dstEnabled", "disconnect", "ratedVoltage", "loadControl"] + _attr_types = {"readRequest": bool, "demandResponse": bool, "relayCapable": bool, "amrSystem": str, "ratedCurrent": float, "phaseCount": int, "reverseFlowHandling": bool, "metrology": bool, "timeZoneOffset": float, "outageReport": bool, "dstEnabled": bool, "disconnect": bool, "ratedVoltage": float, "loadControl": bool} + _defaults = {"readRequest": False, "demandResponse": False, "relayCapable": False, "amrSystem": '', "ratedCurrent": 0.0, "phaseCount": 0, "reverseFlowHandling": False, "metrology": False, "timeZoneOffset": 0.0, "outageReport": False, "dstEnabled": False, "disconnect": False, "ratedVoltage": 0.0, "loadControl": False} + _enums = {} + _refs = ["EndDeviceGroups", "ServiceLocation", "EndDeviceModel", "DeviceFunctions", "ServiceDeliveryPoint", "Readings", "EndDeviceControls", "Customer"] + _many_refs = ["EndDeviceGroups", "DeviceFunctions", "Readings", "EndDeviceControls"] def getEndDeviceGroups(self): """All end device groups referring to this end device asset. diff --git a/schemata/CIM14/IEC61968/Metering/EndDeviceControl.py b/schemata/CIM14/IEC61968/Metering/EndDeviceControl.py index 3a34c60..e15a440 100644 --- a/schemata/CIM14/IEC61968/Metering/EndDeviceControl.py +++ b/schemata/CIM14/IEC61968/Metering/EndDeviceControl.py @@ -20,8 +20,8 @@ class EndDeviceControl(IdentifiedObject): """Instructs an EndDeviceAsset (or EndDeviceGroup) to perform a specified action. """ - def __init__(self, type='', drProgramMandatory=False, priceSignal=0.0, drProgramLevel=0, EndDeviceGroup=None, DemandResponseProgram=None, CustomerAgreement=None, EndDeviceAsset=None, scheduledInterval=None, **kw_args): - """Initializes a new 'EndDeviceControl' instance. + def __init__(self, type='', drProgramMandatory=False, priceSignal=0.0, drProgramLevel=0, EndDeviceGroup=None, DemandResponseProgram=None, CustomerAgreement=None, EndDeviceAsset=None, scheduledInterval=None, *args, **kw_args): + """Initialises a new 'EndDeviceControl' instance. @param type: Type of control. @param drProgramMandatory: Whether a demand response program request is mandatory. Note: Attribute is not defined on DemandResponseProgram as it is not its inherent property (it serves to control it). @@ -59,7 +59,14 @@ class EndDeviceControl(IdentifiedObject): self.scheduledInterval = scheduledInterval - super(EndDeviceControl, self).__init__(**kw_args) + super(EndDeviceControl, self).__init__(*args, **kw_args) + + _attrs = ["type", "drProgramMandatory", "priceSignal", "drProgramLevel"] + _attr_types = {"type": str, "drProgramMandatory": bool, "priceSignal": float, "drProgramLevel": int} + _defaults = {"type": '', "drProgramMandatory": False, "priceSignal": 0.0, "drProgramLevel": 0} + _enums = {} + _refs = ["EndDeviceGroup", "DemandResponseProgram", "CustomerAgreement", "EndDeviceAsset", "scheduledInterval"] + _many_refs = [] def getEndDeviceGroup(self): """End device group receiving commands from this end device control. diff --git a/schemata/CIM14/IEC61968/Metering/EndDeviceEvent.py b/schemata/CIM14/IEC61968/Metering/EndDeviceEvent.py index c565482..c2c7b08 100644 --- a/schemata/CIM14/IEC61968/Metering/EndDeviceEvent.py +++ b/schemata/CIM14/IEC61968/Metering/EndDeviceEvent.py @@ -20,8 +20,8 @@ class EndDeviceEvent(ActivityRecord): """Event detected by a DeviceFunction associated with EndDeviceAsset. """ - def __init__(self, userID='', MeterReading=None, DeviceFunction=None, **kw_args): - """Initializes a new 'EndDeviceEvent' instance. + def __init__(self, userID='', MeterReading=None, DeviceFunction=None, *args, **kw_args): + """Initialises a new 'EndDeviceEvent' instance. @param userID: (if user initiated) ID of user who initiated this end device event. @param MeterReading: Set of measured values to which this event applies. @@ -36,7 +36,14 @@ class EndDeviceEvent(ActivityRecord): self._DeviceFunction = None self.DeviceFunction = DeviceFunction - super(EndDeviceEvent, self).__init__(**kw_args) + super(EndDeviceEvent, self).__init__(*args, **kw_args) + + _attrs = ["userID"] + _attr_types = {"userID": str} + _defaults = {"userID": ''} + _enums = {} + _refs = ["MeterReading", "DeviceFunction"] + _many_refs = [] def getMeterReading(self): """Set of measured values to which this event applies. diff --git a/schemata/CIM14/IEC61968/Metering/EndDeviceGroup.py b/schemata/CIM14/IEC61968/Metering/EndDeviceGroup.py index 92a533e..73db154 100644 --- a/schemata/CIM14/IEC61968/Metering/EndDeviceGroup.py +++ b/schemata/CIM14/IEC61968/Metering/EndDeviceGroup.py @@ -20,8 +20,8 @@ class EndDeviceGroup(IdentifiedObject): """Abstraction for management of group communications within a two-way AMR system or the data for a group of related meters. Commands can be issued to all of the meters that belong to a meter group using a defined group address and the underlying AMR communication infrastructure. """ - def __init__(self, groupAddress=0, EndDeviceAssets=None, EndDeviceControls=None, DemandResponseProgram=None, **kw_args): - """Initializes a new 'EndDeviceGroup' instance. + def __init__(self, groupAddress=0, EndDeviceAssets=None, EndDeviceControls=None, DemandResponseProgram=None, *args, **kw_args): + """Initialises a new 'EndDeviceGroup' instance. @param groupAddress: Address of this end device group. @param EndDeviceAssets: All end device assets this end device group refers to. @@ -40,7 +40,14 @@ class EndDeviceGroup(IdentifiedObject): self._DemandResponseProgram = None self.DemandResponseProgram = DemandResponseProgram - super(EndDeviceGroup, self).__init__(**kw_args) + super(EndDeviceGroup, self).__init__(*args, **kw_args) + + _attrs = ["groupAddress"] + _attr_types = {"groupAddress": int} + _defaults = {"groupAddress": 0} + _enums = {} + _refs = ["EndDeviceAssets", "EndDeviceControls", "DemandResponseProgram"] + _many_refs = ["EndDeviceAssets", "EndDeviceControls"] def getEndDeviceAssets(self): """All end device assets this end device group refers to. diff --git a/schemata/CIM14/IEC61968/Metering/IntervalBlock.py b/schemata/CIM14/IEC61968/Metering/IntervalBlock.py index e51c927..c82c34d 100644 --- a/schemata/CIM14/IEC61968/Metering/IntervalBlock.py +++ b/schemata/CIM14/IEC61968/Metering/IntervalBlock.py @@ -20,8 +20,8 @@ class IntervalBlock(Element): """Time sequence of Readings of the same ReadingType. Contained IntervalReadings may need conversion through the application of an offset and a scalar defined in associated Pending. """ - def __init__(self, MeterReading=None, Pending=None, ReadingType=None, IntervalReadings=None, **kw_args): - """Initializes a new 'IntervalBlock' instance. + def __init__(self, MeterReading=None, Pending=None, ReadingType=None, IntervalReadings=None, *args, **kw_args): + """Initialises a new 'IntervalBlock' instance. @param MeterReading: Meter reading containing this interval block. @param Pending: Pending conversion to apply to interval reading values contained by this block (after which the resulting reading type is different than the original because it reflects the conversion result). @@ -40,7 +40,14 @@ class IntervalBlock(Element): self._IntervalReadings = [] self.IntervalReadings = [] if IntervalReadings is None else IntervalReadings - super(IntervalBlock, self).__init__(**kw_args) + super(IntervalBlock, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MeterReading", "Pending", "ReadingType", "IntervalReadings"] + _many_refs = ["IntervalReadings"] def getMeterReading(self): """Meter reading containing this interval block. diff --git a/schemata/CIM14/IEC61968/Metering/IntervalReading.py b/schemata/CIM14/IEC61968/Metering/IntervalReading.py index 9ad9edd..4645c82 100644 --- a/schemata/CIM14/IEC61968/Metering/IntervalReading.py +++ b/schemata/CIM14/IEC61968/Metering/IntervalReading.py @@ -20,8 +20,8 @@ class IntervalReading(MeasurementValue): """Data captured at regular intervals of time. Interval data could be captured as incremental data, absolute data, or relative data. The source for the data is usually a tariff quantity or an engineering quantity. Data is typically captured in time-tagged, uniform, fixed-length intervals of 5 min, 10 min, 15 min, 30 min, or 60 min. Note: Interval Data is sometimes also called 'Interval Data Readings' (IDR). """ - def __init__(self, value=0.0, ReadingQualities=None, IntervalBlocks=None, **kw_args): - """Initializes a new 'IntervalReading' instance. + def __init__(self, value=0.0, ReadingQualities=None, IntervalBlocks=None, *args, **kw_args): + """Initialises a new 'IntervalReading' instance. @param value: Value of this interval reading. @param ReadingQualities: Used only if quality of this interval reading value is different than 'Good'. @@ -36,7 +36,14 @@ class IntervalReading(MeasurementValue): self._IntervalBlocks = [] self.IntervalBlocks = [] if IntervalBlocks is None else IntervalBlocks - super(IntervalReading, self).__init__(**kw_args) + super(IntervalReading, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["ReadingQualities", "IntervalBlocks"] + _many_refs = ["ReadingQualities", "IntervalBlocks"] def getReadingQualities(self): """Used only if quality of this interval reading value is different than 'Good'. diff --git a/schemata/CIM14/IEC61968/Metering/MeterAsset.py b/schemata/CIM14/IEC61968/Metering/MeterAsset.py index bf5495f..2662dda 100644 --- a/schemata/CIM14/IEC61968/Metering/MeterAsset.py +++ b/schemata/CIM14/IEC61968/Metering/MeterAsset.py @@ -20,8 +20,8 @@ class MeterAsset(EndDeviceAsset): """Physical asset that performs the metering role of the ServiceDeliveryPoint. Used for measuring consumption and detection of events. """ - def __init__(self, kH=0.0, kR=0.0, formNumber='', MeterReplacementWorks=None, MeterServiceWorks=None, MeterReadings=None, VendingTransactions=None, **kw_args): - """Initializes a new 'MeterAsset' instance. + def __init__(self, kH=0.0, kR=0.0, formNumber='', MeterReplacementWorks=None, MeterServiceWorks=None, MeterReadings=None, VendingTransactions=None, *args, **kw_args): + """Initialises a new 'MeterAsset' instance. @param kH: Meter kh (watthour) constant. It is the number of watthours that must be applied to the meter to cause one disk revolution for an electromechanical meter or the number of watthours represented by one increment pulse for an electronic meter. @param kR: Display multiplier used to produce a displayed value from a register value. @@ -52,7 +52,14 @@ class MeterAsset(EndDeviceAsset): self._VendingTransactions = [] self.VendingTransactions = [] if VendingTransactions is None else VendingTransactions - super(MeterAsset, self).__init__(**kw_args) + super(MeterAsset, self).__init__(*args, **kw_args) + + _attrs = ["kH", "kR", "formNumber"] + _attr_types = {"kH": float, "kR": float, "formNumber": str} + _defaults = {"kH": 0.0, "kR": 0.0, "formNumber": ''} + _enums = {} + _refs = ["MeterReplacementWorks", "MeterServiceWorks", "MeterReadings", "VendingTransactions"] + _many_refs = ["MeterReplacementWorks", "MeterServiceWorks", "MeterReadings", "VendingTransactions"] def getMeterReplacementWorks(self): """All works on replacement of this old meter asset. diff --git a/schemata/CIM14/IEC61968/Metering/MeterReading.py b/schemata/CIM14/IEC61968/Metering/MeterReading.py index 8defb8d..2f5b398 100644 --- a/schemata/CIM14/IEC61968/Metering/MeterReading.py +++ b/schemata/CIM14/IEC61968/Metering/MeterReading.py @@ -20,8 +20,8 @@ class MeterReading(IdentifiedObject): """Set of values obtained from the meter. """ - def __init__(self, IntervalBlocks=None, CustomerAgreement=None, MeterAsset=None, EndDeviceEvents=None, Readings=None, ServiceDeliveryPoint=None, valuesInterval=None, **kw_args): - """Initializes a new 'MeterReading' instance. + def __init__(self, IntervalBlocks=None, CustomerAgreement=None, MeterAsset=None, EndDeviceEvents=None, Readings=None, ServiceDeliveryPoint=None, valuesInterval=None, *args, **kw_args): + """Initialises a new 'MeterReading' instance. @param IntervalBlocks: All interval blocks contained in this meter reading. @param CustomerAgreement: (could be deprecated in the future) Customer agreement for this meter reading. @@ -51,7 +51,14 @@ class MeterReading(IdentifiedObject): self.valuesInterval = valuesInterval - super(MeterReading, self).__init__(**kw_args) + super(MeterReading, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["IntervalBlocks", "CustomerAgreement", "MeterAsset", "EndDeviceEvents", "Readings", "ServiceDeliveryPoint", "valuesInterval"] + _many_refs = ["IntervalBlocks", "EndDeviceEvents", "Readings"] def getIntervalBlocks(self): """All interval blocks contained in this meter reading. diff --git a/schemata/CIM14/IEC61968/Metering/MeterServiceWork.py b/schemata/CIM14/IEC61968/Metering/MeterServiceWork.py index a78a527..a916f68 100644 --- a/schemata/CIM14/IEC61968/Metering/MeterServiceWork.py +++ b/schemata/CIM14/IEC61968/Metering/MeterServiceWork.py @@ -20,8 +20,8 @@ class MeterServiceWork(Work): """Work involving meters. """ - def __init__(self, OldMeterAsset=None, MeterAsset=None, **kw_args): - """Initializes a new 'MeterServiceWork' instance. + def __init__(self, OldMeterAsset=None, MeterAsset=None, *args, **kw_args): + """Initialises a new 'MeterServiceWork' instance. @param OldMeterAsset: Old meter asset replaced by this work. @param MeterAsset: Meter asset on which this non-replacement work is performed. @@ -32,7 +32,14 @@ class MeterServiceWork(Work): self._MeterAsset = None self.MeterAsset = MeterAsset - super(MeterServiceWork, self).__init__(**kw_args) + super(MeterServiceWork, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["OldMeterAsset", "MeterAsset"] + _many_refs = [] def getOldMeterAsset(self): """Old meter asset replaced by this work. diff --git a/schemata/CIM14/IEC61968/Metering/Pending.py b/schemata/CIM14/IEC61968/Metering/Pending.py index 3bad463..8500dfa 100644 --- a/schemata/CIM14/IEC61968/Metering/Pending.py +++ b/schemata/CIM14/IEC61968/Metering/Pending.py @@ -20,8 +20,8 @@ class Pending(Element): """When present, a scalar conversion that is associated with IntervalBlock and which needs to be applied to every contained IntervalReading value. This conversion results in a new associated ReadingType, reflecting the true dimensions of interval reading values after the conversion. """ - def __init__(self, scalarDenominator=0, scalarFloat=0.0, scalarNumerator=0, multiplyBeforeAdd=False, offset=0, IntervalBlocks=None, ReadingType=None, **kw_args): - """Initializes a new 'Pending' instance. + def __init__(self, scalarDenominator=0, scalarFloat=0.0, scalarNumerator=0, multiplyBeforeAdd=False, offset=0, IntervalBlocks=None, ReadingType=None, *args, **kw_args): + """Initialises a new 'Pending' instance. @param scalarDenominator: (if scalar is rational number) When 'IntervalReading.value' is multiplied by this attribute and divided by 'scalarDenominator, it causes a unit of measure conversion to occur, resulting in the 'ReadingType.unit'. @param scalarFloat: (if scalar is floating number) When multiplied with 'IntervalReading.value', it causes a unit of measure conversion to occur, resulting in the 'ReadingType.unit'. @@ -52,7 +52,14 @@ class Pending(Element): self._ReadingType = None self.ReadingType = ReadingType - super(Pending, self).__init__(**kw_args) + super(Pending, self).__init__(*args, **kw_args) + + _attrs = ["scalarDenominator", "scalarFloat", "scalarNumerator", "multiplyBeforeAdd", "offset"] + _attr_types = {"scalarDenominator": int, "scalarFloat": float, "scalarNumerator": int, "multiplyBeforeAdd": bool, "offset": int} + _defaults = {"scalarDenominator": 0, "scalarFloat": 0.0, "scalarNumerator": 0, "multiplyBeforeAdd": False, "offset": 0} + _enums = {} + _refs = ["IntervalBlocks", "ReadingType"] + _many_refs = ["IntervalBlocks"] def getIntervalBlocks(self): """All blocks of interval reading values to which this pending conversion applies. diff --git a/schemata/CIM14/IEC61968/Metering/Reading.py b/schemata/CIM14/IEC61968/Metering/Reading.py index 9c85838..fe2bab5 100644 --- a/schemata/CIM14/IEC61968/Metering/Reading.py +++ b/schemata/CIM14/IEC61968/Metering/Reading.py @@ -20,8 +20,8 @@ class Reading(MeasurementValue): """Specific value measured by a meter or other asset. Each Reading is associated with a specific ReadingType. """ - def __init__(self, value=0.0, ReadingType=None, ReadingQualities=None, EndDeviceAsset=None, MeterReadings=None, **kw_args): - """Initializes a new 'Reading' instance. + def __init__(self, value=0.0, ReadingType=None, ReadingQualities=None, EndDeviceAsset=None, MeterReadings=None, *args, **kw_args): + """Initialises a new 'Reading' instance. @param value: Value of this reading. @param ReadingType: Type information for this reading value. @@ -44,7 +44,14 @@ class Reading(MeasurementValue): self._MeterReadings = [] self.MeterReadings = [] if MeterReadings is None else MeterReadings - super(Reading, self).__init__(**kw_args) + super(Reading, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["ReadingType", "ReadingQualities", "EndDeviceAsset", "MeterReadings"] + _many_refs = ["ReadingQualities", "MeterReadings"] def getReadingType(self): """Type information for this reading value. diff --git a/schemata/CIM14/IEC61968/Metering/ReadingQuality.py b/schemata/CIM14/IEC61968/Metering/ReadingQuality.py index e955d03..634b934 100644 --- a/schemata/CIM14/IEC61968/Metering/ReadingQuality.py +++ b/schemata/CIM14/IEC61968/Metering/ReadingQuality.py @@ -20,8 +20,8 @@ class ReadingQuality(Element): """Quality of a specific reading value or interval reading value. Note that more than one Quality may be applicable to a given Reading. Typically not used unless problems or unusual conditions occur (i.e., quality for each Reading is assumed to be 'Good' unless stated otherwise in associated ReadingQuality). """ - def __init__(self, quality='', IntervalReading=None, Reading=None, **kw_args): - """Initializes a new 'ReadingQuality' instance. + def __init__(self, quality='', IntervalReading=None, Reading=None, *args, **kw_args): + """Initialises a new 'ReadingQuality' instance. @param quality: Quality, to be specified if different than 'Good'. @param IntervalReading: Interval reading value to which this quality applies. @@ -36,7 +36,14 @@ class ReadingQuality(Element): self._Reading = None self.Reading = Reading - super(ReadingQuality, self).__init__(**kw_args) + super(ReadingQuality, self).__init__(*args, **kw_args) + + _attrs = ["quality"] + _attr_types = {"quality": str} + _defaults = {"quality": ''} + _enums = {} + _refs = ["IntervalReading", "Reading"] + _many_refs = [] def getIntervalReading(self): """Interval reading value to which this quality applies. diff --git a/schemata/CIM14/IEC61968/Metering/ReadingType.py b/schemata/CIM14/IEC61968/Metering/ReadingType.py index 9d33b0c..0dba903 100644 --- a/schemata/CIM14/IEC61968/Metering/ReadingType.py +++ b/schemata/CIM14/IEC61968/Metering/ReadingType.py @@ -20,8 +20,8 @@ class ReadingType(IdentifiedObject): """Type of data conveyed by a specific Reading. """ - def __init__(self, multiplier='k', kind='voltageAngle', unit='N', reverseChronology=False, defaultQuality='', defaultValueDataType='', channelNumber=0, intervalLength=0.0, Readings=None, dynamicConfiguration=None, IntervalBlocks=None, Pending=None, Register=None, **kw_args): - """Initializes a new 'ReadingType' instance. + def __init__(self, multiplier="k", kind="voltageAngle", unit="N", reverseChronology=False, defaultQuality='', defaultValueDataType='', channelNumber=0, intervalLength=0.0, Readings=None, dynamicConfiguration=None, IntervalBlocks=None, Pending=None, Register=None, *args, **kw_args): + """Initialises a new 'ReadingType' instance. @param multiplier: Multiplier for 'unit'. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" @param kind: Kind of reading. Values are: "voltageAngle", "current", "time", "powerFactor", "voltage", "frequency", "power", "other", "energy", "demand", "volume", "date", "phaseAngle", "pressure", "currentAngle" @@ -37,13 +37,13 @@ class ReadingType(IdentifiedObject): @param Pending: Pending conversion that produced this reading type. @param Register: Register displaying values with this type information. """ - #: Multiplier for 'unit'.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for 'unit'. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.multiplier = multiplier - #: Kind of reading.Values are: "voltageAngle", "current", "time", "powerFactor", "voltage", "frequency", "power", "other", "energy", "demand", "volume", "date", "phaseAngle", "pressure", "currentAngle" + #: Kind of reading. Values are: "voltageAngle", "current", "time", "powerFactor", "voltage", "frequency", "power", "other", "energy", "demand", "volume", "date", "phaseAngle", "pressure", "currentAngle" self.kind = kind - #: Unit for the reading value.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: Unit for the reading value. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.unit = unit #: True for systems that must operate in 'reverse' chronological order. @@ -75,7 +75,14 @@ class ReadingType(IdentifiedObject): self._Register = None self.Register = Register - super(ReadingType, self).__init__(**kw_args) + super(ReadingType, self).__init__(*args, **kw_args) + + _attrs = ["multiplier", "kind", "unit", "reverseChronology", "defaultQuality", "defaultValueDataType", "channelNumber", "intervalLength"] + _attr_types = {"multiplier": str, "kind": str, "unit": str, "reverseChronology": bool, "defaultQuality": str, "defaultValueDataType": str, "channelNumber": int, "intervalLength": float} + _defaults = {"multiplier": "k", "kind": "voltageAngle", "unit": "N", "reverseChronology": False, "defaultQuality": '', "defaultValueDataType": '', "channelNumber": 0, "intervalLength": 0.0} + _enums = {"multiplier": "UnitMultiplier", "kind": "ReadingKind", "unit": "UnitSymbol"} + _refs = ["Readings", "dynamicConfiguration", "IntervalBlocks", "Pending", "Register"] + _many_refs = ["Readings", "IntervalBlocks"] def getReadings(self): """All reading values with this type information. diff --git a/schemata/CIM14/IEC61968/Metering/Register.py b/schemata/CIM14/IEC61968/Metering/Register.py index ca7327a..c0329e7 100644 --- a/schemata/CIM14/IEC61968/Metering/Register.py +++ b/schemata/CIM14/IEC61968/Metering/Register.py @@ -20,8 +20,8 @@ class Register(IdentifiedObject): """Display for quantity that is metered on an end device such as a meter. """ - def __init__(self, leftDigitCount=0, rightDigitCount=0, ReadingType=None, DeviceFunction=None, **kw_args): - """Initializes a new 'Register' instance. + def __init__(self, leftDigitCount=0, rightDigitCount=0, ReadingType=None, DeviceFunction=None, *args, **kw_args): + """Initialises a new 'Register' instance. @param leftDigitCount: Number of digits (dials on a mechanical meter) to the left of the decimal place; default is 5. @param rightDigitCount: Number of digits (dials on a mechanical meter) to the right of the decimal place. @@ -40,7 +40,14 @@ class Register(IdentifiedObject): self._DeviceFunction = None self.DeviceFunction = DeviceFunction - super(Register, self).__init__(**kw_args) + super(Register, self).__init__(*args, **kw_args) + + _attrs = ["leftDigitCount", "rightDigitCount"] + _attr_types = {"leftDigitCount": int, "rightDigitCount": int} + _defaults = {"leftDigitCount": 0, "rightDigitCount": 0} + _enums = {} + _refs = ["ReadingType", "DeviceFunction"] + _many_refs = [] def getReadingType(self): """Reading type for values displayed by this register. diff --git a/schemata/CIM14/IEC61968/Metering/SDPLocation.py b/schemata/CIM14/IEC61968/Metering/SDPLocation.py index 819bdd9..ec3b6b6 100644 --- a/schemata/CIM14/IEC61968/Metering/SDPLocation.py +++ b/schemata/CIM14/IEC61968/Metering/SDPLocation.py @@ -20,8 +20,8 @@ class SDPLocation(Location): """Location of an individual service delivery point. For residential or most businesses, it is typically the location of a meter on the customer's premises. For transmission, it is the point(s) of interconnection on the transmission provider's transmission system where capacity and/or energy transmitted by the transmission provider is made available to the receiving party. The point(s) of delivery is specified in the Service Agreement. """ - def __init__(self, remark='', siteAccessProblem='', occupancyDate='', accessMethod='', ServiceDeliveryPoints=None, **kw_args): - """Initializes a new 'SDPLocation' instance. + def __init__(self, remark='', siteAccessProblem='', occupancyDate='', accessMethod='', ServiceDeliveryPoints=None, *args, **kw_args): + """Initialises a new 'SDPLocation' instance. @param remark: Remarks about this location. @param siteAccessProblem: Problems previously encountered when visiting or performing work at this service delivery point location. Examples include: bad dog, violent customer, verbally abusive occupant, obstructions, safety hazards, etc. @@ -44,7 +44,14 @@ class SDPLocation(Location): self._ServiceDeliveryPoints = [] self.ServiceDeliveryPoints = [] if ServiceDeliveryPoints is None else ServiceDeliveryPoints - super(SDPLocation, self).__init__(**kw_args) + super(SDPLocation, self).__init__(*args, **kw_args) + + _attrs = ["remark", "siteAccessProblem", "occupancyDate", "accessMethod"] + _attr_types = {"remark": str, "siteAccessProblem": str, "occupancyDate": str, "accessMethod": str} + _defaults = {"remark": '', "siteAccessProblem": '', "occupancyDate": '', "accessMethod": ''} + _enums = {} + _refs = ["ServiceDeliveryPoints"] + _many_refs = ["ServiceDeliveryPoints"] def getServiceDeliveryPoints(self): """All service delivery points at this location. diff --git a/schemata/CIM14/IEC61968/Metering/ServiceDeliveryPoint.py b/schemata/CIM14/IEC61968/Metering/ServiceDeliveryPoint.py index 7e082a3..f9da1f0 100644 --- a/schemata/CIM14/IEC61968/Metering/ServiceDeliveryPoint.py +++ b/schemata/CIM14/IEC61968/Metering/ServiceDeliveryPoint.py @@ -20,8 +20,8 @@ class ServiceDeliveryPoint(IdentifiedObject): """Logical point on the network where the ownership of the service changes hands. It is one of potentially many service points within a ServiceLocation, delivering service in accordance with a CustomerAgreement. Used at the place where a meter may be installed. """ - def __init__(self, phaseCode='A', ratedPower=0.0, servicePriority='', checkBilling=False, grounded=False, serviceDeliveryRemark='', ratedCurrent=0.0, estimatedLoad=0.0, nominalServiceVoltage=0, ctptReference=0, PricingStructures=None, Transformer=None, SDPLocations=None, EndDeviceAssets=None, EnergyConsumer=None, ServiceLocation=None, CustomerAgreement=None, MeterReadings=None, ServiceSupplier=None, ServiceCategory=None, **kw_args): - """Initializes a new 'ServiceDeliveryPoint' instance. + def __init__(self, phaseCode="A", ratedPower=0.0, servicePriority='', checkBilling=False, grounded=False, serviceDeliveryRemark='', ratedCurrent=0.0, estimatedLoad=0.0, nominalServiceVoltage=0, ctptReference=0, PricingStructures=None, Transformer=None, SDPLocations=None, EndDeviceAssets=None, EnergyConsumer=None, ServiceLocation=None, CustomerAgreement=None, MeterReadings=None, ServiceSupplier=None, ServiceCategory=None, *args, **kw_args): + """Initialises a new 'ServiceDeliveryPoint' instance. @param phaseCode: Phase code. Number of wires and number of phases can be deduced from enumeration literal values. For example, ABCN is three-phase, four-wire. s12n (splitSecondary12N) is single-phase, three-wire. s1n and s2n are single-phase, two-wire. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" @param ratedPower: Power that this service delivery point is configured to deliver. @@ -44,7 +44,7 @@ class ServiceDeliveryPoint(IdentifiedObject): @param ServiceSupplier: ServiceSupplier (Utility) utilising this service delivery point to deliver a service. @param ServiceCategory: Service category delivered by this service delivery point. """ - #: Phase code. Number of wires and number of phases can be deduced from enumeration literal values. For example, ABCN is three-phase, four-wire. s12n (splitSecondary12N) is single-phase, three-wire. s1n and s2n are single-phase, two-wire.Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" + #: Phase code. Number of wires and number of phases can be deduced from enumeration literal values. For example, ABCN is three-phase, four-wire. s12n (splitSecondary12N) is single-phase, three-wire. s1n and s2n are single-phase, two-wire. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" self.phaseCode = phaseCode #: Power that this service delivery point is configured to deliver. @@ -104,7 +104,14 @@ class ServiceDeliveryPoint(IdentifiedObject): self._ServiceCategory = None self.ServiceCategory = ServiceCategory - super(ServiceDeliveryPoint, self).__init__(**kw_args) + super(ServiceDeliveryPoint, self).__init__(*args, **kw_args) + + _attrs = ["phaseCode", "ratedPower", "servicePriority", "checkBilling", "grounded", "serviceDeliveryRemark", "ratedCurrent", "estimatedLoad", "nominalServiceVoltage", "ctptReference"] + _attr_types = {"phaseCode": str, "ratedPower": float, "servicePriority": str, "checkBilling": bool, "grounded": bool, "serviceDeliveryRemark": str, "ratedCurrent": float, "estimatedLoad": float, "nominalServiceVoltage": int, "ctptReference": int} + _defaults = {"phaseCode": "A", "ratedPower": 0.0, "servicePriority": '', "checkBilling": False, "grounded": False, "serviceDeliveryRemark": '', "ratedCurrent": 0.0, "estimatedLoad": 0.0, "nominalServiceVoltage": 0, "ctptReference": 0} + _enums = {"phaseCode": "PhaseCode"} + _refs = ["PricingStructures", "Transformer", "SDPLocations", "EndDeviceAssets", "EnergyConsumer", "ServiceLocation", "CustomerAgreement", "MeterReadings", "ServiceSupplier", "ServiceCategory"] + _many_refs = ["PricingStructures", "SDPLocations", "EndDeviceAssets", "MeterReadings"] def getPricingStructures(self): """All pricing structures applicable to this service delivery point (with prepayment meter running as a stand-alone device, with no CustomerAgreement or Customer). diff --git a/schemata/CIM14/IEC61968/PaymentMetering/AccountMovement.py b/schemata/CIM14/IEC61968/PaymentMetering/AccountMovement.py index 594b1de..0596dcb 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/AccountMovement.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/AccountMovement.py @@ -20,8 +20,8 @@ class AccountMovement(Element): """Credit/debit movements for an account. """ - def __init__(self, dateTime='', amount=0.0, reason='', **kw_args): - """Initializes a new 'AccountMovement' instance. + def __init__(self, dateTime='', amount=0.0, reason='', *args, **kw_args): + """Initialises a new 'AccountMovement' instance. @param dateTime: Date and time when the credit/debit transaction was performed. @param amount: Amount that was credited to/debited from an account. For example: payment received/interest charge on arrears. @@ -36,5 +36,12 @@ class AccountMovement(Element): #: Reason for credit/debit transaction on an account. Example: payment received/arrears interest levied. self.reason = reason - super(AccountMovement, self).__init__(**kw_args) + super(AccountMovement, self).__init__(*args, **kw_args) + + _attrs = ["dateTime", "amount", "reason"] + _attr_types = {"dateTime": str, "amount": float, "reason": str} + _defaults = {"dateTime": '', "amount": 0.0, "reason": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/PaymentMetering/AccountingUnit.py b/schemata/CIM14/IEC61968/PaymentMetering/AccountingUnit.py index fb1b92f..5e88967 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/AccountingUnit.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/AccountingUnit.py @@ -20,18 +20,18 @@ class AccountingUnit(Element): """Unit for accounting; use either 'energyUnit' or 'currencyUnit' to specify the unit for 'value'. """ - def __init__(self, multiplier='k', monetaryUnit='CNY', energyUnit=0.0, value=0.0, **kw_args): - """Initializes a new 'AccountingUnit' instance. + def __init__(self, multiplier="k", monetaryUnit="CNY", energyUnit=0.0, value=0.0, *args, **kw_args): + """Initialises a new 'AccountingUnit' instance. @param multiplier: Multiplier for the 'energyUnit' or 'monetaryUnit'. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" @param monetaryUnit: Unit of currency. Values are: "CNY", "EUR", "INR", "AUD", "CHF", "DKK", "other", "RUR", "SEK", "GBP", "JPY", "NOK", "CAD", "USD" @param energyUnit: Unit of service. @param value: Value expressed in applicable units. """ - #: Multiplier for the 'energyUnit' or 'monetaryUnit'.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for the 'energyUnit' or 'monetaryUnit'. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.multiplier = multiplier - #: Unit of currency.Values are: "CNY", "EUR", "INR", "AUD", "CHF", "DKK", "other", "RUR", "SEK", "GBP", "JPY", "NOK", "CAD", "USD" + #: Unit of currency. Values are: "CNY", "EUR", "INR", "AUD", "CHF", "DKK", "other", "RUR", "SEK", "GBP", "JPY", "NOK", "CAD", "USD" self.monetaryUnit = monetaryUnit #: Unit of service. @@ -40,5 +40,12 @@ class AccountingUnit(Element): #: Value expressed in applicable units. self.value = value - super(AccountingUnit, self).__init__(**kw_args) + super(AccountingUnit, self).__init__(*args, **kw_args) + + _attrs = ["multiplier", "monetaryUnit", "energyUnit", "value"] + _attr_types = {"multiplier": str, "monetaryUnit": str, "energyUnit": float, "value": float} + _defaults = {"multiplier": "k", "monetaryUnit": "CNY", "energyUnit": 0.0, "value": 0.0} + _enums = {"multiplier": "UnitMultiplier", "monetaryUnit": "Currency"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAccount.py b/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAccount.py index 2680ab3..b954fa9 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAccount.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAccount.py @@ -20,8 +20,8 @@ class AuxiliaryAccount(Document): """Variable and dynamic part of AuxiliaryAgreement, generally representing the current state of the account related to the outstanding balance defined in AuxiliaryAgreement. """ - def __init__(self, balance=0.0, principleAmount=0.0, Charges=None, AuxiliaryAgreement=None, PaymentTransactions=None, lastDebit=None, lastCredit=None, due=None, **kw_args): - """Initializes a new 'AuxiliaryAccount' instance. + def __init__(self, balance=0.0, principleAmount=0.0, Charges=None, AuxiliaryAgreement=None, PaymentTransactions=None, lastDebit=None, lastCredit=None, due=None, *args, **kw_args): + """Initialises a new 'AuxiliaryAccount' instance. @param balance: The total amount currently remaining on this account that is required to be paid in order to settle the account to zero. This excludes any due amounts not yet paid. @param principleAmount: The initial principle amount, with which this account was instantiated. @@ -53,7 +53,14 @@ class AuxiliaryAccount(Document): self.due = due - super(AuxiliaryAccount, self).__init__(**kw_args) + super(AuxiliaryAccount, self).__init__(*args, **kw_args) + + _attrs = ["balance", "principleAmount"] + _attr_types = {"balance": float, "principleAmount": float} + _defaults = {"balance": 0.0, "principleAmount": 0.0} + _enums = {} + _refs = ["Charges", "AuxiliaryAgreement", "PaymentTransactions", "lastDebit", "lastCredit", "due"] + _many_refs = ["Charges", "PaymentTransactions"] def getCharges(self): """All charges levied on this account. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAgreement.py b/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAgreement.py index 3592f04..e29d614 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAgreement.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/AuxiliaryAgreement.py @@ -20,8 +20,8 @@ class AuxiliaryAgreement(Agreement): """An ad-hoc auxiliary account agreement associated with a customer agreement, not part of the customer's account, but typically subject to formal agreement between customer and supplier (utility). Typically this is used to collect revenue owing by the customer for other services or arrears accrued with the utility for other services. It is typically linked to a prepaid token purchase transaction, thus forcing the customer to make a payment towards settlement of the auxiliary account balance whenever he needs to purchase a prepaid token for electricity. The present status of AuxiliaryAgreement can be defined in the context of the utility's business rules, for example: enabled, disabled, pending, over recovered, under recovered, written off, etc. """ - def __init__(self, arrearsInterest=0.0, vendPortion=0.0, minAmount=0.0, auxPriorityCode='', subCategory='', auxRef='', auxCycle='', vendPortionArrear=0.0, payCycle='', fixedAmount=0.0, AuxiliaryAccounts=None, CustomerAgreement=None, **kw_args): - """Initializes a new 'AuxiliaryAgreement' instance. + def __init__(self, arrearsInterest=0.0, vendPortion=0.0, minAmount=0.0, auxPriorityCode='', subCategory='', auxRef='', auxCycle='', vendPortionArrear=0.0, payCycle='', fixedAmount=0.0, AuxiliaryAccounts=None, CustomerAgreement=None, *args, **kw_args): + """Initialises a new 'AuxiliaryAgreement' instance. @param arrearsInterest: The interest per annum to be charged prorata on AuxiliaryAccount.dueArrears at the end of each payCycle. @param vendPortion: The percentage of the transaction amount that must be collected from each vending transaction towards settlement of this AuxiliaryAgreement when payments are not in arrears. Note that there may be multiple tokens vended per vending transaction, but this is not relevant. @@ -72,7 +72,14 @@ class AuxiliaryAgreement(Agreement): self._CustomerAgreement = None self.CustomerAgreement = CustomerAgreement - super(AuxiliaryAgreement, self).__init__(**kw_args) + super(AuxiliaryAgreement, self).__init__(*args, **kw_args) + + _attrs = ["arrearsInterest", "vendPortion", "minAmount", "auxPriorityCode", "subCategory", "auxRef", "auxCycle", "vendPortionArrear", "payCycle", "fixedAmount"] + _attr_types = {"arrearsInterest": float, "vendPortion": float, "minAmount": float, "auxPriorityCode": str, "subCategory": str, "auxRef": str, "auxCycle": str, "vendPortionArrear": float, "payCycle": str, "fixedAmount": float} + _defaults = {"arrearsInterest": 0.0, "vendPortion": 0.0, "minAmount": 0.0, "auxPriorityCode": '', "subCategory": '', "auxRef": '', "auxCycle": '', "vendPortionArrear": 0.0, "payCycle": '', "fixedAmount": 0.0} + _enums = {} + _refs = ["AuxiliaryAccounts", "CustomerAgreement"] + _many_refs = ["AuxiliaryAccounts"] def getAuxiliaryAccounts(self): """All auxiliary accounts regulated by this agreement. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/BankAccountDetail.py b/schemata/CIM14/IEC61968/PaymentMetering/BankAccountDetail.py index 5ea9046..5bcba26 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/BankAccountDetail.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/BankAccountDetail.py @@ -20,8 +20,8 @@ class BankAccountDetail(Element): """Details of a bank account. """ - def __init__(self, holderName='', accountNumber='', bankName='', branchCode='', holderID='', **kw_args): - """Initializes a new 'BankAccountDetail' instance. + def __init__(self, holderName='', accountNumber='', bankName='', branchCode='', holderID='', *args, **kw_args): + """Initialises a new 'BankAccountDetail' instance. @param holderName: Name of account holder. @param accountNumber: Operational account reference number. @@ -44,5 +44,12 @@ class BankAccountDetail(Element): #: National identity number (or equivalent) of account holder. self.holderID = holderID - super(BankAccountDetail, self).__init__(**kw_args) + super(BankAccountDetail, self).__init__(*args, **kw_args) + + _attrs = ["holderName", "accountNumber", "bankName", "branchCode", "holderID"] + _attr_types = {"holderName": str, "accountNumber": str, "bankName": str, "branchCode": str, "holderID": str} + _defaults = {"holderName": '', "accountNumber": '', "bankName": '', "branchCode": '', "holderID": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Card.py b/schemata/CIM14/IEC61968/PaymentMetering/Card.py index 64bce74..070691d 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Card.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Card.py @@ -20,8 +20,8 @@ class Card(Element): """Documentation of the tender when it is a type of card (credit, debit, etc). """ - def __init__(self, pan='', expiryDate='', cvNumber='', accountHolderName='', Tender=None, **kw_args): - """Initializes a new 'Card' instance. + def __init__(self, pan='', expiryDate='', cvNumber='', accountHolderName='', Tender=None, *args, **kw_args): + """Initialises a new 'Card' instance. @param pan: The primary account number. @param expiryDate: The date when this card expires. @@ -44,7 +44,14 @@ class Card(Element): self._Tender = None self.Tender = Tender - super(Card, self).__init__(**kw_args) + super(Card, self).__init__(*args, **kw_args) + + _attrs = ["pan", "expiryDate", "cvNumber", "accountHolderName"] + _attr_types = {"pan": str, "expiryDate": str, "cvNumber": str, "accountHolderName": str} + _defaults = {"pan": '', "expiryDate": '', "cvNumber": '', "accountHolderName": ''} + _enums = {} + _refs = ["Tender"] + _many_refs = [] def getTender(self): """Payment tender this card is being used for. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Cashier.py b/schemata/CIM14/IEC61968/PaymentMetering/Cashier.py index 52cce39..b091056 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Cashier.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Cashier.py @@ -20,8 +20,8 @@ class Cashier(IdentifiedObject): """The operator of the point of sale for the duration of CashierShift. Cashier is under the exclusive management control of Vendor. """ - def __init__(self, CashierShifts=None, electronicAddress=None, Vendor=None, **kw_args): - """Initializes a new 'Cashier' instance. + def __init__(self, CashierShifts=None, electronicAddress=None, Vendor=None, *args, **kw_args): + """Initialises a new 'Cashier' instance. @param CashierShifts: All shifts operated by this cashier. @param electronicAddress: Electronic address. @@ -35,7 +35,14 @@ class Cashier(IdentifiedObject): self._Vendor = None self.Vendor = Vendor - super(Cashier, self).__init__(**kw_args) + super(Cashier, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["CashierShifts", "electronicAddress", "Vendor"] + _many_refs = ["CashierShifts"] def getCashierShifts(self): """All shifts operated by this cashier. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/CashierShift.py b/schemata/CIM14/IEC61968/PaymentMetering/CashierShift.py index 23362ef..5906993 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/CashierShift.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/CashierShift.py @@ -20,8 +20,8 @@ class CashierShift(Shift): """The operating shift for a cashier, during which he may transact against the CashierShift, subject to VendorShift being open. """ - def __init__(self, cashFloat=0.0, Receipts=None, Transactions=None, Cashier=None, PointOfSale=None, **kw_args): - """Initializes a new 'CashierShift' instance. + def __init__(self, cashFloat=0.0, Receipts=None, Transactions=None, Cashier=None, PointOfSale=None, *args, **kw_args): + """Initialises a new 'CashierShift' instance. @param cashFloat: The amount of cash that the cashier brings with him to start his shift and that he will take away at the end of his shift; i.e. the cash float does not get banked. @param Receipts: All Receipts recorded for this Shift. @@ -44,7 +44,14 @@ class CashierShift(Shift): self._PointOfSale = None self.PointOfSale = PointOfSale - super(CashierShift, self).__init__(**kw_args) + super(CashierShift, self).__init__(*args, **kw_args) + + _attrs = ["cashFloat"] + _attr_types = {"cashFloat": float} + _defaults = {"cashFloat": 0.0} + _enums = {} + _refs = ["Receipts", "Transactions", "Cashier", "PointOfSale"] + _many_refs = ["Receipts", "Transactions"] def getReceipts(self): """All Receipts recorded for this Shift. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Charge.py b/schemata/CIM14/IEC61968/PaymentMetering/Charge.py index ba9eb50..da16f12 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Charge.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Charge.py @@ -20,8 +20,8 @@ class Charge(IdentifiedObject): """A charge element associated with other entities such as tariff structures, auxiliary agreements or other charge elements. The total charge amount applicable to this instance of Charge is the sum of fixedPortion plus percentagePortion. """ - def __init__(self, kind='demandCharge', variablePortion=0.0, AuxiliaryAccounts=None, ParentCharge=None, ChildCharges=None, fixedPortion=None, ConsumptionTariffIntervals=None, TimeTariffIntervals=None, **kw_args): - """Initializes a new 'Charge' instance. + def __init__(self, kind="demandCharge", variablePortion=0.0, AuxiliaryAccounts=None, ParentCharge=None, ChildCharges=None, fixedPortion=None, ConsumptionTariffIntervals=None, TimeTariffIntervals=None, *args, **kw_args): + """Initialises a new 'Charge' instance. @param kind: The kind of charge to be applied. Values are: "demandCharge", "other", "auxiliaryCharge", "taxCharge", "consumptionCharge" @param variablePortion: The variable portion of this charge element, calculated as a percentage of the total amount of a parent charge. @@ -32,7 +32,7 @@ class Charge(IdentifiedObject): @param ConsumptionTariffIntervals: Tariff intervals to which this consumption-based charge must be levied. @param TimeTariffIntervals: Tariff intervals to which this time-based charge must be levied. """ - #: The kind of charge to be applied.Values are: "demandCharge", "other", "auxiliaryCharge", "taxCharge", "consumptionCharge" + #: The kind of charge to be applied. Values are: "demandCharge", "other", "auxiliaryCharge", "taxCharge", "consumptionCharge" self.kind = kind #: The variable portion of this charge element, calculated as a percentage of the total amount of a parent charge. @@ -55,7 +55,14 @@ class Charge(IdentifiedObject): self._TimeTariffIntervals = [] self.TimeTariffIntervals = [] if TimeTariffIntervals is None else TimeTariffIntervals - super(Charge, self).__init__(**kw_args) + super(Charge, self).__init__(*args, **kw_args) + + _attrs = ["kind", "variablePortion"] + _attr_types = {"kind": str, "variablePortion": float} + _defaults = {"kind": "demandCharge", "variablePortion": 0.0} + _enums = {"kind": "ChargeKind"} + _refs = ["AuxiliaryAccounts", "ParentCharge", "ChildCharges", "fixedPortion", "ConsumptionTariffIntervals", "TimeTariffIntervals"] + _many_refs = ["AuxiliaryAccounts", "ChildCharges", "ConsumptionTariffIntervals", "TimeTariffIntervals"] def getAuxiliaryAccounts(self): """All auxiliary accounts to which this charge must be levied. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Cheque.py b/schemata/CIM14/IEC61968/PaymentMetering/Cheque.py index f806f75..97b4d1b 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Cheque.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Cheque.py @@ -20,8 +20,8 @@ class Cheque(Element): """The actual tender when it is a type of cheque. """ - def __init__(self, kind='other', micrNumber='', date='', chequeNumber='', Tender=None, bankAccountDetail=None, **kw_args): - """Initializes a new 'Cheque' instance. + def __init__(self, kind="other", micrNumber='', date='', chequeNumber='', Tender=None, bankAccountDetail=None, *args, **kw_args): + """Initialises a new 'Cheque' instance. @param kind: Kind of cheque. Values are: "other", "postalOrder", "bankOrder" @param micrNumber: The magnetic ink character recognition number printed on the cheque. @@ -30,7 +30,7 @@ class Cheque(Element): @param Tender: Payment tender the cheque is being used for. @param bankAccountDetail: Details of the account holder and bank. """ - #: Kind of cheque.Values are: "other", "postalOrder", "bankOrder" + #: Kind of cheque. Values are: "other", "postalOrder", "bankOrder" self.kind = kind #: The magnetic ink character recognition number printed on the cheque. @@ -47,7 +47,14 @@ class Cheque(Element): self.bankAccountDetail = bankAccountDetail - super(Cheque, self).__init__(**kw_args) + super(Cheque, self).__init__(*args, **kw_args) + + _attrs = ["kind", "micrNumber", "date", "chequeNumber"] + _attr_types = {"kind": str, "micrNumber": str, "date": str, "chequeNumber": str} + _defaults = {"kind": "other", "micrNumber": '', "date": '', "chequeNumber": ''} + _enums = {"kind": "ChequeKind"} + _refs = ["Tender", "bankAccountDetail"] + _many_refs = [] def getTender(self): """Payment tender the cheque is being used for. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/ConsumptionTariffInterval.py b/schemata/CIM14/IEC61968/PaymentMetering/ConsumptionTariffInterval.py index 62eb8bb..2380960 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/ConsumptionTariffInterval.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/ConsumptionTariffInterval.py @@ -20,8 +20,8 @@ class ConsumptionTariffInterval(Element): """One of a sequence of intervals defined in terms of consumption quantity of a service such as electricity, water, gas, etc. It is typically used in association with TariffProfile to define the steps or blocks in a step tariff structure, where startValue simultaneously defines the entry value of this step and the closing value of the previous step. Where consumption is >= startValue it falls within this interval and where consumption is < startValue it falls within the previous interval. """ - def __init__(self, sequenceNumber=0, startValue=0.0, TariffProfiles=None, Charges=None, **kw_args): - """Initializes a new 'ConsumptionTariffInterval' instance. + def __init__(self, sequenceNumber=0, startValue=0.0, TariffProfiles=None, Charges=None, *args, **kw_args): + """Initialises a new 'ConsumptionTariffInterval' instance. @param sequenceNumber: A sequential reference that defines the identity of this interval and its relative position with respect to other intervals in a sequence of intervals. @param startValue: The lowest level of consumption that defines the starting point of this interval. The interval extends to the start of the next interval or until it is reset to the start of the first interval by TariffProfile.tariffCycle. @@ -40,7 +40,14 @@ class ConsumptionTariffInterval(Element): self._Charges = [] self.Charges = [] if Charges is None else Charges - super(ConsumptionTariffInterval, self).__init__(**kw_args) + super(ConsumptionTariffInterval, self).__init__(*args, **kw_args) + + _attrs = ["sequenceNumber", "startValue"] + _attr_types = {"sequenceNumber": int, "startValue": float} + _defaults = {"sequenceNumber": 0, "startValue": 0.0} + _enums = {} + _refs = ["TariffProfiles", "Charges"] + _many_refs = ["TariffProfiles", "Charges"] def getTariffProfiles(self): """All tariff profiles defined by this consumption tariff interval. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Due.py b/schemata/CIM14/IEC61968/PaymentMetering/Due.py index dcd057c..d459937 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Due.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Due.py @@ -20,8 +20,8 @@ class Due(Element): """Details on amounts due for an account. """ - def __init__(self, interest=0.0, principle=0.0, arrears=0.0, current=0.0, charges=0.0, **kw_args): - """Initializes a new 'Due' instance. + def __init__(self, interest=0.0, principle=0.0, arrears=0.0, current=0.0, charges=0.0, *args, **kw_args): + """Initialises a new 'Due' instance. @param interest: Part of 'current' that constitutes the interest portion. @param principle: Part of 'current' that constitutes the portion of the principle amount currently due. @@ -44,5 +44,12 @@ class Due(Element): #: Part of 'current' that constitutes the charge portion: 'charges' = 'Charge.fixedPortion' + 'Charge.variablePortion'. self.charges = charges - super(Due, self).__init__(**kw_args) + super(Due, self).__init__(*args, **kw_args) + + _attrs = ["interest", "principle", "arrears", "current", "charges"] + _attr_types = {"interest": float, "principle": float, "arrears": float, "current": float, "charges": float} + _defaults = {"interest": 0.0, "principle": 0.0, "arrears": 0.0, "current": 0.0, "charges": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/PaymentMetering/LineDetail.py b/schemata/CIM14/IEC61968/PaymentMetering/LineDetail.py index a482dc5..08a151c 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/LineDetail.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/LineDetail.py @@ -20,8 +20,8 @@ class LineDetail(Element): """Details on an amount line, with rounding, date and note. """ - def __init__(self, dateTime='', rounding=0.0, note='', amount=0.0, **kw_args): - """Initializes a new 'LineDetail' instance. + def __init__(self, dateTime='', rounding=0.0, note='', amount=0.0, *args, **kw_args): + """Initialises a new 'LineDetail' instance. @param dateTime: Date and time when this line was created in the application process. @param rounding: Totalised monetary value of all errors due to process rounding or truncating that is not reflected in 'amount'. @@ -40,5 +40,12 @@ class LineDetail(Element): #: Amount for this line item. self.amount = amount - super(LineDetail, self).__init__(**kw_args) + super(LineDetail, self).__init__(*args, **kw_args) + + _attrs = ["dateTime", "rounding", "note", "amount"] + _attr_types = {"dateTime": str, "rounding": float, "note": str, "amount": float} + _defaults = {"dateTime": '', "rounding": 0.0, "note": '', "amount": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/PaymentMetering/MerchantAccount.py b/schemata/CIM14/IEC61968/PaymentMetering/MerchantAccount.py index 2e09f0e..29c50ec 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/MerchantAccount.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/MerchantAccount.py @@ -20,8 +20,8 @@ class MerchantAccount(Document): """The operating account controlled by MerchantAgreement, against which Vendor may vend tokens or receipt payments. Transactions via VendorShift debit the account and bank deposits via BankStatement credit the account. """ - def __init__(self, provisionalBalance=0.0, currentBalance=0.0, VendorShifts=None, MerchantAgreement=None, Vendors=None, Transactors=None, **kw_args): - """Initializes a new 'MerchantAccount' instance. + def __init__(self, provisionalBalance=0.0, currentBalance=0.0, VendorShifts=None, MerchantAgreement=None, Vendors=None, Transactors=None, *args, **kw_args): + """Initialises a new 'MerchantAccount' instance. @param provisionalBalance: The balance of this account after taking into account any pending debits from VendorShift.merchantDebitAmount and pending credits from BankStatement.merchantCreditAmount or credits (see also BankStatement attributes and VendorShift attributes). @param currentBalance: The current operating balance of this account. @@ -48,7 +48,14 @@ class MerchantAccount(Document): self._Transactors = [] self.Transactors = [] if Transactors is None else Transactors - super(MerchantAccount, self).__init__(**kw_args) + super(MerchantAccount, self).__init__(*args, **kw_args) + + _attrs = ["provisionalBalance", "currentBalance"] + _attr_types = {"provisionalBalance": float, "currentBalance": float} + _defaults = {"provisionalBalance": 0.0, "currentBalance": 0.0} + _enums = {} + _refs = ["VendorShifts", "MerchantAgreement", "Vendors", "Transactors"] + _many_refs = ["VendorShifts", "Vendors", "Transactors"] def getVendorShifts(self): """All vendor shifts that operate on this merchant account. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/MerchantAgreement.py b/schemata/CIM14/IEC61968/PaymentMetering/MerchantAgreement.py index 11995df..bf4a46f 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/MerchantAgreement.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/MerchantAgreement.py @@ -20,15 +20,22 @@ class MerchantAgreement(Agreement): """A formal controlling contractual agreement between Supplier and Merchant, in terms of which Merchant is authorised to vend tokens and receipt payments on behalf of Supplier. Merchant is accountable to Supplier for revenue collected at PointOfSale. """ - def __init__(self, MerchantAccounts=None, **kw_args): - """Initializes a new 'MerchantAgreement' instance. + def __init__(self, MerchantAccounts=None, *args, **kw_args): + """Initialises a new 'MerchantAgreement' instance. @param MerchantAccounts: All merchant accounts instantiated as a result of this merchant agreement. """ self._MerchantAccounts = [] self.MerchantAccounts = [] if MerchantAccounts is None else MerchantAccounts - super(MerchantAgreement, self).__init__(**kw_args) + super(MerchantAgreement, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MerchantAccounts"] + _many_refs = ["MerchantAccounts"] def getMerchantAccounts(self): """All merchant accounts instantiated as a result of this merchant agreement. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/PointOfSale.py b/schemata/CIM14/IEC61968/PaymentMetering/PointOfSale.py index 77148a4..6003beb 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/PointOfSale.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/PointOfSale.py @@ -20,8 +20,8 @@ class PointOfSale(IdentifiedObject): """Logical point where transactions take place with operational interaction between Cashier and the payment system; in certain cases PointOfSale interacts directly with the end customer, in which case Cashier might not be a real person: for example a self-service kiosk or over the internet. """ - def __init__(self, location='', Vendor=None, CashierShifts=None, **kw_args): - """Initializes a new 'PointOfSale' instance. + def __init__(self, location='', Vendor=None, CashierShifts=None, *args, **kw_args): + """Initialises a new 'PointOfSale' instance. @param location: Local description for where this point of sale is physically located. @param Vendor: Vendor that controls this PointOfSale. @@ -36,7 +36,14 @@ class PointOfSale(IdentifiedObject): self._CashierShifts = [] self.CashierShifts = [] if CashierShifts is None else CashierShifts - super(PointOfSale, self).__init__(**kw_args) + super(PointOfSale, self).__init__(*args, **kw_args) + + _attrs = ["location"] + _attr_types = {"location": str} + _defaults = {"location": ''} + _enums = {} + _refs = ["Vendor", "CashierShifts"] + _many_refs = ["CashierShifts"] def getVendor(self): """Vendor that controls this PointOfSale. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Receipt.py b/schemata/CIM14/IEC61968/PaymentMetering/Receipt.py index 9706e1c..2d30e90 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Receipt.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Receipt.py @@ -20,8 +20,8 @@ class Receipt(IdentifiedObject): """Record of total receipted payment from customer. """ - def __init__(self, isBankable=False, CashierShift=None, Tenders=None, VendorShift=None, Transactions=None, line=None, **kw_args): - """Initializes a new 'Receipt' instance. + def __init__(self, isBankable=False, CashierShift=None, Tenders=None, VendorShift=None, Transactions=None, line=None, *args, **kw_args): + """Initialises a new 'Receipt' instance. @param isBankable: True if this receipted payment is manually bankable, otherwise it is an electronic funds transfer. @param CashierShift: Cashier shift during which this receipt was recorded. @@ -47,7 +47,14 @@ class Receipt(IdentifiedObject): self.line = line - super(Receipt, self).__init__(**kw_args) + super(Receipt, self).__init__(*args, **kw_args) + + _attrs = ["isBankable"] + _attr_types = {"isBankable": bool} + _defaults = {"isBankable": False} + _enums = {} + _refs = ["CashierShift", "Tenders", "VendorShift", "Transactions", "line"] + _many_refs = ["Tenders", "Transactions"] def getCashierShift(self): """Cashier shift during which this receipt was recorded. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/ServiceSupplier.py b/schemata/CIM14/IEC61968/PaymentMetering/ServiceSupplier.py index f219ad6..2054f14 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/ServiceSupplier.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/ServiceSupplier.py @@ -20,15 +20,15 @@ class ServiceSupplier(Organisation): """Organisation that provides services to Customers. """ - def __init__(self, kind='retailer', issuerIdentificationNumber='', CustomerAgreements=None, ServiceDeliveryPoints=None, **kw_args): - """Initializes a new 'ServiceSupplier' instance. + def __init__(self, kind="retailer", issuerIdentificationNumber='', CustomerAgreements=None, ServiceDeliveryPoints=None, *args, **kw_args): + """Initialises a new 'ServiceSupplier' instance. @param kind: Kind of supplier. Values are: "retailer", "utility", "other" @param issuerIdentificationNumber: Unique transaction reference prefix number issued to an entity by the International Standards Organisation for the purpose of tagging onto electronic financial transactions, as defined in ISO/IEC 7812-1 and ISO/IEC 7812-2. @param CustomerAgreements: All customer agreements of this service supplier. @param ServiceDeliveryPoints: All service delivery points this service supplier utilises to deliver a service. """ - #: Kind of supplier.Values are: "retailer", "utility", "other" + #: Kind of supplier. Values are: "retailer", "utility", "other" self.kind = kind #: Unique transaction reference prefix number issued to an entity by the International Standards Organisation for the purpose of tagging onto electronic financial transactions, as defined in ISO/IEC 7812-1 and ISO/IEC 7812-2. @@ -40,7 +40,14 @@ class ServiceSupplier(Organisation): self._ServiceDeliveryPoints = [] self.ServiceDeliveryPoints = [] if ServiceDeliveryPoints is None else ServiceDeliveryPoints - super(ServiceSupplier, self).__init__(**kw_args) + super(ServiceSupplier, self).__init__(*args, **kw_args) + + _attrs = ["kind", "issuerIdentificationNumber"] + _attr_types = {"kind": str, "issuerIdentificationNumber": str} + _defaults = {"kind": "retailer", "issuerIdentificationNumber": ''} + _enums = {"kind": "SupplierKind"} + _refs = ["CustomerAgreements", "ServiceDeliveryPoints"] + _many_refs = ["CustomerAgreements", "ServiceDeliveryPoints"] def getCustomerAgreements(self): """All customer agreements of this service supplier. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Shift.py b/schemata/CIM14/IEC61968/PaymentMetering/Shift.py index b460687..589c321 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Shift.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Shift.py @@ -20,8 +20,8 @@ class Shift(IdentifiedObject): """Generally referring to a period of operation or work performed. Whether shift is open/closed can be derived from attributes 'activiryInterval.start' and 'activityInterval.end'. The grand total for receipts (i.e., cumulative total of all actual receipted amounts during this shift; bankable + non-bankable; excludes rounding error totals) can be derived from Receipt attributes: =sum(Receipt.receiptAmount) ; includes bankable and non-bankable receipts. Must also reconcile against: =sum(receiptsGrandTotalBankable + receiptsGrandTotalNonBankable). Must also reconcile against ReceiptSummary: =sum(ReceiptSummary.receiptsTotal). The attributes with 'GrandTotal' defined in this class may need to be used when the source data is periodically flushed from the system and then these cannot be derived. """ - def __init__(self, receiptsGrandTotalNonBankable=0.0, receiptsGrandTotalBankable=0.0, receiptsGrandTotalRounding=0.0, transactionsGrandTotal=0.0, transactionsGrandTotalRounding=0.0, activityInterval=None, **kw_args): - """Initializes a new 'Shift' instance. + def __init__(self, receiptsGrandTotalNonBankable=0.0, receiptsGrandTotalBankable=0.0, receiptsGrandTotalRounding=0.0, transactionsGrandTotal=0.0, transactionsGrandTotalRounding=0.0, activityInterval=None, *args, **kw_args): + """Initialises a new 'Shift' instance. @param receiptsGrandTotalNonBankable: Total of amounts receipted during this shift that cannot be manually banked (card payments for example). Values are obtained from Receipt attributes: =sum(Receipt.receiptAmount) for all Receipt.bankable = false. @param receiptsGrandTotalBankable: Total of amounts receipted during this shift that can be manually banked (cash and cheques for example). Values are obtained from Receipt attributes: =sum(Receipt.receiptAmount) for all Receipt.bankable = true. @@ -47,7 +47,14 @@ class Shift(IdentifiedObject): self.activityInterval = activityInterval - super(Shift, self).__init__(**kw_args) + super(Shift, self).__init__(*args, **kw_args) + + _attrs = ["receiptsGrandTotalNonBankable", "receiptsGrandTotalBankable", "receiptsGrandTotalRounding", "transactionsGrandTotal", "transactionsGrandTotalRounding"] + _attr_types = {"receiptsGrandTotalNonBankable": float, "receiptsGrandTotalBankable": float, "receiptsGrandTotalRounding": float, "transactionsGrandTotal": float, "transactionsGrandTotalRounding": float} + _defaults = {"receiptsGrandTotalNonBankable": 0.0, "receiptsGrandTotalBankable": 0.0, "receiptsGrandTotalRounding": 0.0, "transactionsGrandTotal": 0.0, "transactionsGrandTotalRounding": 0.0} + _enums = {} + _refs = ["activityInterval"] + _many_refs = [] # Interval for activity of this shift. activityInterval = None diff --git a/schemata/CIM14/IEC61968/PaymentMetering/TariffProfile.py b/schemata/CIM14/IEC61968/PaymentMetering/TariffProfile.py index f481f67..f7ee029 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/TariffProfile.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/TariffProfile.py @@ -20,8 +20,8 @@ class TariffProfile(Document): """A schedule of charges; structure associated with Tariff that allows the definition of complex tarif structures such as step and time of use when used in conjunction with TimeTariffInterval and Charge. Inherited 'status.value' is defined in the context of the utility's business rules, for example: active, inactive, etc. """ - def __init__(self, tariffCycle='', ConsumptionTariffIntervals=None, TimeTariffIntervals=None, Tariffs=None, **kw_args): - """Initializes a new 'TariffProfile' instance. + def __init__(self, tariffCycle='', ConsumptionTariffIntervals=None, TimeTariffIntervals=None, Tariffs=None, *args, **kw_args): + """Initialises a new 'TariffProfile' instance. @param tariffCycle: The frequency at which the tariff charge schedule is repeated Examples are: once off on a specified date and time; hourly; daily; weekly; monthly; 3-monthly; 6-monthly; 12-monthly; etc. At the end of each cycle, the business rules are reset to start from the beginning again. @param ConsumptionTariffIntervals: All consumption tariff intervals used to define this tariff profile. @@ -40,7 +40,14 @@ class TariffProfile(Document): self._Tariffs = [] self.Tariffs = [] if Tariffs is None else Tariffs - super(TariffProfile, self).__init__(**kw_args) + super(TariffProfile, self).__init__(*args, **kw_args) + + _attrs = ["tariffCycle"] + _attr_types = {"tariffCycle": str} + _defaults = {"tariffCycle": ''} + _enums = {} + _refs = ["ConsumptionTariffIntervals", "TimeTariffIntervals", "Tariffs"] + _many_refs = ["ConsumptionTariffIntervals", "TimeTariffIntervals", "Tariffs"] def getConsumptionTariffIntervals(self): """All consumption tariff intervals used to define this tariff profile. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Tender.py b/schemata/CIM14/IEC61968/PaymentMetering/Tender.py index 6ce5419..50766d0 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Tender.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Tender.py @@ -20,8 +20,8 @@ class Tender(IdentifiedObject): """Tender is what is 'offered' by the customer towards making a payment and is often more than the required payment (hence the need for 'change'). The payment is thus that part of the Tender that goes towards settlement of a particular transaction. Tender is modelled as an aggregation of Cheque and Card. Both these tender types can exist in a single tender bid thus 'accountHolderName' must exist separately in each of Cheque and Card as each could have a different account holder name. """ - def __init__(self, kind='cash', amount=0.0, change=0.0, Cheque=None, Receipt=None, Card=None, **kw_args): - """Initializes a new 'Tender' instance. + def __init__(self, kind="cash", amount=0.0, change=0.0, Cheque=None, Receipt=None, Card=None, *args, **kw_args): + """Initialises a new 'Tender' instance. @param kind: Kind of tender from customer. Values are: "cash", "unspecified", "card", "other", "cheque" @param amount: Amount tendered by customer. @@ -30,7 +30,7 @@ class Tender(IdentifiedObject): @param Receipt: Receipt that recorded this receiving of a payment in the form of tenders. @param Card: Card used to tender payment. """ - #: Kind of tender from customer.Values are: "cash", "unspecified", "card", "other", "cheque" + #: Kind of tender from customer. Values are: "cash", "unspecified", "card", "other", "cheque" self.kind = kind #: Amount tendered by customer. @@ -48,7 +48,14 @@ class Tender(IdentifiedObject): self._Card = None self.Card = Card - super(Tender, self).__init__(**kw_args) + super(Tender, self).__init__(*args, **kw_args) + + _attrs = ["kind", "amount", "change"] + _attr_types = {"kind": str, "amount": float, "change": float} + _defaults = {"kind": "cash", "amount": 0.0, "change": 0.0} + _enums = {"kind": "TenderKind"} + _refs = ["Cheque", "Receipt", "Card"] + _many_refs = [] def getCheque(self): """Cheque used to tender payment. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/TimeTariffInterval.py b/schemata/CIM14/IEC61968/PaymentMetering/TimeTariffInterval.py index 95b60cd..cf1f9e9 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/TimeTariffInterval.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/TimeTariffInterval.py @@ -20,8 +20,8 @@ class TimeTariffInterval(Element): """One of a sequence of time intervals defined in terms of real time. It is typically used in association with TariffProfile to define the intervals in a time of use tariff structure, where startDateTime simultaneously determines the starting point of this interval and the ending point of the previous interval. """ - def __init__(self, sequenceNumber=0, startDateTime='', TariffProfiles=None, Charges=None, **kw_args): - """Initializes a new 'TimeTariffInterval' instance. + def __init__(self, sequenceNumber=0, startDateTime='', TariffProfiles=None, Charges=None, *args, **kw_args): + """Initialises a new 'TimeTariffInterval' instance. @param sequenceNumber: A sequential reference that defines the identity of this interval and its relative position with respect to other intervals in a sequence of intervals. @param startDateTime: A real time marker that defines the starting time (typically it is the time of day) for this interval. The interval extends to the start of the next interval or until it is reset to the start of the first interval by TariffProfile.tariffCycle. @@ -40,7 +40,14 @@ class TimeTariffInterval(Element): self._Charges = [] self.Charges = [] if Charges is None else Charges - super(TimeTariffInterval, self).__init__(**kw_args) + super(TimeTariffInterval, self).__init__(*args, **kw_args) + + _attrs = ["sequenceNumber", "startDateTime"] + _attr_types = {"sequenceNumber": int, "startDateTime": str} + _defaults = {"sequenceNumber": 0, "startDateTime": ''} + _enums = {} + _refs = ["TariffProfiles", "Charges"] + _many_refs = ["TariffProfiles", "Charges"] def getTariffProfiles(self): """All tariff profiles defined by this time tariff interval. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Transaction.py b/schemata/CIM14/IEC61968/PaymentMetering/Transaction.py index 9e3e5fc..d121141 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Transaction.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Transaction.py @@ -20,8 +20,8 @@ class Transaction(IdentifiedObject): """The record of details of payment for service or token sale. """ - def __init__(self, kind='diversePayment', serviceUnitsEnergy=0.0, diverseReference='', receiverReference='', donorReference='', serviceUnitsError=0.0, reversedId='', PricingStructure=None, UserAttributes=None, CustomerAccount=None, CashierShift=None, VendorShift=None, MeterAsset=None, AuxiliaryAccount=None, line=None, Receipt=None, **kw_args): - """Initializes a new 'Transaction' instance. + def __init__(self, kind="diversePayment", serviceUnitsEnergy=0.0, diverseReference='', receiverReference='', donorReference='', serviceUnitsError=0.0, reversedId='', PricingStructure=None, UserAttributes=None, CustomerAccount=None, CashierShift=None, VendorShift=None, MeterAsset=None, AuxiliaryAccount=None, line=None, Receipt=None, *args, **kw_args): + """Initialises a new 'Transaction' instance. @param kind: Kind of transaction. Values are: "diversePayment", "tokenSalePayment", "serviceChargePayment", "other", "transactionReversal", "taxChargePayment", "meterConfigurationToken", "accountPayment", "tokenFreeIssue", "tokenExchange", "tokenCancellation", "tokenGrant", "auxiliaryChargePayment" @param serviceUnitsEnergy: Actual amount of service units that is being paid for. @@ -40,7 +40,7 @@ class Transaction(IdentifiedObject): @param line: Transaction amount, rounding, date and note for this transaction line. @param Receipt: The receipted payment for which this transaction has been recorded. """ - #: Kind of transaction.Values are: "diversePayment", "tokenSalePayment", "serviceChargePayment", "other", "transactionReversal", "taxChargePayment", "meterConfigurationToken", "accountPayment", "tokenFreeIssue", "tokenExchange", "tokenCancellation", "tokenGrant", "auxiliaryChargePayment" + #: Kind of transaction. Values are: "diversePayment", "tokenSalePayment", "serviceChargePayment", "other", "transactionReversal", "taxChargePayment", "meterConfigurationToken", "accountPayment", "tokenFreeIssue", "tokenExchange", "tokenCancellation", "tokenGrant", "auxiliaryChargePayment" self.kind = kind #: Actual amount of service units that is being paid for. @@ -87,7 +87,14 @@ class Transaction(IdentifiedObject): self._Receipt = None self.Receipt = Receipt - super(Transaction, self).__init__(**kw_args) + super(Transaction, self).__init__(*args, **kw_args) + + _attrs = ["kind", "serviceUnitsEnergy", "diverseReference", "receiverReference", "donorReference", "serviceUnitsError", "reversedId"] + _attr_types = {"kind": str, "serviceUnitsEnergy": float, "diverseReference": str, "receiverReference": str, "donorReference": str, "serviceUnitsError": float, "reversedId": str} + _defaults = {"kind": "diversePayment", "serviceUnitsEnergy": 0.0, "diverseReference": '', "receiverReference": '', "donorReference": '', "serviceUnitsError": 0.0, "reversedId": ''} + _enums = {"kind": "TransactionKind"} + _refs = ["PricingStructure", "UserAttributes", "CustomerAccount", "CashierShift", "VendorShift", "MeterAsset", "AuxiliaryAccount", "line", "Receipt"] + _many_refs = ["UserAttributes"] def getPricingStructure(self): """Pricing structure applicable for this transaction. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Transactor.py b/schemata/CIM14/IEC61968/PaymentMetering/Transactor.py index 58898f7..2a04b79 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Transactor.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Transactor.py @@ -20,15 +20,22 @@ class Transactor(IdentifiedObject): """The entity that ultimately executes the transaction and who is in control of the process; typically this is embodied in secure software running on a server that may employ secure hardware encryption devices for secure transaction processing. """ - def __init__(self, MerchantAccounts=None, **kw_args): - """Initializes a new 'Transactor' instance. + def __init__(self, MerchantAccounts=None, *args, **kw_args): + """Initialises a new 'Transactor' instance. @param MerchantAccounts: All merchant accounts registered with this transactor. """ self._MerchantAccounts = [] self.MerchantAccounts = [] if MerchantAccounts is None else MerchantAccounts - super(Transactor, self).__init__(**kw_args) + super(Transactor, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MerchantAccounts"] + _many_refs = ["MerchantAccounts"] def getMerchantAccounts(self): """All merchant accounts registered with this transactor. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/Vendor.py b/schemata/CIM14/IEC61968/PaymentMetering/Vendor.py index 362d1bf..9a801b3 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/Vendor.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/Vendor.py @@ -20,8 +20,8 @@ class Vendor(IdentifiedObject): """The entity that owns PointOfSale and contracts with Cashier to receipt payments and vend tokens using the payment system. Vendor has a private contract with and is managed by Merchant who is a type of Organisation. Vendor is accountable to Merchant for revenue collected, who is in turn accountable to Supplier. """ - def __init__(self, PointOfSales=None, MerchantAccount=None, Cashiers=None, VendorShifts=None, **kw_args): - """Initializes a new 'Vendor' instance. + def __init__(self, PointOfSales=None, MerchantAccount=None, Cashiers=None, VendorShifts=None, *args, **kw_args): + """Initialises a new 'Vendor' instance. @param PointOfSales: All points of sale this Vendor controls. @param MerchantAccount: Merchant account against which this vendor sells tokens or recept payments. @@ -40,7 +40,14 @@ class Vendor(IdentifiedObject): self._VendorShifts = [] self.VendorShifts = [] if VendorShifts is None else VendorShifts - super(Vendor, self).__init__(**kw_args) + super(Vendor, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["PointOfSales", "MerchantAccount", "Cashiers", "VendorShifts"] + _many_refs = ["PointOfSales", "Cashiers", "VendorShifts"] def getPointOfSales(self): """All points of sale this Vendor controls. diff --git a/schemata/CIM14/IEC61968/PaymentMetering/VendorShift.py b/schemata/CIM14/IEC61968/PaymentMetering/VendorShift.py index 1356ada..bd18873 100644 --- a/schemata/CIM14/IEC61968/PaymentMetering/VendorShift.py +++ b/schemata/CIM14/IEC61968/PaymentMetering/VendorShift.py @@ -20,8 +20,8 @@ class VendorShift(Shift): """The operating shift for a vendor during which he may transact against the merchant's account. It aggregates transactions and receipts during the shift and periodically debits a merchant account. The totals in VendorShift should always = sum of totals aggregated in all cashier shifts that were open under the particular vendor shift. """ - def __init__(self, merchantDebitAmount=0.0, posted=False, MerchantAccount=None, Transactions=None, Receipts=None, Vendor=None, **kw_args): - """Initializes a new 'VendorShift' instance. + def __init__(self, merchantDebitAmount=0.0, posted=False, MerchantAccount=None, Transactions=None, Receipts=None, Vendor=None, *args, **kw_args): + """Initialises a new 'VendorShift' instance. @param merchantDebitAmount: The amount that is to be debited from the merchant account for this vendor shift. This amount reflects the sum(PaymentTransaction.transactionAmount). @param posted: = true if merchantDebitAmount has been debited from MerchantAccount; typically happens at the end of VendorShift when it closes. @@ -48,7 +48,14 @@ class VendorShift(Shift): self._Vendor = None self.Vendor = Vendor - super(VendorShift, self).__init__(**kw_args) + super(VendorShift, self).__init__(*args, **kw_args) + + _attrs = ["merchantDebitAmount", "posted"] + _attr_types = {"merchantDebitAmount": float, "posted": bool} + _defaults = {"merchantDebitAmount": 0.0, "posted": False} + _enums = {} + _refs = ["MerchantAccount", "Transactions", "Receipts", "Vendor"] + _many_refs = ["Transactions", "Receipts"] def getMerchantAccount(self): """Merchant account this vendor shift periodically debits (based on aggregated transactions). diff --git a/schemata/CIM14/IEC61968/WiresExt/DistributionLineSegment.py b/schemata/CIM14/IEC61968/WiresExt/DistributionLineSegment.py index 3eab36b..2bb9798 100644 --- a/schemata/CIM14/IEC61968/WiresExt/DistributionLineSegment.py +++ b/schemata/CIM14/IEC61968/WiresExt/DistributionLineSegment.py @@ -20,8 +20,8 @@ class DistributionLineSegment(ACLineSegment): """Extends ACLineSegment with references to a library of standard types from which electrical parameters can be calculated, as follows: - calculate electrical parameters from asset data, using associated ConductorInfo, with values then multiplied by Conductor.length to produce a matrix model. - calculate unbalanced electrical parameters from associated PerLengthPhaseImpedance, then multiplied by Conductor.length to produce a matrix model. - calculate transposed electrical parameters from associated PerLengthSequenceImpedance, then multiplied by Conductor.length to produce a sequence model. For symmetrical, transposed 3ph lines, it is sufficient to use inherited ACLineSegment attributes, which describe sequence impedances and admittances for the entire length of the segment. Known issue: Attributes expressing impedances and admittances in PerLengthSequenceImpedance and PhaseImpedanceData use Resistance, etc., which describe pre-calculated, full length of segment, while we should have a longitudinal unit, per length. Taking 'r' as example, its 'unit'=Ohm, but the value is effectively in Ohm/m, so the value needs to be multiplied by Conductor.length. This is against the whole idea of unit data types and is semantically wrong, but base CIM does not have the required data types at this moment. Until the revision of unit modelling in CIM, applications need to deduce and locally handle appending '/m' for units and ensure they multiply the values by Conductor.length. """ - def __init__(self, ConductorInfo=None, PhaseImpedance=None, SequenceImpedance=None, **kw_args): - """Initializes a new 'DistributionLineSegment' instance. + def __init__(self, ConductorInfo=None, PhaseImpedance=None, SequenceImpedance=None, *args, **kw_args): + """Initialises a new 'DistributionLineSegment' instance. @param ConductorInfo: Conductor data of this conductor segment. @param PhaseImpedance: Phase impedance of this conductor segment; used for unbalanced model. @@ -36,7 +36,14 @@ class DistributionLineSegment(ACLineSegment): self._SequenceImpedance = None self.SequenceImpedance = SequenceImpedance - super(DistributionLineSegment, self).__init__(**kw_args) + super(DistributionLineSegment, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ConductorInfo", "PhaseImpedance", "SequenceImpedance"] + _many_refs = [] def getConductorInfo(self): """Conductor data of this conductor segment. diff --git a/schemata/CIM14/IEC61968/WiresExt/DistributionTapChanger.py b/schemata/CIM14/IEC61968/WiresExt/DistributionTapChanger.py index ea7e0f0..6bf3bde 100644 --- a/schemata/CIM14/IEC61968/WiresExt/DistributionTapChanger.py +++ b/schemata/CIM14/IEC61968/WiresExt/DistributionTapChanger.py @@ -20,8 +20,8 @@ class DistributionTapChanger(RatioTapChanger): """Additional ratio tap changer parameters common to distribution line regulators. 'tculControlMode' would always be 'volt'. If 'monitoredPhase' is not specified, then if the controlled DistributionTransformerWinding is single-phase, the PT primary is assumed to be connected across that winding, which is the normal case. If the controlled winding is three-phase, then the 'monitoredPhase' is assumed to be 'AN', unless otherwise specified. Whenever 'ctRatio' and 'ptRatio' are specified, it's customary to specify the R and X in 'volts' referred to the PT secondary circuit, otherwise R and X are in feeder primary ohms. If 'ptRatio' is not specified, then 'targetVoltage', 'limitVoltage', and 'bandVoltage' are on the feeder primary base, phase-neutral or phase-phase depending on the 'monitoredPhase'. Otherwise, these attributes are all on the PT secondary base. """ - def __init__(self, monitoredPhase='A', ptRatio=0.0, reverseLineDropX=0.0, ctRating=0.0, reverseLineDropR=0.0, lineDropCompensation=False, ctRatio=0.0, targetVoltage=0.0, limitVoltage=0.0, lineDropR=0.0, lineDropX=0.0, bandVoltage=0.0, **kw_args): - """Initializes a new 'DistributionTapChanger' instance. + def __init__(self, monitoredPhase="A", ptRatio=0.0, reverseLineDropX=0.0, ctRating=0.0, reverseLineDropR=0.0, lineDropCompensation=False, ctRatio=0.0, targetVoltage=0.0, limitVoltage=0.0, lineDropR=0.0, lineDropX=0.0, bandVoltage=0.0, *args, **kw_args): + """Initialises a new 'DistributionTapChanger' instance. @param monitoredPhase: Phase voltage controlling this regulator, measured at regulator location. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" @param ptRatio: Built-in voltage transducer ratio. @@ -36,7 +36,7 @@ class DistributionTapChanger(RatioTapChanger): @param lineDropX: Line drop compensator reactance setting for normal (forward) power flow. @param bandVoltage: Voltage range (max - min) on the PT secondary base, centered on 'targetVoltage'. """ - #: Phase voltage controlling this regulator, measured at regulator location.Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" + #: Phase voltage controlling this regulator, measured at regulator location. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" self.monitoredPhase = monitoredPhase #: Built-in voltage transducer ratio. @@ -72,5 +72,12 @@ class DistributionTapChanger(RatioTapChanger): #: Voltage range (max - min) on the PT secondary base, centered on 'targetVoltage'. self.bandVoltage = bandVoltage - super(DistributionTapChanger, self).__init__(**kw_args) + super(DistributionTapChanger, self).__init__(*args, **kw_args) + + _attrs = ["monitoredPhase", "ptRatio", "reverseLineDropX", "ctRating", "reverseLineDropR", "lineDropCompensation", "ctRatio", "targetVoltage", "limitVoltage", "lineDropR", "lineDropX", "bandVoltage"] + _attr_types = {"monitoredPhase": str, "ptRatio": float, "reverseLineDropX": float, "ctRating": float, "reverseLineDropR": float, "lineDropCompensation": bool, "ctRatio": float, "targetVoltage": float, "limitVoltage": float, "lineDropR": float, "lineDropX": float, "bandVoltage": float} + _defaults = {"monitoredPhase": "A", "ptRatio": 0.0, "reverseLineDropX": 0.0, "ctRating": 0.0, "reverseLineDropR": 0.0, "lineDropCompensation": False, "ctRatio": 0.0, "targetVoltage": 0.0, "limitVoltage": 0.0, "lineDropR": 0.0, "lineDropX": 0.0, "bandVoltage": 0.0} + _enums = {"monitoredPhase": "PhaseCode"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61968/WiresExt/DistributionTransformer.py b/schemata/CIM14/IEC61968/WiresExt/DistributionTransformer.py index 1b9eda9..ea8a2e6 100644 --- a/schemata/CIM14/IEC61968/WiresExt/DistributionTransformer.py +++ b/schemata/CIM14/IEC61968/WiresExt/DistributionTransformer.py @@ -20,8 +20,8 @@ class DistributionTransformer(Equipment): """An assembly of two or more coupled windings that transform electrical power between voltage levels. Supports both balanced and unbalanced winding connections. This class differs from Wires::PowerTransformer as follows: - it is part of a TransformerBank - it draws parameters exclusively from TransformerInfo and its associated classes. """ - def __init__(self, Windings=None, ServiceDeliveryPoints=None, TransformerBank=None, TransformerInfo=None, **kw_args): - """Initializes a new 'DistributionTransformer' instance. + def __init__(self, Windings=None, ServiceDeliveryPoints=None, TransformerBank=None, TransformerInfo=None, *args, **kw_args): + """Initialises a new 'DistributionTransformer' instance. @param Windings: All windings of this transformer. @param ServiceDeliveryPoints: All service delivery points supplied by this transformer. @@ -40,7 +40,14 @@ class DistributionTransformer(Equipment): self._TransformerInfo = None self.TransformerInfo = TransformerInfo - super(DistributionTransformer, self).__init__(**kw_args) + super(DistributionTransformer, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Windings", "ServiceDeliveryPoints", "TransformerBank", "TransformerInfo"] + _many_refs = ["Windings", "ServiceDeliveryPoints"] def getWindings(self): """All windings of this transformer. diff --git a/schemata/CIM14/IEC61968/WiresExt/DistributionTransformerWinding.py b/schemata/CIM14/IEC61968/WiresExt/DistributionTransformerWinding.py index d152733..1bcdfac 100644 --- a/schemata/CIM14/IEC61968/WiresExt/DistributionTransformerWinding.py +++ b/schemata/CIM14/IEC61968/WiresExt/DistributionTransformerWinding.py @@ -20,8 +20,8 @@ class DistributionTransformerWinding(ConductingEquipment): """Conducting connection point of a distribution / unbalanced transformer winding instance. This class differs from Wires::TransformerWinding as follows: - the eight Pi model attributes are moved into separate class, that can be optionally referred to from several winding instances. - the three grounding attributes can differ per winding instance, even for windings that use the same TransformerInfo, so they are kept on DistributionTransformerWinding. - 'windingType' attribute is replaced by 'sequenceNumber' attribute on WindingInfo class. - all the other attributes come from the WindingInfo (and its relationships). TransformerInfo is associated to the DistributionTransformer as referenceable data, so it can be defined once and referred to from instances, instead of being specified with each instance. """ - def __init__(self, grounded=False, xground=0.0, rground=0.0, Transformer=None, WindingInfo=None, RatioTapChanger=None, PiImpedance=None, PhaseTapChanger=None, **kw_args): - """Initializes a new 'DistributionTransformerWinding' instance. + def __init__(self, grounded=False, xground=0.0, rground=0.0, Transformer=None, WindingInfo=None, RatioTapChanger=None, PiImpedance=None, PhaseTapChanger=None, *args, **kw_args): + """Initialises a new 'DistributionTransformerWinding' instance. @param grounded: (for Yn and Zn connections) True if the neutral is solidly grounded. @param xground: (for Yn and Zn connections) Reactive part of neutral impedance where 'grounded' is true. @@ -56,7 +56,14 @@ class DistributionTransformerWinding(ConductingEquipment): self._PhaseTapChanger = None self.PhaseTapChanger = PhaseTapChanger - super(DistributionTransformerWinding, self).__init__(**kw_args) + super(DistributionTransformerWinding, self).__init__(*args, **kw_args) + + _attrs = ["grounded", "xground", "rground"] + _attr_types = {"grounded": bool, "xground": float, "rground": float} + _defaults = {"grounded": False, "xground": 0.0, "rground": 0.0} + _enums = {} + _refs = ["Transformer", "WindingInfo", "RatioTapChanger", "PiImpedance", "PhaseTapChanger"] + _many_refs = [] def getTransformer(self): """Transformer this winding belongs to. diff --git a/schemata/CIM14/IEC61968/WiresExt/PerLengthPhaseImpedance.py b/schemata/CIM14/IEC61968/WiresExt/PerLengthPhaseImpedance.py index 2501185..2c70253 100644 --- a/schemata/CIM14/IEC61968/WiresExt/PerLengthPhaseImpedance.py +++ b/schemata/CIM14/IEC61968/WiresExt/PerLengthPhaseImpedance.py @@ -20,8 +20,8 @@ class PerLengthPhaseImpedance(IdentifiedObject): """Impedance and admittance parameters per unit length for n-wire unbalanced lines, in matrix form. """ - def __init__(self, conductorCount=0, ConductorSegments=None, PhaseImpedanceData=None, **kw_args): - """Initializes a new 'PerLengthPhaseImpedance' instance. + def __init__(self, conductorCount=0, ConductorSegments=None, PhaseImpedanceData=None, *args, **kw_args): + """Initialises a new 'PerLengthPhaseImpedance' instance. @param conductorCount: Number of phase, neutral, and other wires retained. Constrains the number of matrix elements and the phase codes that can be used with this matrix. @param ConductorSegments: All conductor segments described by this phase impedance. @@ -36,7 +36,14 @@ class PerLengthPhaseImpedance(IdentifiedObject): self._PhaseImpedanceData = [] self.PhaseImpedanceData = [] if PhaseImpedanceData is None else PhaseImpedanceData - super(PerLengthPhaseImpedance, self).__init__(**kw_args) + super(PerLengthPhaseImpedance, self).__init__(*args, **kw_args) + + _attrs = ["conductorCount"] + _attr_types = {"conductorCount": int} + _defaults = {"conductorCount": 0} + _enums = {} + _refs = ["ConductorSegments", "PhaseImpedanceData"] + _many_refs = ["ConductorSegments", "PhaseImpedanceData"] def getConductorSegments(self): """All conductor segments described by this phase impedance. diff --git a/schemata/CIM14/IEC61968/WiresExt/PerLengthSequenceImpedance.py b/schemata/CIM14/IEC61968/WiresExt/PerLengthSequenceImpedance.py index 9988d15..b6e4a6d 100644 --- a/schemata/CIM14/IEC61968/WiresExt/PerLengthSequenceImpedance.py +++ b/schemata/CIM14/IEC61968/WiresExt/PerLengthSequenceImpedance.py @@ -20,8 +20,8 @@ class PerLengthSequenceImpedance(IdentifiedObject): """Sequence impedance and admittance parameters per unit length, for transposed lines of 1, 2, or 3 phases. For 1-phase lines, define x=x0=xself. For 2-phase lines, define x=xs-xm and x0=xs+xm. """ - def __init__(self, r0=0.0, r=0.0, b0ch=0.0, x0=0.0, gch=0.0, g0ch=0.0, bch=0.0, x=0.0, ConductorSegments=None, **kw_args): - """Initializes a new 'PerLengthSequenceImpedance' instance. + def __init__(self, r0=0.0, r=0.0, b0ch=0.0, x0=0.0, gch=0.0, g0ch=0.0, bch=0.0, x=0.0, ConductorSegments=None, *args, **kw_args): + """Initialises a new 'PerLengthSequenceImpedance' instance. @param r0: Zero sequence series resistance, per unit of length. @param r: Positive sequence series resistance, per unit of length. @@ -60,7 +60,14 @@ class PerLengthSequenceImpedance(IdentifiedObject): self._ConductorSegments = [] self.ConductorSegments = [] if ConductorSegments is None else ConductorSegments - super(PerLengthSequenceImpedance, self).__init__(**kw_args) + super(PerLengthSequenceImpedance, self).__init__(*args, **kw_args) + + _attrs = ["r0", "r", "b0ch", "x0", "gch", "g0ch", "bch", "x"] + _attr_types = {"r0": float, "r": float, "b0ch": float, "x0": float, "gch": float, "g0ch": float, "bch": float, "x": float} + _defaults = {"r0": 0.0, "r": 0.0, "b0ch": 0.0, "x0": 0.0, "gch": 0.0, "g0ch": 0.0, "bch": 0.0, "x": 0.0} + _enums = {} + _refs = ["ConductorSegments"] + _many_refs = ["ConductorSegments"] def getConductorSegments(self): """All conductor segments described by this sequence impedance. diff --git a/schemata/CIM14/IEC61968/WiresExt/PhaseImpedanceData.py b/schemata/CIM14/IEC61968/WiresExt/PhaseImpedanceData.py index 7b34e16..ba626b7 100644 --- a/schemata/CIM14/IEC61968/WiresExt/PhaseImpedanceData.py +++ b/schemata/CIM14/IEC61968/WiresExt/PhaseImpedanceData.py @@ -20,8 +20,8 @@ class PhaseImpedanceData(Element): """Triplet of resistance, reactance, and susceptance matrix element values. """ - def __init__(self, r=0.0, x=0.0, sequenceNumber=0, b=0.0, PhaseImpedance=None, **kw_args): - """Initializes a new 'PhaseImpedanceData' instance. + def __init__(self, r=0.0, x=0.0, sequenceNumber=0, b=0.0, PhaseImpedance=None, *args, **kw_args): + """Initialises a new 'PhaseImpedanceData' instance. @param r: Resistance matrix element value, per length of unit. @param x: Reactance matrix element value, per length of unit. @@ -44,7 +44,14 @@ class PhaseImpedanceData(Element): self._PhaseImpedance = None self.PhaseImpedance = PhaseImpedance - super(PhaseImpedanceData, self).__init__(**kw_args) + super(PhaseImpedanceData, self).__init__(*args, **kw_args) + + _attrs = ["r", "x", "sequenceNumber", "b"] + _attr_types = {"r": float, "x": float, "sequenceNumber": int, "b": float} + _defaults = {"r": 0.0, "x": 0.0, "sequenceNumber": 0, "b": 0.0} + _enums = {} + _refs = ["PhaseImpedance"] + _many_refs = [] def getPhaseImpedance(self): """Conductor phase impedance to which this data belongs. diff --git a/schemata/CIM14/IEC61968/WiresExt/TransformerBank.py b/schemata/CIM14/IEC61968/WiresExt/TransformerBank.py index 7e27c06..e0cbee8 100644 --- a/schemata/CIM14/IEC61968/WiresExt/TransformerBank.py +++ b/schemata/CIM14/IEC61968/WiresExt/TransformerBank.py @@ -20,8 +20,8 @@ class TransformerBank(Equipment): """An assembly of transformers that are connected together. For three-phase transformers, there would be one transformer per bank. For banks of single-phase transformers, there will be more than one transformer per bank, and they need not be identical. """ - def __init__(self, vectorGroup='', Transformers=None, **kw_args): - """Initializes a new 'TransformerBank' instance. + def __init__(self, vectorGroup='', Transformers=None, *args, **kw_args): + """Initialises a new 'TransformerBank' instance. @param vectorGroup: Vector group of the bank for protective relaying, e.g., Dyn1. For unbalanced transformers, this may not be simply determined from the constituent winding connections. @param Transformers: All transformers that belong to this bank. @@ -32,7 +32,14 @@ class TransformerBank(Equipment): self._Transformers = [] self.Transformers = [] if Transformers is None else Transformers - super(TransformerBank, self).__init__(**kw_args) + super(TransformerBank, self).__init__(*args, **kw_args) + + _attrs = ["vectorGroup"] + _attr_types = {"vectorGroup": str} + _defaults = {"vectorGroup": ''} + _enums = {} + _refs = ["Transformers"] + _many_refs = ["Transformers"] def getTransformers(self): """All transformers that belong to this bank. diff --git a/schemata/CIM14/IEC61968/WiresExt/WindingPiImpedance.py b/schemata/CIM14/IEC61968/WiresExt/WindingPiImpedance.py index a08a48a..32fe327 100644 --- a/schemata/CIM14/IEC61968/WiresExt/WindingPiImpedance.py +++ b/schemata/CIM14/IEC61968/WiresExt/WindingPiImpedance.py @@ -20,8 +20,8 @@ class WindingPiImpedance(IdentifiedObject): """Transformer Pi-model impedance that accurately reflects impedance for transformers with 2 or 3 windings. For transformers with 4 or more windings, you must use TransformerInfo. """ - def __init__(self, g=0.0, b=0.0, r=0.0, x0=0.0, x=0.0, r0=0.0, b0=0.0, g0=0.0, Windings=None, **kw_args): - """Initializes a new 'WindingPiImpedance' instance. + def __init__(self, g=0.0, b=0.0, r=0.0, x0=0.0, x=0.0, r0=0.0, b0=0.0, g0=0.0, Windings=None, *args, **kw_args): + """Initialises a new 'WindingPiImpedance' instance. @param g: Magnetizing branch conductance (G mag). @param b: Magnetizing branch susceptance (B mag). The value can be positive or negative. @@ -60,7 +60,14 @@ class WindingPiImpedance(IdentifiedObject): self._Windings = [] self.Windings = [] if Windings is None else Windings - super(WindingPiImpedance, self).__init__(**kw_args) + super(WindingPiImpedance, self).__init__(*args, **kw_args) + + _attrs = ["g", "b", "r", "x0", "x", "r0", "b0", "g0"] + _attr_types = {"g": float, "b": float, "r": float, "x0": float, "x": float, "r0": float, "b0": float, "g0": float} + _defaults = {"g": 0.0, "b": 0.0, "r": 0.0, "x0": 0.0, "x": 0.0, "r0": 0.0, "b0": 0.0, "g0": 0.0} + _enums = {} + _refs = ["Windings"] + _many_refs = ["Windings"] def getWindings(self): """All windings having this Pi impedance. diff --git a/schemata/CIM14/IEC61968/Work/Work.py b/schemata/CIM14/IEC61968/Work/Work.py index c5daac6..67e4341 100644 --- a/schemata/CIM14/IEC61968/Work/Work.py +++ b/schemata/CIM14/IEC61968/Work/Work.py @@ -20,15 +20,15 @@ class Work(Document): """Document used to request, initiate, track and record work. This is synonymous with Work Breakdown Structure (WBS), which is traversed through the (currently informative) recursive association of Work. Note that the work name is equal to the WBS name, which is given in the inherited 'name' attribute. """ - def __init__(self, kind='construction', priority='', requestDateTime='', Customers=None, **kw_args): - """Initializes a new 'Work' instance. + def __init__(self, kind="construction", priority='', requestDateTime='', Customers=None, *args, **kw_args): + """Initialises a new 'Work' instance. @param kind: Kind of work. Values are: "construction", "maintenance", "reconnect", "meter", "service", "disconnect", "inspection", "other" @param priority: Priority of work. @param requestDateTime: Date and time work was requested. @param Customers: All the customers for which this work is performed. """ - #: Kind of work.Values are: "construction", "maintenance", "reconnect", "meter", "service", "disconnect", "inspection", "other" + #: Kind of work. Values are: "construction", "maintenance", "reconnect", "meter", "service", "disconnect", "inspection", "other" self.kind = kind #: Priority of work. @@ -40,7 +40,14 @@ class Work(Document): self._Customers = [] self.Customers = [] if Customers is None else Customers - super(Work, self).__init__(**kw_args) + super(Work, self).__init__(*args, **kw_args) + + _attrs = ["kind", "priority", "requestDateTime"] + _attr_types = {"kind": str, "priority": str, "requestDateTime": str} + _defaults = {"kind": "construction", "priority": '', "requestDateTime": ''} + _enums = {"kind": "WorkKind"} + _refs = ["Customers"] + _many_refs = ["Customers"] def getCustomers(self): """All the customers for which this work is performed. diff --git a/schemata/CIM14/IEC61970/Contingency/Contingency.py b/schemata/CIM14/IEC61970/Contingency/Contingency.py index 2e43942..4b3b65c 100644 --- a/schemata/CIM14/IEC61970/Contingency/Contingency.py +++ b/schemata/CIM14/IEC61970/Contingency/Contingency.py @@ -20,8 +20,8 @@ class Contingency(IdentifiedObject): """An event threatening system reliability, consisting of one or more contingency elements. """ - def __init__(self, mustStudy=False, ContingencyElement=None, **kw_args): - """Initializes a new 'Contingency' instance. + def __init__(self, mustStudy=False, ContingencyElement=None, *args, **kw_args): + """Initialises a new 'Contingency' instance. @param mustStudy: Set true if must study this contingency. @param ContingencyElement: A contingency can have any number of contingency elements. @@ -32,7 +32,14 @@ class Contingency(IdentifiedObject): self._ContingencyElement = [] self.ContingencyElement = [] if ContingencyElement is None else ContingencyElement - super(Contingency, self).__init__(**kw_args) + super(Contingency, self).__init__(*args, **kw_args) + + _attrs = ["mustStudy"] + _attr_types = {"mustStudy": bool} + _defaults = {"mustStudy": False} + _enums = {} + _refs = ["ContingencyElement"] + _many_refs = ["ContingencyElement"] def getContingencyElement(self): """A contingency can have any number of contingency elements. diff --git a/schemata/CIM14/IEC61970/Contingency/ContingencyElement.py b/schemata/CIM14/IEC61970/Contingency/ContingencyElement.py index 367a3b0..da23728 100644 --- a/schemata/CIM14/IEC61970/Contingency/ContingencyElement.py +++ b/schemata/CIM14/IEC61970/Contingency/ContingencyElement.py @@ -20,15 +20,22 @@ class ContingencyElement(IdentifiedObject): """An element of a system event to be studied by contingency analysis, representing a change in status of a single piece of equipment. """ - def __init__(self, Contingency=None, **kw_args): - """Initializes a new 'ContingencyElement' instance. + def __init__(self, Contingency=None, *args, **kw_args): + """Initialises a new 'ContingencyElement' instance. @param Contingency: A contingency element belongs to one contingency. """ self._Contingency = None self.Contingency = Contingency - super(ContingencyElement, self).__init__(**kw_args) + super(ContingencyElement, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Contingency"] + _many_refs = [] def getContingency(self): """A contingency element belongs to one contingency. diff --git a/schemata/CIM14/IEC61970/Contingency/ContingencyEquipment.py b/schemata/CIM14/IEC61970/Contingency/ContingencyEquipment.py index ae534a3..2626ad3 100644 --- a/schemata/CIM14/IEC61970/Contingency/ContingencyEquipment.py +++ b/schemata/CIM14/IEC61970/Contingency/ContingencyEquipment.py @@ -20,19 +20,26 @@ class ContingencyEquipment(ContingencyElement): """A equipment to which the in service status is to change such as a power transformer or AC line segment. """ - def __init__(self, contingentStatus='outOfService', Equipment=None, **kw_args): - """Initializes a new 'ContingencyEquipment' instance. + def __init__(self, contingentStatus="outOfService", Equipment=None, *args, **kw_args): + """Initialises a new 'ContingencyEquipment' instance. @param contingentStatus: The status for the associated equipment when in the contingency state. This status is independent of the case to which the contingency is originally applied, but defines the equipment status when the contingency is applied. Values are: "outOfService", "inService" @param Equipment: The single piece of equipment to which to apply the contingency. """ - #: The status for the associated equipment when in the contingency state. This status is independent of the case to which the contingency is originally applied, but defines the equipment status when the contingency is applied.Values are: "outOfService", "inService" + #: The status for the associated equipment when in the contingency state. This status is independent of the case to which the contingency is originally applied, but defines the equipment status when the contingency is applied. Values are: "outOfService", "inService" self.contingentStatus = contingentStatus self._Equipment = None self.Equipment = Equipment - super(ContingencyEquipment, self).__init__(**kw_args) + super(ContingencyEquipment, self).__init__(*args, **kw_args) + + _attrs = ["contingentStatus"] + _attr_types = {"contingentStatus": str} + _defaults = {"contingentStatus": "outOfService"} + _enums = {"contingentStatus": "ContingencyEquipmentStatusKind"} + _refs = ["Equipment"] + _many_refs = [] def getEquipment(self): """The single piece of equipment to which to apply the contingency. diff --git a/schemata/CIM14/IEC61970/ControlArea/AltGeneratingUnitMeas.py b/schemata/CIM14/IEC61970/ControlArea/AltGeneratingUnitMeas.py index 88c8907..67b3283 100644 --- a/schemata/CIM14/IEC61970/ControlArea/AltGeneratingUnitMeas.py +++ b/schemata/CIM14/IEC61970/ControlArea/AltGeneratingUnitMeas.py @@ -20,8 +20,8 @@ class AltGeneratingUnitMeas(Element): """A prioritized measurement to be used for the generating unit in the control area specificaiton. """ - def __init__(self, priority=0, ControlAreaGeneratingUnit=None, AnalogValue=None, **kw_args): - """Initializes a new 'AltGeneratingUnitMeas' instance. + def __init__(self, priority=0, ControlAreaGeneratingUnit=None, AnalogValue=None, *args, **kw_args): + """Initialises a new 'AltGeneratingUnitMeas' instance. @param priority: Priority of a measurement usage. Lower numbers have first priority. @param ControlAreaGeneratingUnit: The control aread generating unit to which the prioritized measurement assignment is applied. @@ -36,7 +36,14 @@ class AltGeneratingUnitMeas(Element): self._AnalogValue = None self.AnalogValue = AnalogValue - super(AltGeneratingUnitMeas, self).__init__(**kw_args) + super(AltGeneratingUnitMeas, self).__init__(*args, **kw_args) + + _attrs = ["priority"] + _attr_types = {"priority": int} + _defaults = {"priority": 0} + _enums = {} + _refs = ["ControlAreaGeneratingUnit", "AnalogValue"] + _many_refs = [] def getControlAreaGeneratingUnit(self): """The control aread generating unit to which the prioritized measurement assignment is applied. diff --git a/schemata/CIM14/IEC61970/ControlArea/AltTieMeas.py b/schemata/CIM14/IEC61970/ControlArea/AltTieMeas.py index e05c04c..a6516df 100644 --- a/schemata/CIM14/IEC61970/ControlArea/AltTieMeas.py +++ b/schemata/CIM14/IEC61970/ControlArea/AltTieMeas.py @@ -20,8 +20,8 @@ class AltTieMeas(Element): """A prioritized measurement to be used for the tie flow as part of the control area specification. """ - def __init__(self, priority=0, AnalogValue=None, TieFlow=None, **kw_args): - """Initializes a new 'AltTieMeas' instance. + def __init__(self, priority=0, AnalogValue=None, TieFlow=None, *args, **kw_args): + """Initialises a new 'AltTieMeas' instance. @param priority: Priority of a measurement usage. Lower numbers have first priority. @param AnalogValue: The specific analog value used as a source. @@ -36,7 +36,14 @@ class AltTieMeas(Element): self._TieFlow = None self.TieFlow = TieFlow - super(AltTieMeas, self).__init__(**kw_args) + super(AltTieMeas, self).__init__(*args, **kw_args) + + _attrs = ["priority"] + _attr_types = {"priority": int} + _defaults = {"priority": 0} + _enums = {} + _refs = ["AnalogValue", "TieFlow"] + _many_refs = [] def getAnalogValue(self): """The specific analog value used as a source. diff --git a/schemata/CIM14/IEC61970/ControlArea/ControlArea.py b/schemata/CIM14/IEC61970/ControlArea/ControlArea.py index 382333e..1372c0e 100644 --- a/schemata/CIM14/IEC61970/ControlArea/ControlArea.py +++ b/schemata/CIM14/IEC61970/ControlArea/ControlArea.py @@ -20,8 +20,8 @@ class ControlArea(PowerSystemResource): """A control area is a grouping of generating units and/or loads and a cutset of tie lines (as terminals) which may be used for a variety of purposes including automatic generation control, powerflow solution area interchange control specification, and input to load forecasting. Note that any number of overlapping control area specifications can be superimposed on the physical model. """ - def __init__(self, type='Interchange', netInterchange=0.0, pTolerance=0.0, TieFlow=None, EnergyArea=None, ControlAreaGeneratingUnit=None, **kw_args): - """Initializes a new 'ControlArea' instance. + def __init__(self, type="Interchange", netInterchange=0.0, pTolerance=0.0, TieFlow=None, EnergyArea=None, ControlAreaGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'ControlArea' instance. @param type: The type of control area defintion used to determine if this is used for automatic generation control, for planning interchange control, or other purposes. Values are: "Interchange", "Forecast", "AGC" @param netInterchange: The specified positive net interchange into the control area. @@ -30,7 +30,7 @@ class ControlArea(PowerSystemResource): @param EnergyArea: The energy area that is forecast from this control area specification. @param ControlAreaGeneratingUnit: The generating unit specificaitons for the control area. """ - #: The type of control area defintion used to determine if this is used for automatic generation control, for planning interchange control, or other purposes.Values are: "Interchange", "Forecast", "AGC" + #: The type of control area defintion used to determine if this is used for automatic generation control, for planning interchange control, or other purposes. Values are: "Interchange", "Forecast", "AGC" self.type = type #: The specified positive net interchange into the control area. @@ -48,7 +48,14 @@ class ControlArea(PowerSystemResource): self._ControlAreaGeneratingUnit = [] self.ControlAreaGeneratingUnit = [] if ControlAreaGeneratingUnit is None else ControlAreaGeneratingUnit - super(ControlArea, self).__init__(**kw_args) + super(ControlArea, self).__init__(*args, **kw_args) + + _attrs = ["type", "netInterchange", "pTolerance"] + _attr_types = {"type": str, "netInterchange": float, "pTolerance": float} + _defaults = {"type": "Interchange", "netInterchange": 0.0, "pTolerance": 0.0} + _enums = {"type": "ControlAreaTypeKind"} + _refs = ["TieFlow", "EnergyArea", "ControlAreaGeneratingUnit"] + _many_refs = ["TieFlow", "ControlAreaGeneratingUnit"] def getTieFlow(self): """The tie flows associated with the control area. diff --git a/schemata/CIM14/IEC61970/ControlArea/ControlAreaGeneratingUnit.py b/schemata/CIM14/IEC61970/ControlArea/ControlAreaGeneratingUnit.py index 2f9fce6..c01445f 100644 --- a/schemata/CIM14/IEC61970/ControlArea/ControlAreaGeneratingUnit.py +++ b/schemata/CIM14/IEC61970/ControlArea/ControlAreaGeneratingUnit.py @@ -20,8 +20,8 @@ class ControlAreaGeneratingUnit(Element): """A control area generating unit. This class is needed so that alternate control area definitions may include the same generating unit. Note only one instance within a control area should reference a specific generating unit. """ - def __init__(self, AltGeneratingUnitMeas=None, ControlArea=None, GeneratingUnit=None, **kw_args): - """Initializes a new 'ControlAreaGeneratingUnit' instance. + def __init__(self, AltGeneratingUnitMeas=None, ControlArea=None, GeneratingUnit=None, *args, **kw_args): + """Initialises a new 'ControlAreaGeneratingUnit' instance. @param AltGeneratingUnitMeas: The link to prioritized measurements for this GeneratingUnit. @param ControlArea: The parent control area for the generating unit specifications. @@ -36,7 +36,14 @@ class ControlAreaGeneratingUnit(Element): self._GeneratingUnit = None self.GeneratingUnit = GeneratingUnit - super(ControlAreaGeneratingUnit, self).__init__(**kw_args) + super(ControlAreaGeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["AltGeneratingUnitMeas", "ControlArea", "GeneratingUnit"] + _many_refs = ["AltGeneratingUnitMeas"] def getAltGeneratingUnitMeas(self): """The link to prioritized measurements for this GeneratingUnit. diff --git a/schemata/CIM14/IEC61970/ControlArea/TieFlow.py b/schemata/CIM14/IEC61970/ControlArea/TieFlow.py index 980a77d..de2409e 100644 --- a/schemata/CIM14/IEC61970/ControlArea/TieFlow.py +++ b/schemata/CIM14/IEC61970/ControlArea/TieFlow.py @@ -20,8 +20,8 @@ class TieFlow(Element): """A flow specification in terms of location and direction for a control area. """ - def __init__(self, positiveFlowIn=False, ControlArea=None, AltTieMeas=None, Terminal=None, **kw_args): - """Initializes a new 'TieFlow' instance. + def __init__(self, positiveFlowIn=False, ControlArea=None, AltTieMeas=None, Terminal=None, *args, **kw_args): + """Initialises a new 'TieFlow' instance. @param positiveFlowIn: The flow is positive into the terminal. A flow is positive if it is an import into the control area. @param ControlArea: The control area of the tie flows. @@ -40,7 +40,14 @@ class TieFlow(Element): self._Terminal = None self.Terminal = Terminal - super(TieFlow, self).__init__(**kw_args) + super(TieFlow, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn"] + _attr_types = {"positiveFlowIn": bool} + _defaults = {"positiveFlowIn": False} + _enums = {} + _refs = ["ControlArea", "AltTieMeas", "Terminal"] + _many_refs = ["AltTieMeas"] def getControlArea(self): """The control area of the tie flows. diff --git a/schemata/CIM14/IEC61970/Core/BasePower.py b/schemata/CIM14/IEC61970/Core/BasePower.py index 2de599e..b2802dc 100644 --- a/schemata/CIM14/IEC61970/Core/BasePower.py +++ b/schemata/CIM14/IEC61970/Core/BasePower.py @@ -20,13 +20,20 @@ class BasePower(IdentifiedObject): """The BasePower class defines the base power used in the per unit calculations. """ - def __init__(self, basePower=0.0, **kw_args): - """Initializes a new 'BasePower' instance. + def __init__(self, basePower=0.0, *args, **kw_args): + """Initialises a new 'BasePower' instance. @param basePower: Definition of base power. """ #: Definition of base power. self.basePower = basePower - super(BasePower, self).__init__(**kw_args) + super(BasePower, self).__init__(*args, **kw_args) + + _attrs = ["basePower"] + _attr_types = {"basePower": float} + _defaults = {"basePower": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Core/BaseVoltage.py b/schemata/CIM14/IEC61970/Core/BaseVoltage.py index 270b32a..24d6ac9 100644 --- a/schemata/CIM14/IEC61970/Core/BaseVoltage.py +++ b/schemata/CIM14/IEC61970/Core/BaseVoltage.py @@ -20,8 +20,8 @@ class BaseVoltage(IdentifiedObject): """Defines a nominal base voltage which is referenced in the system. """ - def __init__(self, nominalVoltage=0.0, isDC=False, ConductingEquipment=None, VoltageLevel=None, TopologicalNode=None, **kw_args): - """Initializes a new 'BaseVoltage' instance. + def __init__(self, nominalVoltage=0.0, isDC=False, ConductingEquipment=None, VoltageLevel=None, TopologicalNode=None, *args, **kw_args): + """Initialises a new 'BaseVoltage' instance. @param nominalVoltage: The PowerSystemResource's base voltage. @param isDC: If true, this is a direct current base voltage and items assigned to this base voltage are also associated with a direct current capabilities. False indicates alternating current. @@ -44,7 +44,14 @@ class BaseVoltage(IdentifiedObject): self._TopologicalNode = [] self.TopologicalNode = [] if TopologicalNode is None else TopologicalNode - super(BaseVoltage, self).__init__(**kw_args) + super(BaseVoltage, self).__init__(*args, **kw_args) + + _attrs = ["nominalVoltage", "isDC"] + _attr_types = {"nominalVoltage": float, "isDC": bool} + _defaults = {"nominalVoltage": 0.0, "isDC": False} + _enums = {} + _refs = ["ConductingEquipment", "VoltageLevel", "TopologicalNode"] + _many_refs = ["ConductingEquipment", "VoltageLevel", "TopologicalNode"] def getConductingEquipment(self): """Use association to ConductingEquipment only when there is no VoltageLevel container used. diff --git a/schemata/CIM14/IEC61970/Core/BasicIntervalSchedule.py b/schemata/CIM14/IEC61970/Core/BasicIntervalSchedule.py index 482e75d..f6da6e2 100644 --- a/schemata/CIM14/IEC61970/Core/BasicIntervalSchedule.py +++ b/schemata/CIM14/IEC61970/Core/BasicIntervalSchedule.py @@ -20,8 +20,8 @@ class BasicIntervalSchedule(IdentifiedObject): """Schedule of values at points in time. """ - def __init__(self, value2Multiplier='k', value2Unit='N', value1Multiplier='k', value1Unit='N', startTime='', **kw_args): - """Initializes a new 'BasicIntervalSchedule' instance. + def __init__(self, value2Multiplier="k", value2Unit="N", value1Multiplier="k", value1Unit="N", startTime='', *args, **kw_args): + """Initialises a new 'BasicIntervalSchedule' instance. @param value2Multiplier: Multiplier for value2. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" @param value2Unit: Value2 units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" @@ -29,20 +29,27 @@ class BasicIntervalSchedule(IdentifiedObject): @param value1Unit: Value1 units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" @param startTime: The time for the first time point. """ - #: Multiplier for value2.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for value2. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.value2Multiplier = value2Multiplier - #: Value2 units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: Value2 units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.value2Unit = value2Unit - #: Multiplier for value1.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for value1. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.value1Multiplier = value1Multiplier - #: Value1 units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: Value1 units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.value1Unit = value1Unit #: The time for the first time point. self.startTime = startTime - super(BasicIntervalSchedule, self).__init__(**kw_args) + super(BasicIntervalSchedule, self).__init__(*args, **kw_args) + + _attrs = ["value2Multiplier", "value2Unit", "value1Multiplier", "value1Unit", "startTime"] + _attr_types = {"value2Multiplier": str, "value2Unit": str, "value1Multiplier": str, "value1Unit": str, "startTime": str} + _defaults = {"value2Multiplier": "k", "value2Unit": "N", "value1Multiplier": "k", "value1Unit": "N", "startTime": ''} + _enums = {"value2Multiplier": "UnitMultiplier", "value2Unit": "UnitSymbol", "value1Multiplier": "UnitMultiplier", "value1Unit": "UnitSymbol"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Core/Bay.py b/schemata/CIM14/IEC61970/Core/Bay.py index 9497d19..d02d9cf 100644 --- a/schemata/CIM14/IEC61970/Core/Bay.py +++ b/schemata/CIM14/IEC61970/Core/Bay.py @@ -20,8 +20,8 @@ class Bay(EquipmentContainer): """A collection of power system resources (within a given substation) including conducting equipment, protection relays, measurements, and telemetry. """ - def __init__(self, busBarConfiguration='mainWithTransfer', breakerConfiguration='breakerAndAHalf', bayPowerMeasFlag=False, bayEnergyMeasFlag=False, Substation=None, VoltageLevel=None, **kw_args): - """Initializes a new 'Bay' instance. + def __init__(self, busBarConfiguration="mainWithTransfer", breakerConfiguration="breakerAndAHalf", bayPowerMeasFlag=False, bayEnergyMeasFlag=False, Substation=None, VoltageLevel=None, *args, **kw_args): + """Initialises a new 'Bay' instance. @param busBarConfiguration: Bus bar configuration. Values are: "mainWithTransfer", "ringBus", "singleBus", "doubleBus" @param breakerConfiguration: Breaker configuration. Values are: "breakerAndAHalf", "singleBreaker", "noBreaker", "doubleBreaker" @@ -30,10 +30,10 @@ class Bay(EquipmentContainer): @param Substation: The association is used in the naming hierarchy. @param VoltageLevel: The association is used in the naming hierarchy. """ - #: Bus bar configuration.Values are: "mainWithTransfer", "ringBus", "singleBus", "doubleBus" + #: Bus bar configuration. Values are: "mainWithTransfer", "ringBus", "singleBus", "doubleBus" self.busBarConfiguration = busBarConfiguration - #: Breaker configuration.Values are: "breakerAndAHalf", "singleBreaker", "noBreaker", "doubleBreaker" + #: Breaker configuration. Values are: "breakerAndAHalf", "singleBreaker", "noBreaker", "doubleBreaker" self.breakerConfiguration = breakerConfiguration #: Indicates the presence/absence of active/reactive power measurements. @@ -48,7 +48,14 @@ class Bay(EquipmentContainer): self._VoltageLevel = None self.VoltageLevel = VoltageLevel - super(Bay, self).__init__(**kw_args) + super(Bay, self).__init__(*args, **kw_args) + + _attrs = ["busBarConfiguration", "breakerConfiguration", "bayPowerMeasFlag", "bayEnergyMeasFlag"] + _attr_types = {"busBarConfiguration": str, "breakerConfiguration": str, "bayPowerMeasFlag": bool, "bayEnergyMeasFlag": bool} + _defaults = {"busBarConfiguration": "mainWithTransfer", "breakerConfiguration": "breakerAndAHalf", "bayPowerMeasFlag": False, "bayEnergyMeasFlag": False} + _enums = {"busBarConfiguration": "BusbarConfiguration", "breakerConfiguration": "BreakerConfiguration"} + _refs = ["Substation", "VoltageLevel"] + _many_refs = [] def getSubstation(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Core/ConductingEquipment.py b/schemata/CIM14/IEC61970/Core/ConductingEquipment.py index b4509e9..25e7e6b 100644 --- a/schemata/CIM14/IEC61970/Core/ConductingEquipment.py +++ b/schemata/CIM14/IEC61970/Core/ConductingEquipment.py @@ -20,8 +20,8 @@ class ConductingEquipment(Equipment): """The parts of the power system that are designed to carry current or that are conductively connected therewith. ConductingEquipment is contained within an EquipmentContainer that may be a Substation, or a VoltageLevel or a Bay within a Substation. """ - def __init__(self, phases='A', ClearanceTags=None, SvStatus=None, Terminals=None, BaseVoltage=None, ProtectionEquipments=None, **kw_args): - """Initializes a new 'ConductingEquipment' instance. + def __init__(self, phases="A", ClearanceTags=None, SvStatus=None, Terminals=None, BaseVoltage=None, ProtectionEquipments=None, *args, **kw_args): + """Initialises a new 'ConductingEquipment' instance. @param phases: Describes the phases carried by a conducting equipment. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" @param ClearanceTags: Conducting equipment may have multiple clearance tags for authorized field work @@ -30,7 +30,7 @@ class ConductingEquipment(Equipment): @param BaseVoltage: Use association to ConductingEquipment only when there is no VoltageLevel container used. @param ProtectionEquipments: Protection equipment may be used to protect specific Conducting Equipment. Multiple equipment may be protected or monitored by multiple protection equipment. """ - #: Describes the phases carried by a conducting equipment.Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" + #: Describes the phases carried by a conducting equipment. Values are: "A", "AC", "AN", "ABCN", "B", "C", "BN", "CN", "splitSecondary12N", "ABC", "splitSecondary2N", "N", "ABN", "BC", "BCN", "AB", "splitSecondary1N", "ACN" self.phases = phases self._ClearanceTags = [] @@ -48,7 +48,14 @@ class ConductingEquipment(Equipment): self._ProtectionEquipments = [] self.ProtectionEquipments = [] if ProtectionEquipments is None else ProtectionEquipments - super(ConductingEquipment, self).__init__(**kw_args) + super(ConductingEquipment, self).__init__(*args, **kw_args) + + _attrs = ["phases"] + _attr_types = {"phases": str} + _defaults = {"phases": "A"} + _enums = {"phases": "PhaseCode"} + _refs = ["ClearanceTags", "SvStatus", "Terminals", "BaseVoltage", "ProtectionEquipments"] + _many_refs = ["ClearanceTags", "Terminals", "ProtectionEquipments"] def getClearanceTags(self): """Conducting equipment may have multiple clearance tags for authorized field work diff --git a/schemata/CIM14/IEC61970/Core/ConnectivityNode.py b/schemata/CIM14/IEC61970/Core/ConnectivityNode.py index 34de45d..75dd2d4 100644 --- a/schemata/CIM14/IEC61970/Core/ConnectivityNode.py +++ b/schemata/CIM14/IEC61970/Core/ConnectivityNode.py @@ -20,8 +20,8 @@ class ConnectivityNode(IdentifiedObject): """Connectivity nodes are points where terminals of conducting equipment are connected together with zero impedance. """ - def __init__(self, TopologicalNode=None, BusNameMarker=None, ConnectivityNodeContainer=None, Terminals=None, **kw_args): - """Initializes a new 'ConnectivityNode' instance. + def __init__(self, TopologicalNode=None, BusNameMarker=None, ConnectivityNodeContainer=None, Terminals=None, *args, **kw_args): + """Initialises a new 'ConnectivityNode' instance. @param TopologicalNode: Several ConnectivityNode(s) may combine together to form a single TopologicalNode, depending on the current state of the network. @param BusNameMarker: The associated name of the bus (TopologicalNode) containing the ConnectivityNode is derived by an algorithm that uses the bus name marker. @@ -40,7 +40,14 @@ class ConnectivityNode(IdentifiedObject): self._Terminals = [] self.Terminals = [] if Terminals is None else Terminals - super(ConnectivityNode, self).__init__(**kw_args) + super(ConnectivityNode, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["TopologicalNode", "BusNameMarker", "ConnectivityNodeContainer", "Terminals"] + _many_refs = ["Terminals"] def getTopologicalNode(self): """Several ConnectivityNode(s) may combine together to form a single TopologicalNode, depending on the current state of the network. diff --git a/schemata/CIM14/IEC61970/Core/ConnectivityNodeContainer.py b/schemata/CIM14/IEC61970/Core/ConnectivityNodeContainer.py index 23a367a..f6a4a04 100644 --- a/schemata/CIM14/IEC61970/Core/ConnectivityNodeContainer.py +++ b/schemata/CIM14/IEC61970/Core/ConnectivityNodeContainer.py @@ -20,8 +20,8 @@ class ConnectivityNodeContainer(PowerSystemResource): """A base class for all objects that may contain ConnectivityNodes or TopologicalNodes. """ - def __init__(self, ConnectivityNodes=None, TopologicalNode=None, **kw_args): - """Initializes a new 'ConnectivityNodeContainer' instance. + def __init__(self, ConnectivityNodes=None, TopologicalNode=None, *args, **kw_args): + """Initialises a new 'ConnectivityNodeContainer' instance. @param ConnectivityNodes: Connectivity nodes contained by this container. @param TopologicalNode: The topological nodes which belong to this connectivity node container. @@ -32,7 +32,14 @@ class ConnectivityNodeContainer(PowerSystemResource): self._TopologicalNode = [] self.TopologicalNode = [] if TopologicalNode is None else TopologicalNode - super(ConnectivityNodeContainer, self).__init__(**kw_args) + super(ConnectivityNodeContainer, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ConnectivityNodes", "TopologicalNode"] + _many_refs = ["ConnectivityNodes", "TopologicalNode"] def getConnectivityNodes(self): """Connectivity nodes contained by this container. diff --git a/schemata/CIM14/IEC61970/Core/Curve.py b/schemata/CIM14/IEC61970/Core/Curve.py index 9801d44..7d1cac9 100644 --- a/schemata/CIM14/IEC61970/Core/Curve.py +++ b/schemata/CIM14/IEC61970/Core/Curve.py @@ -20,8 +20,8 @@ class Curve(IdentifiedObject): """A multi-purpose curve or functional relationship between an independent variable (X-axis) and dependent (Y-axis) variables. """ - def __init__(self, y2Multiplier='k', y3Multiplier='k', y1Unit='N', xMultiplier='k', y3Unit='N', xUnit='N', y1Multiplier='k', curveStyle='rampYValue', y2Unit='N', CurveDatas=None, **kw_args): - """Initializes a new 'Curve' instance. + def __init__(self, y2Multiplier="k", y3Multiplier="k", y1Unit="N", xMultiplier="k", y3Unit="N", xUnit="N", y1Multiplier="k", curveStyle="rampYValue", y2Unit="N", CurveDatas=None, *args, **kw_args): + """Initialises a new 'Curve' instance. @param y2Multiplier: Multiplier for Y2-axis. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" @param y3Multiplier: Multiplier for Y3-axis. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" @@ -34,37 +34,44 @@ class Curve(IdentifiedObject): @param y2Unit: The Y2-axis units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" @param CurveDatas: The point data values that define a curve """ - #: Multiplier for Y2-axis.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for Y2-axis. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.y2Multiplier = y2Multiplier - #: Multiplier for Y3-axis.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for Y3-axis. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.y3Multiplier = y3Multiplier - #: The Y1-axis units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: The Y1-axis units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.y1Unit = y1Unit - #: Multiplier for X-axis.Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for X-axis. Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.xMultiplier = xMultiplier - #: The Y3-axis units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: The Y3-axis units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.y3Unit = y3Unit - #: The X-axis units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: The X-axis units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.xUnit = xUnit - #: Multiplier for Y1-axisValues are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" + #: Multiplier for Y1-axis Values are: "k", "d", "n", "M", "none", "G", "micro", "T", "c", "m", "p" self.y1Multiplier = y1Multiplier - #: The style or shape of the curve.Values are: "rampYValue", "straightLineYValues", "formula", "constantYValue" + #: The style or shape of the curve. Values are: "rampYValue", "straightLineYValues", "formula", "constantYValue" self.curveStyle = curveStyle - #: The Y2-axis units of measure.Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" + #: The Y2-axis units of measure. Values are: "N", "VArh", "VA", "none", "m3", "kg/J", "deg", "W/Hz", "g", "Wh", "W/s", "Pa", "V/VAr", "ohm", "h", "F", "H", "m2", "VAr", "A", "rad", "s", "S", "VAh", "Hz", "oC", "s-1", "min", "J", "Hz-1", "J/s", "m", "W", "V" self.y2Unit = y2Unit self._CurveDatas = [] self.CurveDatas = [] if CurveDatas is None else CurveDatas - super(Curve, self).__init__(**kw_args) + super(Curve, self).__init__(*args, **kw_args) + + _attrs = ["y2Multiplier", "y3Multiplier", "y1Unit", "xMultiplier", "y3Unit", "xUnit", "y1Multiplier", "curveStyle", "y2Unit"] + _attr_types = {"y2Multiplier": str, "y3Multiplier": str, "y1Unit": str, "xMultiplier": str, "y3Unit": str, "xUnit": str, "y1Multiplier": str, "curveStyle": str, "y2Unit": str} + _defaults = {"y2Multiplier": "k", "y3Multiplier": "k", "y1Unit": "N", "xMultiplier": "k", "y3Unit": "N", "xUnit": "N", "y1Multiplier": "k", "curveStyle": "rampYValue", "y2Unit": "N"} + _enums = {"y2Multiplier": "UnitMultiplier", "y3Multiplier": "UnitMultiplier", "y1Unit": "UnitSymbol", "xMultiplier": "UnitMultiplier", "y3Unit": "UnitSymbol", "xUnit": "UnitSymbol", "y1Multiplier": "UnitMultiplier", "curveStyle": "CurveStyle", "y2Unit": "UnitSymbol"} + _refs = ["CurveDatas"] + _many_refs = ["CurveDatas"] def getCurveDatas(self): """The point data values that define a curve diff --git a/schemata/CIM14/IEC61970/Core/CurveData.py b/schemata/CIM14/IEC61970/Core/CurveData.py index 6d7f498..b075a22 100644 --- a/schemata/CIM14/IEC61970/Core/CurveData.py +++ b/schemata/CIM14/IEC61970/Core/CurveData.py @@ -20,8 +20,8 @@ class CurveData(Element): """Multi-purpose data points for defining a curve. """ - def __init__(self, y3value=0.0, xvalue=0.0, y2value=0.0, y1value=0.0, Curve=None, **kw_args): - """Initializes a new 'CurveData' instance. + def __init__(self, y3value=0.0, xvalue=0.0, y2value=0.0, y1value=0.0, Curve=None, *args, **kw_args): + """Initialises a new 'CurveData' instance. @param y3value: The data value of the third Y-axis variable (if present), depending on the Y-axis units @param xvalue: The data value of the X-axis variable, depending on the X-axis units @@ -44,7 +44,14 @@ class CurveData(Element): self._Curve = None self.Curve = Curve - super(CurveData, self).__init__(**kw_args) + super(CurveData, self).__init__(*args, **kw_args) + + _attrs = ["y3value", "xvalue", "y2value", "y1value"] + _attr_types = {"y3value": float, "xvalue": float, "y2value": float, "y1value": float} + _defaults = {"y3value": 0.0, "xvalue": 0.0, "y2value": 0.0, "y1value": 0.0} + _enums = {} + _refs = ["Curve"] + _many_refs = [] def getCurve(self): """The Curve defined by this CurveData. diff --git a/schemata/CIM14/IEC61970/Core/Equipment.py b/schemata/CIM14/IEC61970/Core/Equipment.py index 8646f62..3cc41a7 100644 --- a/schemata/CIM14/IEC61970/Core/Equipment.py +++ b/schemata/CIM14/IEC61970/Core/Equipment.py @@ -20,8 +20,8 @@ class Equipment(PowerSystemResource): """The parts of a power system that are physical devices, electronic or mechanical """ - def __init__(self, normaIlyInService=False, aggregate=False, OperationalLimitSet=None, ContingencyEquipment=None, EquipmentContainer=None, CustomerAgreements=None, **kw_args): - """Initializes a new 'Equipment' instance. + def __init__(self, normaIlyInService=False, aggregate=False, OperationalLimitSet=None, ContingencyEquipment=None, EquipmentContainer=None, CustomerAgreements=None, *args, **kw_args): + """Initialises a new 'Equipment' instance. @param normaIlyInService: The equipment is normally in service. @param aggregate: The single instance of equipment represents multiple pieces of equipment that have been modeled together as an aggregate. Examples would be PowerTransformers or SychronousMachines operating in parallel modeled as a single aggregate PowerTransformer or aggregate SynchronousMachine. This is not to be used to indicate equipment that is part of a group of interdependent equipment produced by a network production program. @@ -48,7 +48,14 @@ class Equipment(PowerSystemResource): self._CustomerAgreements = [] self.CustomerAgreements = [] if CustomerAgreements is None else CustomerAgreements - super(Equipment, self).__init__(**kw_args) + super(Equipment, self).__init__(*args, **kw_args) + + _attrs = ["normaIlyInService", "aggregate"] + _attr_types = {"normaIlyInService": bool, "aggregate": bool} + _defaults = {"normaIlyInService": False, "aggregate": False} + _enums = {} + _refs = ["OperationalLimitSet", "ContingencyEquipment", "EquipmentContainer", "CustomerAgreements"] + _many_refs = ["OperationalLimitSet", "ContingencyEquipment", "CustomerAgreements"] def getOperationalLimitSet(self): """The equipment limit sets associated with the equipment. diff --git a/schemata/CIM14/IEC61970/Core/EquipmentContainer.py b/schemata/CIM14/IEC61970/Core/EquipmentContainer.py index 8487106..daeaae8 100644 --- a/schemata/CIM14/IEC61970/Core/EquipmentContainer.py +++ b/schemata/CIM14/IEC61970/Core/EquipmentContainer.py @@ -20,15 +20,22 @@ class EquipmentContainer(ConnectivityNodeContainer): """A modeling construct to provide a root class for containing equipment. """ - def __init__(self, Equipments=None, **kw_args): - """Initializes a new 'EquipmentContainer' instance. + def __init__(self, Equipments=None, *args, **kw_args): + """Initialises a new 'EquipmentContainer' instance. @param Equipments: The association is used in the naming hierarchy. """ self._Equipments = [] self.Equipments = [] if Equipments is None else Equipments - super(EquipmentContainer, self).__init__(**kw_args) + super(EquipmentContainer, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Equipments"] + _many_refs = ["Equipments"] def getEquipments(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Core/GeographicalRegion.py b/schemata/CIM14/IEC61970/Core/GeographicalRegion.py index 45d3877..0662684 100644 --- a/schemata/CIM14/IEC61970/Core/GeographicalRegion.py +++ b/schemata/CIM14/IEC61970/Core/GeographicalRegion.py @@ -20,15 +20,22 @@ class GeographicalRegion(IdentifiedObject): """A geographical region of a power system network model. """ - def __init__(self, Regions=None, **kw_args): - """Initializes a new 'GeographicalRegion' instance. + def __init__(self, Regions=None, *args, **kw_args): + """Initialises a new 'GeographicalRegion' instance. @param Regions: The association is used in the naming hierarchy. """ self._Regions = [] self.Regions = [] if Regions is None else Regions - super(GeographicalRegion, self).__init__(**kw_args) + super(GeographicalRegion, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Regions"] + _many_refs = ["Regions"] def getRegions(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Core/IdentifiedObject.py b/schemata/CIM14/IEC61970/Core/IdentifiedObject.py index 6eb47e9..543dc6d 100644 --- a/schemata/CIM14/IEC61970/Core/IdentifiedObject.py +++ b/schemata/CIM14/IEC61970/Core/IdentifiedObject.py @@ -20,8 +20,8 @@ class IdentifiedObject(Element): """This is a root class to provide common naming attributes for all classes needing naming attributes """ - def __init__(self, pathName='', aliasName='', mRID='', name='', description='', localName='', ModelingAuthoritySet=None, **kw_args): - """Initializes a new 'IdentifiedObject' instance. + def __init__(self, pathName='', aliasName='', mRID='', name='', description='', localName='', ModelingAuthoritySet=None, *args, **kw_args): + """Initialises a new 'IdentifiedObject' instance. @param pathName: The pathname is a system unique name composed from all IdentifiedObject.localNames in a naming hierarchy path from the object to the root. @param aliasName: The aliasName is free text human readable name of the object alternative to IdentifiedObject.name. It may be non unique and may not correlate to a naming hierarchy. @@ -52,7 +52,14 @@ class IdentifiedObject(Element): self._ModelingAuthoritySet = None self.ModelingAuthoritySet = ModelingAuthoritySet - super(IdentifiedObject, self).__init__(**kw_args) + super(IdentifiedObject, self).__init__(*args, **kw_args) + + _attrs = ["pathName", "aliasName", "mRID", "name", "description", "localName"] + _attr_types = {"pathName": str, "aliasName": str, "mRID": str, "name": str, "description": str, "localName": str} + _defaults = {"pathName": '', "aliasName": '', "mRID": '', "name": '', "description": '', "localName": ''} + _enums = {} + _refs = ["ModelingAuthoritySet"] + _many_refs = [] def getModelingAuthoritySet(self): """An IdentifiedObject belongs to a Modeling Authority Set for purposes of defining a group of data maintained by the same Modeling Authority. diff --git a/schemata/CIM14/IEC61970/Core/IrregularIntervalSchedule.py b/schemata/CIM14/IEC61970/Core/IrregularIntervalSchedule.py index fdfaa48..f7253b2 100644 --- a/schemata/CIM14/IEC61970/Core/IrregularIntervalSchedule.py +++ b/schemata/CIM14/IEC61970/Core/IrregularIntervalSchedule.py @@ -20,15 +20,22 @@ class IrregularIntervalSchedule(BasicIntervalSchedule): """The schedule has TimePoints where the time between them varies. """ - def __init__(self, TimePoints=None, **kw_args): - """Initializes a new 'IrregularIntervalSchedule' instance. + def __init__(self, TimePoints=None, *args, **kw_args): + """Initialises a new 'IrregularIntervalSchedule' instance. @param TimePoints: The point data values that define a curve """ self._TimePoints = [] self.TimePoints = [] if TimePoints is None else TimePoints - super(IrregularIntervalSchedule, self).__init__(**kw_args) + super(IrregularIntervalSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["TimePoints"] + _many_refs = ["TimePoints"] def getTimePoints(self): """The point data values that define a curve diff --git a/schemata/CIM14/IEC61970/Core/IrregularTimePoint.py b/schemata/CIM14/IEC61970/Core/IrregularTimePoint.py index 2b0acdb..b9355ae 100644 --- a/schemata/CIM14/IEC61970/Core/IrregularTimePoint.py +++ b/schemata/CIM14/IEC61970/Core/IrregularTimePoint.py @@ -20,8 +20,8 @@ class IrregularTimePoint(Element): """TimePoints for a schedule where the time between the points varies. """ - def __init__(self, time=0.0, value2=0.0, value1=0.0, IntervalSchedule=None, **kw_args): - """Initializes a new 'IrregularTimePoint' instance. + def __init__(self, time=0.0, value2=0.0, value1=0.0, IntervalSchedule=None, *args, **kw_args): + """Initialises a new 'IrregularTimePoint' instance. @param time: The time is relative the BasicTimeSchedule.startTime. @param value2: The second value at the time. The meaning of the value is defined by the class inhering the IrregularIntervalSchedule. @@ -40,7 +40,14 @@ class IrregularTimePoint(Element): self._IntervalSchedule = None self.IntervalSchedule = IntervalSchedule - super(IrregularTimePoint, self).__init__(**kw_args) + super(IrregularTimePoint, self).__init__(*args, **kw_args) + + _attrs = ["time", "value2", "value1"] + _attr_types = {"time": float, "value2": float, "value1": float} + _defaults = {"time": 0.0, "value2": 0.0, "value1": 0.0} + _enums = {} + _refs = ["IntervalSchedule"] + _many_refs = [] def getIntervalSchedule(self): """An IrregularTimePoint belongs to an IrregularIntervalSchedule. diff --git a/schemata/CIM14/IEC61970/Core/OperatingParticipant.py b/schemata/CIM14/IEC61970/Core/OperatingParticipant.py index 93d8465..79dfa05 100644 --- a/schemata/CIM14/IEC61970/Core/OperatingParticipant.py +++ b/schemata/CIM14/IEC61970/Core/OperatingParticipant.py @@ -20,15 +20,22 @@ class OperatingParticipant(IdentifiedObject): """An operator of multiple PowerSystemResource objects. Note multple OperatingParticipants may operate the same PowerSystemResource object. This can be used for modeling jointly owned units where each owner operates as a contractual share. """ - def __init__(self, OperatingShare=None, **kw_args): - """Initializes a new 'OperatingParticipant' instance. + def __init__(self, OperatingShare=None, *args, **kw_args): + """Initialises a new 'OperatingParticipant' instance. @param OperatingShare: The operating shares of an operating participant. An operating participant can be reused for any number of PSR's. """ self._OperatingShare = [] self.OperatingShare = [] if OperatingShare is None else OperatingShare - super(OperatingParticipant, self).__init__(**kw_args) + super(OperatingParticipant, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["OperatingShare"] + _many_refs = ["OperatingShare"] def getOperatingShare(self): """The operating shares of an operating participant. An operating participant can be reused for any number of PSR's. diff --git a/schemata/CIM14/IEC61970/Core/OperatingShare.py b/schemata/CIM14/IEC61970/Core/OperatingShare.py index 7246ca5..8634d35 100644 --- a/schemata/CIM14/IEC61970/Core/OperatingShare.py +++ b/schemata/CIM14/IEC61970/Core/OperatingShare.py @@ -20,8 +20,8 @@ class OperatingShare(Element): """Specifies the contract relationship between a PowerSystemResource and a contract participant. """ - def __init__(self, percentage=0.0, PowerSystemResource=None, OperatingParticipant=None, **kw_args): - """Initializes a new 'OperatingShare' instance. + def __init__(self, percentage=0.0, PowerSystemResource=None, OperatingParticipant=None, *args, **kw_args): + """Initialises a new 'OperatingShare' instance. @param percentage: Percentage ownership for this device. The percentage indicates the percentage ownership of the PSROwner for the PowerSystemResource. The total percentage ownership for a PowerSystemResource should add to 100%. @param PowerSystemResource: The PowerSystemResource to which the attribues apply. The percentage ownership of all owners of a PowerSystemResource should add to 100%. @@ -36,7 +36,14 @@ class OperatingShare(Element): self._OperatingParticipant = None self.OperatingParticipant = OperatingParticipant - super(OperatingShare, self).__init__(**kw_args) + super(OperatingShare, self).__init__(*args, **kw_args) + + _attrs = ["percentage"] + _attr_types = {"percentage": float} + _defaults = {"percentage": 0.0} + _enums = {} + _refs = ["PowerSystemResource", "OperatingParticipant"] + _many_refs = [] def getPowerSystemResource(self): """The PowerSystemResource to which the attribues apply. The percentage ownership of all owners of a PowerSystemResource should add to 100%. diff --git a/schemata/CIM14/IEC61970/Core/PSRType.py b/schemata/CIM14/IEC61970/Core/PSRType.py index 657d247..c71cc13 100644 --- a/schemata/CIM14/IEC61970/Core/PSRType.py +++ b/schemata/CIM14/IEC61970/Core/PSRType.py @@ -20,15 +20,22 @@ class PSRType(IdentifiedObject): """Classifying instances of the same class, e.g. overhead and underground ACLineSegments. This classification mechanism is intended to provide flexibility outside the scope of this standard, i.e. provide customisation that is non standard. """ - def __init__(self, PowerSystemResources=None, **kw_args): - """Initializes a new 'PSRType' instance. + def __init__(self, PowerSystemResources=None, *args, **kw_args): + """Initialises a new 'PSRType' instance. @param PowerSystemResources: Power system resources classified with this PSRType. """ self._PowerSystemResources = [] self.PowerSystemResources = [] if PowerSystemResources is None else PowerSystemResources - super(PSRType, self).__init__(**kw_args) + super(PSRType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["PowerSystemResources"] + _many_refs = ["PowerSystemResources"] def getPowerSystemResources(self): """Power system resources classified with this PSRType. diff --git a/schemata/CIM14/IEC61970/Core/PowerSystemResource.py b/schemata/CIM14/IEC61970/Core/PowerSystemResource.py index 93ce4a6..5197737 100644 --- a/schemata/CIM14/IEC61970/Core/PowerSystemResource.py +++ b/schemata/CIM14/IEC61970/Core/PowerSystemResource.py @@ -20,8 +20,8 @@ class PowerSystemResource(IdentifiedObject): """A power system resource can be an item of equipment such as a Switch, an EquipmentContainer containing many individual items of equipment such as a Substation, or an organisational entity such as Company or SubControlArea. This provides for the nesting of collections of PowerSystemResources within other PowerSystemResources. For example, a Switch could be a member of a Substation and a Substation could be a member of a division of a Company. """ - def __init__(self, Location=None, Assets=None, PsrLists=None, Measurements=None, OperatingShare=None, OutageSchedule=None, ReportingGroup=None, Block=None, PSRType=None, **kw_args): - """Initializes a new 'PowerSystemResource' instance. + def __init__(self, Location=None, Assets=None, PsrLists=None, Measurements=None, OperatingShare=None, OutageSchedule=None, ReportingGroup=None, Block=None, PSRType=None, *args, **kw_args): + """Initialises a new 'PowerSystemResource' instance. @param Location: Location of this power system resource. @param Assets: All assets represented by this power system resource. For example, multiple conductor assets are electrically modelled as a single AC line segment. @@ -60,7 +60,14 @@ class PowerSystemResource(IdentifiedObject): self._PSRType = None self.PSRType = PSRType - super(PowerSystemResource, self).__init__(**kw_args) + super(PowerSystemResource, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Location", "Assets", "PsrLists", "Measurements", "OperatingShare", "OutageSchedule", "ReportingGroup", "Block", "PSRType"] + _many_refs = ["Assets", "PsrLists", "Measurements", "OperatingShare", "ReportingGroup", "Block"] def getLocation(self): """Location of this power system resource. diff --git a/schemata/CIM14/IEC61970/Core/PsrList.py b/schemata/CIM14/IEC61970/Core/PsrList.py index 2ef47de..2b2d7f0 100644 --- a/schemata/CIM14/IEC61970/Core/PsrList.py +++ b/schemata/CIM14/IEC61970/Core/PsrList.py @@ -20,8 +20,8 @@ class PsrList(IdentifiedObject): """Arbitrary list of PowerSystemResources. Can be used for various purposes, including grouping for report generation. """ - def __init__(self, typePSRList='', PowerSystemResources=None, **kw_args): - """Initializes a new 'PsrList' instance. + def __init__(self, typePSRList='', PowerSystemResources=None, *args, **kw_args): + """Initialises a new 'PsrList' instance. @param typePSRList: Type of power system resources in this list. @param PowerSystemResources: @@ -32,7 +32,14 @@ class PsrList(IdentifiedObject): self._PowerSystemResources = [] self.PowerSystemResources = [] if PowerSystemResources is None else PowerSystemResources - super(PsrList, self).__init__(**kw_args) + super(PsrList, self).__init__(*args, **kw_args) + + _attrs = ["typePSRList"] + _attr_types = {"typePSRList": str} + _defaults = {"typePSRList": ''} + _enums = {} + _refs = ["PowerSystemResources"] + _many_refs = ["PowerSystemResources"] def getPowerSystemResources(self): diff --git a/schemata/CIM14/IEC61970/Core/RegularIntervalSchedule.py b/schemata/CIM14/IEC61970/Core/RegularIntervalSchedule.py index c01507e..4d67ec2 100644 --- a/schemata/CIM14/IEC61970/Core/RegularIntervalSchedule.py +++ b/schemata/CIM14/IEC61970/Core/RegularIntervalSchedule.py @@ -20,8 +20,8 @@ class RegularIntervalSchedule(BasicIntervalSchedule): """The schedule has TimePoints where the time between them is constant. """ - def __init__(self, endTime='', timeStep=0.0, TimePoints=None, **kw_args): - """Initializes a new 'RegularIntervalSchedule' instance. + def __init__(self, endTime='', timeStep=0.0, TimePoints=None, *args, **kw_args): + """Initialises a new 'RegularIntervalSchedule' instance. @param endTime: The time for the last time point. @param timeStep: The time between each pair of subsequent RegularTimePoints. @@ -36,7 +36,14 @@ class RegularIntervalSchedule(BasicIntervalSchedule): self._TimePoints = [] self.TimePoints = [] if TimePoints is None else TimePoints - super(RegularIntervalSchedule, self).__init__(**kw_args) + super(RegularIntervalSchedule, self).__init__(*args, **kw_args) + + _attrs = ["endTime", "timeStep"] + _attr_types = {"endTime": str, "timeStep": float} + _defaults = {"endTime": '', "timeStep": 0.0} + _enums = {} + _refs = ["TimePoints"] + _many_refs = ["TimePoints"] def getTimePoints(self): """The point data values that define a curve diff --git a/schemata/CIM14/IEC61970/Core/RegularTimePoint.py b/schemata/CIM14/IEC61970/Core/RegularTimePoint.py index 4c599ab..74de31d 100644 --- a/schemata/CIM14/IEC61970/Core/RegularTimePoint.py +++ b/schemata/CIM14/IEC61970/Core/RegularTimePoint.py @@ -20,8 +20,8 @@ class RegularTimePoint(Element): """TimePoints for a schedule where the time between the points is constant. """ - def __init__(self, value1=0.0, sequenceNumber=0, value2=0.0, IntervalSchedule=None, **kw_args): - """Initializes a new 'RegularTimePoint' instance. + def __init__(self, value1=0.0, sequenceNumber=0, value2=0.0, IntervalSchedule=None, *args, **kw_args): + """Initialises a new 'RegularTimePoint' instance. @param value1: The first value at the time. The meaning of the value is defined by the class inhering the RegularIntervalSchedule. @param sequenceNumber: The position of the RegularTimePoint in the sequence. Note that time points don't have to be sequential, i.e. time points may be omitted. The actual time for a RegularTimePoint is computed by multiplying the RegularIntervalSchedule.timeStep with the RegularTimePoint.sequenceNumber and add the BasicIntervalSchedule.startTime. @@ -40,7 +40,14 @@ class RegularTimePoint(Element): self._IntervalSchedule = None self.IntervalSchedule = IntervalSchedule - super(RegularTimePoint, self).__init__(**kw_args) + super(RegularTimePoint, self).__init__(*args, **kw_args) + + _attrs = ["value1", "sequenceNumber", "value2"] + _attr_types = {"value1": float, "sequenceNumber": int, "value2": float} + _defaults = {"value1": 0.0, "sequenceNumber": 0, "value2": 0.0} + _enums = {} + _refs = ["IntervalSchedule"] + _many_refs = [] def getIntervalSchedule(self): """A RegularTimePoint belongs to a RegularIntervalSchedule. diff --git a/schemata/CIM14/IEC61970/Core/ReportingGroup.py b/schemata/CIM14/IEC61970/Core/ReportingGroup.py index 4f90969..c7de76b 100644 --- a/schemata/CIM14/IEC61970/Core/ReportingGroup.py +++ b/schemata/CIM14/IEC61970/Core/ReportingGroup.py @@ -20,8 +20,8 @@ class ReportingGroup(IdentifiedObject): """A reporting group is used for various ad-hoc groupings used for reporting. """ - def __init__(self, ReportingSuperGroup=None, TopologicalNode=None, BusNameMarker=None, PowerSystemResource=None, **kw_args): - """Initializes a new 'ReportingGroup' instance. + def __init__(self, ReportingSuperGroup=None, TopologicalNode=None, BusNameMarker=None, PowerSystemResource=None, *args, **kw_args): + """Initialises a new 'ReportingGroup' instance. @param ReportingSuperGroup: Reporting super group to which this reporting group belongs. @param TopologicalNode: The topological nodes that belong to the reporting group. @@ -40,7 +40,14 @@ class ReportingGroup(IdentifiedObject): self._PowerSystemResource = [] self.PowerSystemResource = [] if PowerSystemResource is None else PowerSystemResource - super(ReportingGroup, self).__init__(**kw_args) + super(ReportingGroup, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ReportingSuperGroup", "TopologicalNode", "BusNameMarker", "PowerSystemResource"] + _many_refs = ["TopologicalNode", "BusNameMarker", "PowerSystemResource"] def getReportingSuperGroup(self): """Reporting super group to which this reporting group belongs. diff --git a/schemata/CIM14/IEC61970/Core/ReportingSuperGroup.py b/schemata/CIM14/IEC61970/Core/ReportingSuperGroup.py index d2f204a..5ab7d10 100644 --- a/schemata/CIM14/IEC61970/Core/ReportingSuperGroup.py +++ b/schemata/CIM14/IEC61970/Core/ReportingSuperGroup.py @@ -20,15 +20,22 @@ class ReportingSuperGroup(IdentifiedObject): """A reporting super group, groups reporting groups for a higher level report. """ - def __init__(self, ReportingGroup=None, **kw_args): - """Initializes a new 'ReportingSuperGroup' instance. + def __init__(self, ReportingGroup=None, *args, **kw_args): + """Initialises a new 'ReportingSuperGroup' instance. @param ReportingGroup: Reporting groups that are grouped under this group group. """ self._ReportingGroup = [] self.ReportingGroup = [] if ReportingGroup is None else ReportingGroup - super(ReportingSuperGroup, self).__init__(**kw_args) + super(ReportingSuperGroup, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ReportingGroup"] + _many_refs = ["ReportingGroup"] def getReportingGroup(self): """Reporting groups that are grouped under this group group. diff --git a/schemata/CIM14/IEC61970/Core/SubGeographicalRegion.py b/schemata/CIM14/IEC61970/Core/SubGeographicalRegion.py index 565332e..2bb3cfa 100644 --- a/schemata/CIM14/IEC61970/Core/SubGeographicalRegion.py +++ b/schemata/CIM14/IEC61970/Core/SubGeographicalRegion.py @@ -20,8 +20,8 @@ class SubGeographicalRegion(IdentifiedObject): """A subset of a geographical region of a power system network model. """ - def __init__(self, Region=None, Substations=None, Lines=None, **kw_args): - """Initializes a new 'SubGeographicalRegion' instance. + def __init__(self, Region=None, Substations=None, Lines=None, *args, **kw_args): + """Initialises a new 'SubGeographicalRegion' instance. @param Region: The association is used in the naming hierarchy. @param Substations: The association is used in the naming hierarchy. @@ -36,7 +36,14 @@ class SubGeographicalRegion(IdentifiedObject): self._Lines = [] self.Lines = [] if Lines is None else Lines - super(SubGeographicalRegion, self).__init__(**kw_args) + super(SubGeographicalRegion, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Region", "Substations", "Lines"] + _many_refs = ["Substations", "Lines"] def getRegion(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Core/Substation.py b/schemata/CIM14/IEC61970/Core/Substation.py index 746d0ed..ca3f763 100644 --- a/schemata/CIM14/IEC61970/Core/Substation.py +++ b/schemata/CIM14/IEC61970/Core/Substation.py @@ -20,8 +20,8 @@ class Substation(EquipmentContainer): """A collection of equipment for purposes other than generation or utilization, through which electric energy in bulk is passed for the purposes of switching or modifying its characteristics. """ - def __init__(self, VoltageLevels=None, Bays=None, Region=None, **kw_args): - """Initializes a new 'Substation' instance. + def __init__(self, VoltageLevels=None, Bays=None, Region=None, *args, **kw_args): + """Initialises a new 'Substation' instance. @param VoltageLevels: The association is used in the naming hierarchy. @param Bays: The association is used in the naming hierarchy. @@ -36,7 +36,14 @@ class Substation(EquipmentContainer): self._Region = None self.Region = Region - super(Substation, self).__init__(**kw_args) + super(Substation, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["VoltageLevels", "Bays", "Region"] + _many_refs = ["VoltageLevels", "Bays"] def getVoltageLevels(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Core/Terminal.py b/schemata/CIM14/IEC61970/Core/Terminal.py index 6e39c7f..d6edfdc 100644 --- a/schemata/CIM14/IEC61970/Core/Terminal.py +++ b/schemata/CIM14/IEC61970/Core/Terminal.py @@ -20,8 +20,8 @@ class Terminal(IdentifiedObject): """An electrical connection point to a piece of conducting equipment. Terminals are connected at physical connection points called 'connectivity nodes'. """ - def __init__(self, connected=False, sequenceNumber=0, TopologicalNode=None, Block=None, OperationalLimitSet=None, HasSecond_MutualCoupling=None, RegulatingControl=None, Measurements=None, BranchGroupTerminal=None, ConductingEquipment=None, HasFirst_MutualCoupling=None, SvPowerFlow=None, ConnectivityNode=None, TieFlow=None, **kw_args): - """Initializes a new 'Terminal' instance. + def __init__(self, connected=False, sequenceNumber=0, TopologicalNode=None, Block=None, OperationalLimitSet=None, HasSecond_MutualCoupling=None, RegulatingControl=None, Measurements=None, BranchGroupTerminal=None, ConductingEquipment=None, HasFirst_MutualCoupling=None, SvPowerFlow=None, ConnectivityNode=None, TieFlow=None, *args, **kw_args): + """Initialises a new 'Terminal' instance. @param connected: The connected status is related to a bus-branch model and the TopologicalNode-Terminal relation. True implies the Terminal is connected to the related TopologicalNode and false implies it is not. In a bus-branch model the connected status is used to tell if equipment is disconnected without having to change the connectivity described by the TopologicalNode-Terminal relation. A valid case is that ConductingEquipment can be connected in one end and open in the other. In particular for an ACLineSegment where the charging can be significant this is a relevant case. @param sequenceNumber: The orientation of the terminal connections for a multiple terminal conducting equipment. The sequence numbering starts with 1 and additional terminals should follow in increasing order. The first terminal is the 'starting point' for a two terminal branch. In the case of class TransformerWinding only one terminal is used so its sequenceNumber must be 1. @@ -80,7 +80,14 @@ class Terminal(IdentifiedObject): self._TieFlow = [] self.TieFlow = [] if TieFlow is None else TieFlow - super(Terminal, self).__init__(**kw_args) + super(Terminal, self).__init__(*args, **kw_args) + + _attrs = ["connected", "sequenceNumber"] + _attr_types = {"connected": bool, "sequenceNumber": int} + _defaults = {"connected": False, "sequenceNumber": 0} + _enums = {} + _refs = ["TopologicalNode", "Block", "OperationalLimitSet", "HasSecond_MutualCoupling", "RegulatingControl", "Measurements", "BranchGroupTerminal", "ConductingEquipment", "HasFirst_MutualCoupling", "SvPowerFlow", "ConnectivityNode", "TieFlow"] + _many_refs = ["Block", "OperationalLimitSet", "HasSecond_MutualCoupling", "RegulatingControl", "Measurements", "BranchGroupTerminal", "HasFirst_MutualCoupling", "TieFlow"] def getTopologicalNode(self): """The topological node associated with the terminal. This can be used as an alternative to the connectivity node path to topological node, thus making it unneccesary to model connedtivity nodes in some cases. Note that the if connectivity nodes are in the model, this association would proably not be used. diff --git a/schemata/CIM14/IEC61970/Core/Unit.py b/schemata/CIM14/IEC61970/Core/Unit.py index 924b3e0..98b99ab 100644 --- a/schemata/CIM14/IEC61970/Core/Unit.py +++ b/schemata/CIM14/IEC61970/Core/Unit.py @@ -20,8 +20,8 @@ class Unit(IdentifiedObject): """Quantity being measured. The Unit.name shall be unique among all specified quantities and describe the quantity. The Unit.aliasName is meant to be used for localization. """ - def __init__(self, Controls=None, Measurements=None, MetaBlockConOutput=None, MetaBlockConInput=None, ProtectionEquipments=None, **kw_args): - """Initializes a new 'Unit' instance. + def __init__(self, Controls=None, Measurements=None, MetaBlockConOutput=None, MetaBlockConInput=None, ProtectionEquipments=None, *args, **kw_args): + """Initialises a new 'Unit' instance. @param Controls: The Controls having the Unit. @param Measurements: The Measurements having the Unit @@ -44,7 +44,14 @@ class Unit(IdentifiedObject): self._ProtectionEquipments = [] self.ProtectionEquipments = [] if ProtectionEquipments is None else ProtectionEquipments - super(Unit, self).__init__(**kw_args) + super(Unit, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Controls", "Measurements", "MetaBlockConOutput", "MetaBlockConInput", "ProtectionEquipments"] + _many_refs = ["Controls", "Measurements", "MetaBlockConOutput", "MetaBlockConInput", "ProtectionEquipments"] def getControls(self): """The Controls having the Unit. diff --git a/schemata/CIM14/IEC61970/Core/VoltageLevel.py b/schemata/CIM14/IEC61970/Core/VoltageLevel.py index 90dc270..e3be4bd 100644 --- a/schemata/CIM14/IEC61970/Core/VoltageLevel.py +++ b/schemata/CIM14/IEC61970/Core/VoltageLevel.py @@ -20,8 +20,8 @@ class VoltageLevel(EquipmentContainer): """A collection of equipment at one common system voltage forming a switchgear. The equipment typically consist of breakers, busbars, instrumentation, control, regulation and protection devices as well as assemblies of all these. """ - def __init__(self, highVoltageLimit=0.0, lowVoltageLimit=0.0, Substation=None, Bays=None, BaseVoltage=None, **kw_args): - """Initializes a new 'VoltageLevel' instance. + def __init__(self, highVoltageLimit=0.0, lowVoltageLimit=0.0, Substation=None, Bays=None, BaseVoltage=None, *args, **kw_args): + """Initialises a new 'VoltageLevel' instance. @param highVoltageLimit: The bus bar's high voltage limit @param lowVoltageLimit: The bus bar's low voltage limit @@ -44,7 +44,14 @@ class VoltageLevel(EquipmentContainer): self._BaseVoltage = None self.BaseVoltage = BaseVoltage - super(VoltageLevel, self).__init__(**kw_args) + super(VoltageLevel, self).__init__(*args, **kw_args) + + _attrs = ["highVoltageLimit", "lowVoltageLimit"] + _attr_types = {"highVoltageLimit": float, "lowVoltageLimit": float} + _defaults = {"highVoltageLimit": 0.0, "lowVoltageLimit": 0.0} + _enums = {} + _refs = ["Substation", "Bays", "BaseVoltage"] + _many_refs = ["Bays"] def getSubstation(self): """The association is used in the naming hierarchy. diff --git a/schemata/CIM14/IEC61970/Equivalents/EquivalentBranch.py b/schemata/CIM14/IEC61970/Equivalents/EquivalentBranch.py index e104acf..4cf250f 100644 --- a/schemata/CIM14/IEC61970/Equivalents/EquivalentBranch.py +++ b/schemata/CIM14/IEC61970/Equivalents/EquivalentBranch.py @@ -20,8 +20,8 @@ class EquivalentBranch(EquivalentEquipment): """The class represents equivalent branches. """ - def __init__(self, x=0.0, r=0.0, **kw_args): - """Initializes a new 'EquivalentBranch' instance. + def __init__(self, x=0.0, r=0.0, *args, **kw_args): + """Initialises a new 'EquivalentBranch' instance. @param x: Positive sequence series reactance of the reduced branch. @param r: Positive sequence series resistance of the reduced branch. @@ -32,5 +32,12 @@ class EquivalentBranch(EquivalentEquipment): #: Positive sequence series resistance of the reduced branch. self.r = r - super(EquivalentBranch, self).__init__(**kw_args) + super(EquivalentBranch, self).__init__(*args, **kw_args) + + _attrs = ["x", "r"] + _attr_types = {"x": float, "r": float} + _defaults = {"x": 0.0, "r": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Equivalents/EquivalentEquipment.py b/schemata/CIM14/IEC61970/Equivalents/EquivalentEquipment.py index e1bb2d4..c957a61 100644 --- a/schemata/CIM14/IEC61970/Equivalents/EquivalentEquipment.py +++ b/schemata/CIM14/IEC61970/Equivalents/EquivalentEquipment.py @@ -20,15 +20,22 @@ class EquivalentEquipment(ConductingEquipment): """The class represents equivalent objects that are the result of a network reduction. The class is the base for equivalent objects of different types. """ - def __init__(self, EquivalentNetwork=None, **kw_args): - """Initializes a new 'EquivalentEquipment' instance. + def __init__(self, EquivalentNetwork=None, *args, **kw_args): + """Initialises a new 'EquivalentEquipment' instance. @param EquivalentNetwork: The equivalent where the reduced model belongs. """ self._EquivalentNetwork = None self.EquivalentNetwork = EquivalentNetwork - super(EquivalentEquipment, self).__init__(**kw_args) + super(EquivalentEquipment, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["EquivalentNetwork"] + _many_refs = [] def getEquivalentNetwork(self): """The equivalent where the reduced model belongs. diff --git a/schemata/CIM14/IEC61970/Equivalents/EquivalentInjection.py b/schemata/CIM14/IEC61970/Equivalents/EquivalentInjection.py index 3575221..2404c2c 100644 --- a/schemata/CIM14/IEC61970/Equivalents/EquivalentInjection.py +++ b/schemata/CIM14/IEC61970/Equivalents/EquivalentInjection.py @@ -20,8 +20,8 @@ class EquivalentInjection(EquivalentEquipment): """This class represents equivalent injections (generation or load). Voltage regulation is allowed only at the local connectivity node. """ - def __init__(self, maxP=0.0, regulationCapability=False, regulationTarget=0.0, minP=0.0, regulationStatus=False, **kw_args): - """Initializes a new 'EquivalentInjection' instance. + def __init__(self, maxP=0.0, regulationCapability=False, regulationTarget=0.0, minP=0.0, regulationStatus=False, *args, **kw_args): + """Initialises a new 'EquivalentInjection' instance. @param maxP: Minimum active power of the injection. @param regulationCapability: Specifies whether or not the EquivalentInjection has the capability to regulate the local voltage. @@ -44,5 +44,12 @@ class EquivalentInjection(EquivalentEquipment): #: Specifies the default regulation status of the EquivalentInjection. True is regulating. False is not regulating. self.regulationStatus = regulationStatus - super(EquivalentInjection, self).__init__(**kw_args) + super(EquivalentInjection, self).__init__(*args, **kw_args) + + _attrs = ["maxP", "regulationCapability", "regulationTarget", "minP", "regulationStatus"] + _attr_types = {"maxP": float, "regulationCapability": bool, "regulationTarget": float, "minP": float, "regulationStatus": bool} + _defaults = {"maxP": 0.0, "regulationCapability": False, "regulationTarget": 0.0, "minP": 0.0, "regulationStatus": False} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Equivalents/EquivalentNetwork.py b/schemata/CIM14/IEC61970/Equivalents/EquivalentNetwork.py index 1828517..b8f68a1 100644 --- a/schemata/CIM14/IEC61970/Equivalents/EquivalentNetwork.py +++ b/schemata/CIM14/IEC61970/Equivalents/EquivalentNetwork.py @@ -20,15 +20,22 @@ class EquivalentNetwork(ConnectivityNodeContainer): """A class that represents an external meshed network that has been reduced to an electrically equivalent model. The ConnectivityNodes contained in the equivalent are intended to reflect internal nodes of the equivalent. The boundary Connectivity nodes where the equivalent connects outside itself are NOT contained by the equivalent. """ - def __init__(self, EquivalentEquipments=None, **kw_args): - """Initializes a new 'EquivalentNetwork' instance. + def __init__(self, EquivalentEquipments=None, *args, **kw_args): + """Initialises a new 'EquivalentNetwork' instance. @param EquivalentEquipments: The associated reduced equivalents. """ self._EquivalentEquipments = [] self.EquivalentEquipments = [] if EquivalentEquipments is None else EquivalentEquipments - super(EquivalentNetwork, self).__init__(**kw_args) + super(EquivalentNetwork, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["EquivalentEquipments"] + _many_refs = ["EquivalentEquipments"] def getEquivalentEquipments(self): """The associated reduced equivalents. diff --git a/schemata/CIM14/IEC61970/Equivalents/EquivalentShunt.py b/schemata/CIM14/IEC61970/Equivalents/EquivalentShunt.py index 7bc22e3..e36a416 100644 --- a/schemata/CIM14/IEC61970/Equivalents/EquivalentShunt.py +++ b/schemata/CIM14/IEC61970/Equivalents/EquivalentShunt.py @@ -20,8 +20,8 @@ class EquivalentShunt(EquivalentEquipment): """The class represents equivalent shunts. """ - def __init__(self, b=0.0, g=0.0, **kw_args): - """Initializes a new 'EquivalentShunt' instance. + def __init__(self, b=0.0, g=0.0, *args, **kw_args): + """Initialises a new 'EquivalentShunt' instance. @param b: Positive sequence shunt susceptance. @param g: Positive sequence shunt conductance. @@ -32,5 +32,12 @@ class EquivalentShunt(EquivalentEquipment): #: Positive sequence shunt conductance. self.g = g - super(EquivalentShunt, self).__init__(**kw_args) + super(EquivalentShunt, self).__init__(*args, **kw_args) + + _attrs = ["b", "g"] + _attr_types = {"b": float, "g": float} + _defaults = {"b": 0.0, "g": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/BWRSteamSupply.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/BWRSteamSupply.py index 0ae7d78..615b925 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/BWRSteamSupply.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/BWRSteamSupply.py @@ -20,8 +20,8 @@ class BWRSteamSupply(SteamSupply): """Boiling water reactor used as a steam supply to a steam turbine """ - def __init__(self, lowerLimit=0.0, pressureSetpointGA=0.0, rfAux8=0.0, rfAux3=0.0, rfAux2=0.0, highPowerLimit=0.0, rodPattern=0.0, rodPatternConstant=0.0, integralGain=0.0, rfAux7=0.0, proportionalGain=0.0, rfAux6=0.0, pressureSetpointTC2=0.0, rfAux1=0.0, pressureSetpointTC1=0.0, inCoreThermalTC=0.0, upperLimit=0.0, rfAux4=0.0, pressureLimit=0.0, rfAux5=0.0, lowPowerLimit=0.0, **kw_args): - """Initializes a new 'BWRSteamSupply' instance. + def __init__(self, lowerLimit=0.0, pressureSetpointGA=0.0, rfAux8=0.0, rfAux3=0.0, rfAux2=0.0, highPowerLimit=0.0, rodPattern=0.0, rodPatternConstant=0.0, integralGain=0.0, rfAux7=0.0, proportionalGain=0.0, rfAux6=0.0, pressureSetpointTC2=0.0, rfAux1=0.0, pressureSetpointTC1=0.0, inCoreThermalTC=0.0, upperLimit=0.0, rfAux4=0.0, pressureLimit=0.0, rfAux5=0.0, lowPowerLimit=0.0, *args, **kw_args): + """Initialises a new 'BWRSteamSupply' instance. @param lowerLimit: Initial Lower Limit @param pressureSetpointGA: Pressure Setpoint Gain Adjuster @@ -108,5 +108,12 @@ class BWRSteamSupply(SteamSupply): #: Low Power Limit self.lowPowerLimit = lowPowerLimit - super(BWRSteamSupply, self).__init__(**kw_args) + super(BWRSteamSupply, self).__init__(*args, **kw_args) + + _attrs = ["lowerLimit", "pressureSetpointGA", "rfAux8", "rfAux3", "rfAux2", "highPowerLimit", "rodPattern", "rodPatternConstant", "integralGain", "rfAux7", "proportionalGain", "rfAux6", "pressureSetpointTC2", "rfAux1", "pressureSetpointTC1", "inCoreThermalTC", "upperLimit", "rfAux4", "pressureLimit", "rfAux5", "lowPowerLimit"] + _attr_types = {"lowerLimit": float, "pressureSetpointGA": float, "rfAux8": float, "rfAux3": float, "rfAux2": float, "highPowerLimit": float, "rodPattern": float, "rodPatternConstant": float, "integralGain": float, "rfAux7": float, "proportionalGain": float, "rfAux6": float, "pressureSetpointTC2": float, "rfAux1": float, "pressureSetpointTC1": float, "inCoreThermalTC": float, "upperLimit": float, "rfAux4": float, "pressureLimit": float, "rfAux5": float, "lowPowerLimit": float} + _defaults = {"lowerLimit": 0.0, "pressureSetpointGA": 0.0, "rfAux8": 0.0, "rfAux3": 0.0, "rfAux2": 0.0, "highPowerLimit": 0.0, "rodPattern": 0.0, "rodPatternConstant": 0.0, "integralGain": 0.0, "rfAux7": 0.0, "proportionalGain": 0.0, "rfAux6": 0.0, "pressureSetpointTC2": 0.0, "rfAux1": 0.0, "pressureSetpointTC1": 0.0, "inCoreThermalTC": 0.0, "upperLimit": 0.0, "rfAux4": 0.0, "pressureLimit": 0.0, "rfAux5": 0.0, "lowPowerLimit": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CTTempActivePowerCurve.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CTTempActivePowerCurve.py index 7810ef0..5d6c43b 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CTTempActivePowerCurve.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CTTempActivePowerCurve.py @@ -20,15 +20,22 @@ class CTTempActivePowerCurve(Curve): """Relationship between the combustion turbine's power output rating in gross active power (X-axis) and the ambient air temperature (Y-axis) """ - def __init__(self, CombustionTurbine=None, **kw_args): - """Initializes a new 'CTTempActivePowerCurve' instance. + def __init__(self, CombustionTurbine=None, *args, **kw_args): + """Initialises a new 'CTTempActivePowerCurve' instance. @param CombustionTurbine: A combustion turbine may have an active power versus ambient temperature relationship """ self._CombustionTurbine = None self.CombustionTurbine = CombustionTurbine - super(CTTempActivePowerCurve, self).__init__(**kw_args) + super(CTTempActivePowerCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["CombustionTurbine"] + _many_refs = [] def getCombustionTurbine(self): """A combustion turbine may have an active power versus ambient temperature relationship diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CombustionTurbine.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CombustionTurbine.py index 0d0c8b1..095ef3e 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CombustionTurbine.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/CombustionTurbine.py @@ -20,8 +20,8 @@ class CombustionTurbine(PrimeMover): """A prime mover that is typically fueled by gas or light oil """ - def __init__(self, capabilityVersusFrequency=0.0, heatRecoveryFlag=False, timeConstant=0.0, auxPowerVersusFrequency=0.0, auxPowerVersusVoltage=0.0, referenceTemp=0.0, ambientTemp=0.0, powerVariationByTemp=0.0, HeatRecoveryBoiler=None, CTTempActivePowerCurve=None, AirCompressor=None, **kw_args): - """Initializes a new 'CombustionTurbine' instance. + def __init__(self, capabilityVersusFrequency=0.0, heatRecoveryFlag=False, timeConstant=0.0, auxPowerVersusFrequency=0.0, auxPowerVersusVoltage=0.0, referenceTemp=0.0, ambientTemp=0.0, powerVariationByTemp=0.0, HeatRecoveryBoiler=None, CTTempActivePowerCurve=None, AirCompressor=None, *args, **kw_args): + """Initialises a new 'CombustionTurbine' instance. @param capabilityVersusFrequency: Off-nominal frequency effect on turbine capability. Per unit reduction in unit active power capability versus per unit reduction in frequency (from rated frequency). @param heatRecoveryFlag: Flag that is set to true if the combustion turbine is associated with a heat recovery boiler @@ -68,7 +68,14 @@ class CombustionTurbine(PrimeMover): self._AirCompressor = None self.AirCompressor = AirCompressor - super(CombustionTurbine, self).__init__(**kw_args) + super(CombustionTurbine, self).__init__(*args, **kw_args) + + _attrs = ["capabilityVersusFrequency", "heatRecoveryFlag", "timeConstant", "auxPowerVersusFrequency", "auxPowerVersusVoltage", "referenceTemp", "ambientTemp", "powerVariationByTemp"] + _attr_types = {"capabilityVersusFrequency": float, "heatRecoveryFlag": bool, "timeConstant": float, "auxPowerVersusFrequency": float, "auxPowerVersusVoltage": float, "referenceTemp": float, "ambientTemp": float, "powerVariationByTemp": float} + _defaults = {"capabilityVersusFrequency": 0.0, "heatRecoveryFlag": False, "timeConstant": 0.0, "auxPowerVersusFrequency": 0.0, "auxPowerVersusVoltage": 0.0, "referenceTemp": 0.0, "ambientTemp": 0.0, "powerVariationByTemp": 0.0} + _enums = {} + _refs = ["HeatRecoveryBoiler", "CTTempActivePowerCurve", "AirCompressor"] + _many_refs = [] def getHeatRecoveryBoiler(self): """A combustion turbine may have a heat recovery boiler for making steam diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/DrumBoiler.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/DrumBoiler.py index e5e6d10..3c0423c 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/DrumBoiler.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/DrumBoiler.py @@ -20,13 +20,20 @@ class DrumBoiler(FossilSteamSupply): """Drum boiler """ - def __init__(self, drumBoilerRating=0.0, **kw_args): - """Initializes a new 'DrumBoiler' instance. + def __init__(self, drumBoilerRating=0.0, *args, **kw_args): + """Initialises a new 'DrumBoiler' instance. @param drumBoilerRating: Rating of drum boiler in steam units """ #: Rating of drum boiler in steam units self.drumBoilerRating = drumBoilerRating - super(DrumBoiler, self).__init__(**kw_args) + super(DrumBoiler, self).__init__(*args, **kw_args) + + _attrs = ["drumBoilerRating"] + _attr_types = {"drumBoilerRating": float} + _defaults = {"drumBoilerRating": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/FossilSteamSupply.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/FossilSteamSupply.py index e6c72d3..6ae2ad3 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/FossilSteamSupply.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/FossilSteamSupply.py @@ -20,8 +20,8 @@ class FossilSteamSupply(SteamSupply): """Fossil fueled boiler (e.g., coal, oil, gas) """ - def __init__(self, boilerControlMode='following', superHeater2Capacity=0.0, auxPowerVersusFrequency=0.0, feedWaterIG=0.0, controlPED=0.0, throttlePressureSP=0.0, pressureCtrlIG=0.0, fuelSupplyDelay=0.0, controlPEB=0.0, controlTC=0.0, pressureFeedback=0, feedWaterPG=0.0, controlIC=0.0, controlPC=0.0, minErrorRateP=0.0, fuelSupplyTC=0.0, fuelDemandLimit=0.0, mechPowerSensorLag=0.0, pressureCtrlDG=0.0, maxErrorRateP=0.0, superHeaterPipePD=0.0, controlErrorBiasP=0.0, feedWaterTC=0.0, superHeater1Capacity=0.0, auxPowerVersusVoltage=0.0, pressureCtrlPG=0.0, **kw_args): - """Initializes a new 'FossilSteamSupply' instance. + def __init__(self, boilerControlMode="following", superHeater2Capacity=0.0, auxPowerVersusFrequency=0.0, feedWaterIG=0.0, controlPED=0.0, throttlePressureSP=0.0, pressureCtrlIG=0.0, fuelSupplyDelay=0.0, controlPEB=0.0, controlTC=0.0, pressureFeedback=0, feedWaterPG=0.0, controlIC=0.0, controlPC=0.0, minErrorRateP=0.0, fuelSupplyTC=0.0, fuelDemandLimit=0.0, mechPowerSensorLag=0.0, pressureCtrlDG=0.0, maxErrorRateP=0.0, superHeaterPipePD=0.0, controlErrorBiasP=0.0, feedWaterTC=0.0, superHeater1Capacity=0.0, auxPowerVersusVoltage=0.0, pressureCtrlPG=0.0, *args, **kw_args): + """Initialises a new 'FossilSteamSupply' instance. @param boilerControlMode: The control mode of the boiler Values are: "following", "coordinated" @param superHeater2Capacity: Secondary Superheater Capacity @@ -50,7 +50,7 @@ class FossilSteamSupply(SteamSupply): @param auxPowerVersusVoltage: Off nominal voltage effect on auxiliary real power. Per unit active power variation versus per unit voltage variation. @param pressureCtrlPG: Pressure Control Proportional Gain ratio """ - #: The control mode of the boilerValues are: "following", "coordinated" + #: The control mode of the boiler Values are: "following", "coordinated" self.boilerControlMode = boilerControlMode #: Secondary Superheater Capacity @@ -128,5 +128,12 @@ class FossilSteamSupply(SteamSupply): #: Pressure Control Proportional Gain ratio self.pressureCtrlPG = pressureCtrlPG - super(FossilSteamSupply, self).__init__(**kw_args) + super(FossilSteamSupply, self).__init__(*args, **kw_args) + + _attrs = ["boilerControlMode", "superHeater2Capacity", "auxPowerVersusFrequency", "feedWaterIG", "controlPED", "throttlePressureSP", "pressureCtrlIG", "fuelSupplyDelay", "controlPEB", "controlTC", "pressureFeedback", "feedWaterPG", "controlIC", "controlPC", "minErrorRateP", "fuelSupplyTC", "fuelDemandLimit", "mechPowerSensorLag", "pressureCtrlDG", "maxErrorRateP", "superHeaterPipePD", "controlErrorBiasP", "feedWaterTC", "superHeater1Capacity", "auxPowerVersusVoltage", "pressureCtrlPG"] + _attr_types = {"boilerControlMode": str, "superHeater2Capacity": float, "auxPowerVersusFrequency": float, "feedWaterIG": float, "controlPED": float, "throttlePressureSP": float, "pressureCtrlIG": float, "fuelSupplyDelay": float, "controlPEB": float, "controlTC": float, "pressureFeedback": int, "feedWaterPG": float, "controlIC": float, "controlPC": float, "minErrorRateP": float, "fuelSupplyTC": float, "fuelDemandLimit": float, "mechPowerSensorLag": float, "pressureCtrlDG": float, "maxErrorRateP": float, "superHeaterPipePD": float, "controlErrorBiasP": float, "feedWaterTC": float, "superHeater1Capacity": float, "auxPowerVersusVoltage": float, "pressureCtrlPG": float} + _defaults = {"boilerControlMode": "following", "superHeater2Capacity": 0.0, "auxPowerVersusFrequency": 0.0, "feedWaterIG": 0.0, "controlPED": 0.0, "throttlePressureSP": 0.0, "pressureCtrlIG": 0.0, "fuelSupplyDelay": 0.0, "controlPEB": 0.0, "controlTC": 0.0, "pressureFeedback": 0, "feedWaterPG": 0.0, "controlIC": 0.0, "controlPC": 0.0, "minErrorRateP": 0.0, "fuelSupplyTC": 0.0, "fuelDemandLimit": 0.0, "mechPowerSensorLag": 0.0, "pressureCtrlDG": 0.0, "maxErrorRateP": 0.0, "superHeaterPipePD": 0.0, "controlErrorBiasP": 0.0, "feedWaterTC": 0.0, "superHeater1Capacity": 0.0, "auxPowerVersusVoltage": 0.0, "pressureCtrlPG": 0.0} + _enums = {"boilerControlMode": "BoilerControlMode"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HeatRecoveryBoiler.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HeatRecoveryBoiler.py index 32f65b7..4136ee4 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HeatRecoveryBoiler.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HeatRecoveryBoiler.py @@ -20,8 +20,8 @@ class HeatRecoveryBoiler(FossilSteamSupply): """The heat recovery system associated with combustion turbines in order to produce steam for combined cycle plants """ - def __init__(self, steamSupplyRating2=0.0, CombustionTurbines=None, **kw_args): - """Initializes a new 'HeatRecoveryBoiler' instance. + def __init__(self, steamSupplyRating2=0.0, CombustionTurbines=None, *args, **kw_args): + """Initialises a new 'HeatRecoveryBoiler' instance. @param steamSupplyRating2: The steam supply rating in kilopounds per hour, if dual pressure boiler @param CombustionTurbines: A combustion turbine may have a heat recovery boiler for making steam @@ -32,7 +32,14 @@ class HeatRecoveryBoiler(FossilSteamSupply): self._CombustionTurbines = [] self.CombustionTurbines = [] if CombustionTurbines is None else CombustionTurbines - super(HeatRecoveryBoiler, self).__init__(**kw_args) + super(HeatRecoveryBoiler, self).__init__(*args, **kw_args) + + _attrs = ["steamSupplyRating2"] + _attr_types = {"steamSupplyRating2": float} + _defaults = {"steamSupplyRating2": 0.0} + _enums = {} + _refs = ["CombustionTurbines"] + _many_refs = ["CombustionTurbines"] def getCombustionTurbines(self): """A combustion turbine may have a heat recovery boiler for making steam diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HydroTurbine.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HydroTurbine.py index 1fc91b5..c880f7f 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HydroTurbine.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/HydroTurbine.py @@ -20,8 +20,8 @@ class HydroTurbine(PrimeMover): """A water driven prime mover. Typical turbine types are: Francis, Kaplan, and Pelton. """ - def __init__(self, turbineType='francis', turbineRating=0.0, maxHeadMaxP=0.0, transientDroopTime=0.0, speedRegulation=0.0, waterStartingTime=0.0, speedRating=0.0, transientRegulation=0.0, gateUpperLimit=0.0, minHeadMaxP=0.0, gateRateLimit=0.0, HydroTurbineGovernor=None, **kw_args): - """Initializes a new 'HydroTurbine' instance. + def __init__(self, turbineType="francis", turbineRating=0.0, maxHeadMaxP=0.0, transientDroopTime=0.0, speedRegulation=0.0, waterStartingTime=0.0, speedRating=0.0, transientRegulation=0.0, gateUpperLimit=0.0, minHeadMaxP=0.0, gateRateLimit=0.0, HydroTurbineGovernor=None, *args, **kw_args): + """Initialises a new 'HydroTurbine' instance. @param turbineType: Type of turbine. Values are: "francis", "pelton", "kaplan" @param turbineRating: Rated turbine active power @@ -36,7 +36,7 @@ class HydroTurbine(PrimeMover): @param gateRateLimit: Gate Rate Limit @param HydroTurbineGovernor: """ - #: Type of turbine.Values are: "francis", "pelton", "kaplan" + #: Type of turbine. Values are: "francis", "pelton", "kaplan" self.turbineType = turbineType #: Rated turbine active power @@ -72,7 +72,14 @@ class HydroTurbine(PrimeMover): self._HydroTurbineGovernor = None self.HydroTurbineGovernor = HydroTurbineGovernor - super(HydroTurbine, self).__init__(**kw_args) + super(HydroTurbine, self).__init__(*args, **kw_args) + + _attrs = ["turbineType", "turbineRating", "maxHeadMaxP", "transientDroopTime", "speedRegulation", "waterStartingTime", "speedRating", "transientRegulation", "gateUpperLimit", "minHeadMaxP", "gateRateLimit"] + _attr_types = {"turbineType": str, "turbineRating": float, "maxHeadMaxP": float, "transientDroopTime": float, "speedRegulation": float, "waterStartingTime": float, "speedRating": float, "transientRegulation": float, "gateUpperLimit": float, "minHeadMaxP": float, "gateRateLimit": float} + _defaults = {"turbineType": "francis", "turbineRating": 0.0, "maxHeadMaxP": 0.0, "transientDroopTime": 0.0, "speedRegulation": 0.0, "waterStartingTime": 0.0, "speedRating": 0.0, "transientRegulation": 0.0, "gateUpperLimit": 0.0, "minHeadMaxP": 0.0, "gateRateLimit": 0.0} + _enums = {"turbineType": "TurbineType"} + _refs = ["HydroTurbineGovernor"] + _many_refs = [] def getHydroTurbineGovernor(self): diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PWRSteamSupply.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PWRSteamSupply.py index e6a7dd7..d12e464 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PWRSteamSupply.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PWRSteamSupply.py @@ -20,8 +20,8 @@ class PWRSteamSupply(SteamSupply): """Pressurized water reactor used as a steam supply to a steam turbine """ - def __init__(self, pressureCG=0.0, throttlePressureSP=0.0, coldLegFBLagTC=0.0, hotLegSteamGain=0.0, coreHTLagTC2=0.0, coreHTLagTC1=0.0, coreNeutronicsHT=0.0, coldLegFBLeadTC1=0.0, feedbackFactor=0.0, coreNeutronicsEffTC=0.0, steamFlowFG=0.0, steamPressureDropLagTC=0.0, steamPressureFG=0.0, coldLegFG1=0.0, throttlePressureFactor=0.0, coldLegFBLeadTC2=0.0, hotLegToColdLegGain=0.0, coldLegFG2=0.0, hotLegLagTC=0.0, coldLegLagTC=0.0, **kw_args): - """Initializes a new 'PWRSteamSupply' instance. + def __init__(self, pressureCG=0.0, throttlePressureSP=0.0, coldLegFBLagTC=0.0, hotLegSteamGain=0.0, coreHTLagTC2=0.0, coreHTLagTC1=0.0, coreNeutronicsHT=0.0, coldLegFBLeadTC1=0.0, feedbackFactor=0.0, coreNeutronicsEffTC=0.0, steamFlowFG=0.0, steamPressureDropLagTC=0.0, steamPressureFG=0.0, coldLegFG1=0.0, throttlePressureFactor=0.0, coldLegFBLeadTC2=0.0, hotLegToColdLegGain=0.0, coldLegFG2=0.0, hotLegLagTC=0.0, coldLegLagTC=0.0, *args, **kw_args): + """Initialises a new 'PWRSteamSupply' instance. @param pressureCG: Pressure Control Gain @param throttlePressureSP: Throttle Pressure Setpoint @@ -104,5 +104,12 @@ class PWRSteamSupply(SteamSupply): #: Cold Leg Lag Time Constant self.coldLegLagTC = coldLegLagTC - super(PWRSteamSupply, self).__init__(**kw_args) + super(PWRSteamSupply, self).__init__(*args, **kw_args) + + _attrs = ["pressureCG", "throttlePressureSP", "coldLegFBLagTC", "hotLegSteamGain", "coreHTLagTC2", "coreHTLagTC1", "coreNeutronicsHT", "coldLegFBLeadTC1", "feedbackFactor", "coreNeutronicsEffTC", "steamFlowFG", "steamPressureDropLagTC", "steamPressureFG", "coldLegFG1", "throttlePressureFactor", "coldLegFBLeadTC2", "hotLegToColdLegGain", "coldLegFG2", "hotLegLagTC", "coldLegLagTC"] + _attr_types = {"pressureCG": float, "throttlePressureSP": float, "coldLegFBLagTC": float, "hotLegSteamGain": float, "coreHTLagTC2": float, "coreHTLagTC1": float, "coreNeutronicsHT": float, "coldLegFBLeadTC1": float, "feedbackFactor": float, "coreNeutronicsEffTC": float, "steamFlowFG": float, "steamPressureDropLagTC": float, "steamPressureFG": float, "coldLegFG1": float, "throttlePressureFactor": float, "coldLegFBLeadTC2": float, "hotLegToColdLegGain": float, "coldLegFG2": float, "hotLegLagTC": float, "coldLegLagTC": float} + _defaults = {"pressureCG": 0.0, "throttlePressureSP": 0.0, "coldLegFBLagTC": 0.0, "hotLegSteamGain": 0.0, "coreHTLagTC2": 0.0, "coreHTLagTC1": 0.0, "coreNeutronicsHT": 0.0, "coldLegFBLeadTC1": 0.0, "feedbackFactor": 0.0, "coreNeutronicsEffTC": 0.0, "steamFlowFG": 0.0, "steamPressureDropLagTC": 0.0, "steamPressureFG": 0.0, "coldLegFG1": 0.0, "throttlePressureFactor": 0.0, "coldLegFBLeadTC2": 0.0, "hotLegToColdLegGain": 0.0, "coldLegFG2": 0.0, "hotLegLagTC": 0.0, "coldLegLagTC": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PrimeMover.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PrimeMover.py index 14dcd7b..17116c1 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PrimeMover.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/PrimeMover.py @@ -20,8 +20,8 @@ class PrimeMover(PowerSystemResource): """The machine used to develop mechanical energy used to drive a generator. """ - def __init__(self, primeMoverRating=0.0, SynchronousMachines=None, **kw_args): - """Initializes a new 'PrimeMover' instance. + def __init__(self, primeMoverRating=0.0, SynchronousMachines=None, *args, **kw_args): + """Initialises a new 'PrimeMover' instance. @param primeMoverRating: Rating of prime mover @param SynchronousMachines: Synchronous machines this Prime mover drives. @@ -32,7 +32,14 @@ class PrimeMover(PowerSystemResource): self._SynchronousMachines = [] self.SynchronousMachines = [] if SynchronousMachines is None else SynchronousMachines - super(PrimeMover, self).__init__(**kw_args) + super(PrimeMover, self).__init__(*args, **kw_args) + + _attrs = ["primeMoverRating"] + _attr_types = {"primeMoverRating": float} + _defaults = {"primeMoverRating": 0.0} + _enums = {} + _refs = ["SynchronousMachines"] + _many_refs = ["SynchronousMachines"] def getSynchronousMachines(self): """Synchronous machines this Prime mover drives. diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamSupply.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamSupply.py index 61fd147..0982518 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamSupply.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamSupply.py @@ -20,8 +20,8 @@ class SteamSupply(PowerSystemResource): """Steam supply for steam turbine """ - def __init__(self, steamSupplyRating=0.0, SteamTurbines=None, **kw_args): - """Initializes a new 'SteamSupply' instance. + def __init__(self, steamSupplyRating=0.0, SteamTurbines=None, *args, **kw_args): + """Initialises a new 'SteamSupply' instance. @param steamSupplyRating: Rating of steam supply @param SteamTurbines: Steam turbines may have steam supplied by a steam supply @@ -32,7 +32,14 @@ class SteamSupply(PowerSystemResource): self._SteamTurbines = [] self.SteamTurbines = [] if SteamTurbines is None else SteamTurbines - super(SteamSupply, self).__init__(**kw_args) + super(SteamSupply, self).__init__(*args, **kw_args) + + _attrs = ["steamSupplyRating"] + _attr_types = {"steamSupplyRating": float} + _defaults = {"steamSupplyRating": 0.0} + _enums = {} + _refs = ["SteamTurbines"] + _many_refs = ["SteamTurbines"] def getSteamTurbines(self): """Steam turbines may have steam supplied by a steam supply diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamTurbine.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamTurbine.py index 2016649..e6b3870 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamTurbine.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/SteamTurbine.py @@ -20,8 +20,8 @@ class SteamTurbine(PrimeMover): """Steam turbine """ - def __init__(self, reheater2TC=0.0, shaft1PowerIP=0.0, shaft1PowerLP2=0.0, reheater1TC=0.0, steamChestTC=0.0, crossoverTC=0.0, shaft2PowerHP=0.0, shaft2PowerLP2=0.0, shaft2PowerIP=0.0, shaft1PowerHP=0.0, shaft1PowerLP1=0.0, shaft2PowerLP1=0.0, SteamSupplys=None, **kw_args): - """Initializes a new 'SteamTurbine' instance. + def __init__(self, reheater2TC=0.0, shaft1PowerIP=0.0, shaft1PowerLP2=0.0, reheater1TC=0.0, steamChestTC=0.0, crossoverTC=0.0, shaft2PowerHP=0.0, shaft2PowerLP2=0.0, shaft2PowerIP=0.0, shaft1PowerHP=0.0, shaft1PowerLP1=0.0, shaft2PowerLP1=0.0, SteamSupplys=None, *args, **kw_args): + """Initialises a new 'SteamTurbine' instance. @param reheater2TC: Second Reheater Time Constant @param shaft1PowerIP: Fraction Of Power From Shaft 1 Intermediate Pressure Turbine output @@ -76,7 +76,14 @@ class SteamTurbine(PrimeMover): self._SteamSupplys = [] self.SteamSupplys = [] if SteamSupplys is None else SteamSupplys - super(SteamTurbine, self).__init__(**kw_args) + super(SteamTurbine, self).__init__(*args, **kw_args) + + _attrs = ["reheater2TC", "shaft1PowerIP", "shaft1PowerLP2", "reheater1TC", "steamChestTC", "crossoverTC", "shaft2PowerHP", "shaft2PowerLP2", "shaft2PowerIP", "shaft1PowerHP", "shaft1PowerLP1", "shaft2PowerLP1"] + _attr_types = {"reheater2TC": float, "shaft1PowerIP": float, "shaft1PowerLP2": float, "reheater1TC": float, "steamChestTC": float, "crossoverTC": float, "shaft2PowerHP": float, "shaft2PowerLP2": float, "shaft2PowerIP": float, "shaft1PowerHP": float, "shaft1PowerLP1": float, "shaft2PowerLP1": float} + _defaults = {"reheater2TC": 0.0, "shaft1PowerIP": 0.0, "shaft1PowerLP2": 0.0, "reheater1TC": 0.0, "steamChestTC": 0.0, "crossoverTC": 0.0, "shaft2PowerHP": 0.0, "shaft2PowerLP2": 0.0, "shaft2PowerIP": 0.0, "shaft1PowerHP": 0.0, "shaft1PowerLP1": 0.0, "shaft2PowerLP1": 0.0} + _enums = {} + _refs = ["SteamSupplys"] + _many_refs = ["SteamSupplys"] def getSteamSupplys(self): """Steam turbines may have steam supplied by a steam supply diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Subcritical.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Subcritical.py index 6a17e76..bbe4aa1 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Subcritical.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Subcritical.py @@ -20,9 +20,16 @@ class Subcritical(FossilSteamSupply): """Once-through subcritical boiler """ - def __init__(self, **kw_args): - """Initializes a new 'Subcritical' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Subcritical' instance. """ - super(Subcritical, self).__init__(**kw_args) + super(Subcritical, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Supercritical.py b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Supercritical.py index 8330b73..54dc278 100644 --- a/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Supercritical.py +++ b/schemata/CIM14/IEC61970/Generation/GenerationDynamics/Supercritical.py @@ -20,9 +20,16 @@ class Supercritical(FossilSteamSupply): """Once-through supercritical boiler """ - def __init__(self, **kw_args): - """Initializes a new 'Supercritical' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Supercritical' instance. """ - super(Supercritical, self).__init__(**kw_args) + super(Supercritical, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/Production/AirCompressor.py b/schemata/CIM14/IEC61970/Generation/Production/AirCompressor.py index 32053af..62a21dd 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/AirCompressor.py +++ b/schemata/CIM14/IEC61970/Generation/Production/AirCompressor.py @@ -20,8 +20,8 @@ class AirCompressor(PowerSystemResource): """Combustion turbine air compressor which is an integral part of a compressed air energy storage (CAES) plant """ - def __init__(self, airCompressorRating=0.0, CAESPlant=None, CombustionTurbine=None, **kw_args): - """Initializes a new 'AirCompressor' instance. + def __init__(self, airCompressorRating=0.0, CAESPlant=None, CombustionTurbine=None, *args, **kw_args): + """Initialises a new 'AirCompressor' instance. @param airCompressorRating: Rating of the CAES air compressor @param CAESPlant: An air compressor may be a member of a compressed air energy storage plant @@ -36,7 +36,14 @@ class AirCompressor(PowerSystemResource): self._CombustionTurbine = None self.CombustionTurbine = CombustionTurbine - super(AirCompressor, self).__init__(**kw_args) + super(AirCompressor, self).__init__(*args, **kw_args) + + _attrs = ["airCompressorRating"] + _attr_types = {"airCompressorRating": float} + _defaults = {"airCompressorRating": 0.0} + _enums = {} + _refs = ["CAESPlant", "CombustionTurbine"] + _many_refs = [] def getCAESPlant(self): """An air compressor may be a member of a compressed air energy storage plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/CAESPlant.py b/schemata/CIM14/IEC61970/Generation/Production/CAESPlant.py index 862efac..70f0601 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/CAESPlant.py +++ b/schemata/CIM14/IEC61970/Generation/Production/CAESPlant.py @@ -20,8 +20,8 @@ class CAESPlant(PowerSystemResource): """Compressed air energy storage plant """ - def __init__(self, energyStorageCapacity=0.0, ratedCapacityP=0.0, AirCompressor=None, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'CAESPlant' instance. + def __init__(self, energyStorageCapacity=0.0, ratedCapacityP=0.0, AirCompressor=None, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'CAESPlant' instance. @param energyStorageCapacity: The rated energy storage capacity. @param ratedCapacityP: The CAES plant's gross rated generating capacity @@ -40,7 +40,14 @@ class CAESPlant(PowerSystemResource): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(CAESPlant, self).__init__(**kw_args) + super(CAESPlant, self).__init__(*args, **kw_args) + + _attrs = ["energyStorageCapacity", "ratedCapacityP"] + _attr_types = {"energyStorageCapacity": float, "ratedCapacityP": float} + _defaults = {"energyStorageCapacity": 0.0, "ratedCapacityP": 0.0} + _enums = {} + _refs = ["AirCompressor", "ThermalGeneratingUnit"] + _many_refs = [] def getAirCompressor(self): """An air compressor may be a member of a compressed air energy storage plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/CogenerationPlant.py b/schemata/CIM14/IEC61970/Generation/Production/CogenerationPlant.py index be32369..b3d6f2d 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/CogenerationPlant.py +++ b/schemata/CIM14/IEC61970/Generation/Production/CogenerationPlant.py @@ -20,8 +20,8 @@ class CogenerationPlant(PowerSystemResource): """A set of thermal generating units for the production of electrical energy and process steam (usually from the output of the steam turbines). The steam sendout is typically used for industrial purposes or for municipal heating and cooling. """ - def __init__(self, cogenLPSteamRating=0.0, cogenHPSendoutRating=0.0, ratedP=0.0, cogenLPSendoutRating=0.0, cogenHPSteamRating=0.0, ThermalGeneratingUnits=None, SteamSendoutSchedule=None, **kw_args): - """Initializes a new 'CogenerationPlant' instance. + def __init__(self, cogenLPSteamRating=0.0, cogenHPSendoutRating=0.0, ratedP=0.0, cogenLPSendoutRating=0.0, cogenHPSteamRating=0.0, ThermalGeneratingUnits=None, SteamSendoutSchedule=None, *args, **kw_args): + """Initialises a new 'CogenerationPlant' instance. @param cogenLPSteamRating: The low pressure steam rating @param cogenHPSendoutRating: The high pressure steam sendout @@ -52,7 +52,14 @@ class CogenerationPlant(PowerSystemResource): self._SteamSendoutSchedule = None self.SteamSendoutSchedule = SteamSendoutSchedule - super(CogenerationPlant, self).__init__(**kw_args) + super(CogenerationPlant, self).__init__(*args, **kw_args) + + _attrs = ["cogenLPSteamRating", "cogenHPSendoutRating", "ratedP", "cogenLPSendoutRating", "cogenHPSteamRating"] + _attr_types = {"cogenLPSteamRating": float, "cogenHPSendoutRating": float, "ratedP": float, "cogenLPSendoutRating": float, "cogenHPSteamRating": float} + _defaults = {"cogenLPSteamRating": 0.0, "cogenHPSendoutRating": 0.0, "ratedP": 0.0, "cogenLPSendoutRating": 0.0, "cogenHPSteamRating": 0.0} + _enums = {} + _refs = ["ThermalGeneratingUnits", "SteamSendoutSchedule"] + _many_refs = ["ThermalGeneratingUnits"] def getThermalGeneratingUnits(self): """A thermal generating unit may be a member of a cogeneration plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/CombinedCyclePlant.py b/schemata/CIM14/IEC61970/Generation/Production/CombinedCyclePlant.py index e7b0aa8..9749d10 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/CombinedCyclePlant.py +++ b/schemata/CIM14/IEC61970/Generation/Production/CombinedCyclePlant.py @@ -20,8 +20,8 @@ class CombinedCyclePlant(PowerSystemResource): """A set of combustion turbines and steam turbines where the exhaust heat from the combustion turbines is recovered to make steam for the steam turbines, resulting in greater overall plant efficiency """ - def __init__(self, combCyclePlantRating=0.0, ThermalGeneratingUnits=None, **kw_args): - """Initializes a new 'CombinedCyclePlant' instance. + def __init__(self, combCyclePlantRating=0.0, ThermalGeneratingUnits=None, *args, **kw_args): + """Initialises a new 'CombinedCyclePlant' instance. @param combCyclePlantRating: The combined cycle plant's active power output rating @param ThermalGeneratingUnits: A thermal generating unit may be a member of a combined cycle plant @@ -32,7 +32,14 @@ class CombinedCyclePlant(PowerSystemResource): self._ThermalGeneratingUnits = [] self.ThermalGeneratingUnits = [] if ThermalGeneratingUnits is None else ThermalGeneratingUnits - super(CombinedCyclePlant, self).__init__(**kw_args) + super(CombinedCyclePlant, self).__init__(*args, **kw_args) + + _attrs = ["combCyclePlantRating"] + _attr_types = {"combCyclePlantRating": float} + _defaults = {"combCyclePlantRating": 0.0} + _enums = {} + _refs = ["ThermalGeneratingUnits"] + _many_refs = ["ThermalGeneratingUnits"] def getThermalGeneratingUnits(self): """A thermal generating unit may be a member of a combined cycle plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/EmissionAccount.py b/schemata/CIM14/IEC61970/Generation/Production/EmissionAccount.py index 45e4eae..bc52a7e 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/EmissionAccount.py +++ b/schemata/CIM14/IEC61970/Generation/Production/EmissionAccount.py @@ -20,23 +20,30 @@ class EmissionAccount(Curve): """Accounts for tracking emissions usage and credits for thermal generating units. A unit may have zero or more emission accounts, and will typically have one for tracking usage and one for tracking credits. """ - def __init__(self, emissionType='chlorine', emissionValueSource='measured', ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'EmissionAccount' instance. + def __init__(self, emissionType="chlorine", emissionValueSource="measured", ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'EmissionAccount' instance. @param emissionType: The type of emission, for example sulfur dioxide (SO2). The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide). Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" @param emissionValueSource: The source of the emission value. Values are: "measured", "calculated" @param ThermalGeneratingUnit: A thermal generating unit may have one or more emission allowance accounts """ - #: The type of emission, for example sulfur dioxide (SO2). The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide).Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" + #: The type of emission, for example sulfur dioxide (SO2). The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide). Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" self.emissionType = emissionType - #: The source of the emission value.Values are: "measured", "calculated" + #: The source of the emission value. Values are: "measured", "calculated" self.emissionValueSource = emissionValueSource self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(EmissionAccount, self).__init__(**kw_args) + super(EmissionAccount, self).__init__(*args, **kw_args) + + _attrs = ["emissionType", "emissionValueSource"] + _attr_types = {"emissionType": str, "emissionValueSource": str} + _defaults = {"emissionType": "chlorine", "emissionValueSource": "measured"} + _enums = {"emissionType": "EmissionType", "emissionValueSource": "EmissionValueSource"} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have one or more emission allowance accounts diff --git a/schemata/CIM14/IEC61970/Generation/Production/EmissionCurve.py b/schemata/CIM14/IEC61970/Generation/Production/EmissionCurve.py index 38a674b..712b426 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/EmissionCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/EmissionCurve.py @@ -20,15 +20,15 @@ class EmissionCurve(Curve): """Relationship between the unit's emission rate in units of mass per hour (Y-axis) and output active power (X-axis) for a given type of emission. This curve applies when only one type of fuel is being burned. """ - def __init__(self, emissionType='chlorine', isNetGrossP=False, emissionContent=0.0, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'EmissionCurve' instance. + def __init__(self, emissionType="chlorine", isNetGrossP=False, emissionContent=0.0, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'EmissionCurve' instance. @param emissionType: The type of emission, which also gives the production rate measurement unit. The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide). Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" @param isNetGrossP: Flag is set to true when output is expressed in net active power @param emissionContent: The emission content per quantity of fuel burned @param ThermalGeneratingUnit: A thermal generating unit may have one or more emission curves """ - #: The type of emission, which also gives the production rate measurement unit. The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide).Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" + #: The type of emission, which also gives the production rate measurement unit. The y1AxisUnits of the curve contains the unit of measure (e.g. kg) and the emissionType is the type of emission (e.g. sulfer dioxide). Values are: "chlorine", "carbonDioxide", "hydrogenSulfide", "nitrogenOxide", "sulfurDioxide", "carbonDisulfide" self.emissionType = emissionType #: Flag is set to true when output is expressed in net active power @@ -40,7 +40,14 @@ class EmissionCurve(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(EmissionCurve, self).__init__(**kw_args) + super(EmissionCurve, self).__init__(*args, **kw_args) + + _attrs = ["emissionType", "isNetGrossP", "emissionContent"] + _attr_types = {"emissionType": str, "isNetGrossP": bool, "emissionContent": float} + _defaults = {"emissionType": "chlorine", "isNetGrossP": False, "emissionContent": 0.0} + _enums = {"emissionType": "EmissionType"} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have one or more emission curves diff --git a/schemata/CIM14/IEC61970/Generation/Production/FossilFuel.py b/schemata/CIM14/IEC61970/Generation/Production/FossilFuel.py index 4efdcd2..7662b66 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/FossilFuel.py +++ b/schemata/CIM14/IEC61970/Generation/Production/FossilFuel.py @@ -20,8 +20,8 @@ class FossilFuel(IdentifiedObject): """The fossil fuel consumed by the non-nuclear thermal generating units, e.g., coal, oil, gas """ - def __init__(self, fossilFuelType='lignite', fuelSulfur=0.0, fuelMixture=0.0, fuelCost=0.0, fuelHandlingCost=0.0, fuelEffFactor=0.0, fuelHeatContent=0.0, fuelDispatchCost=0.0, lowBreakpointP=0.0, highBreakpointP=0.0, FuelAllocationSchedules=None, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'FossilFuel' instance. + def __init__(self, fossilFuelType="lignite", fuelSulfur=0.0, fuelMixture=0.0, fuelCost=0.0, fuelHandlingCost=0.0, fuelEffFactor=0.0, fuelHeatContent=0.0, fuelDispatchCost=0.0, lowBreakpointP=0.0, highBreakpointP=0.0, FuelAllocationSchedules=None, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'FossilFuel' instance. @param fossilFuelType: The type of fossil fuel, such as coal, oil, or gas. Values are: "lignite", "coal", "oil", "gas" @param fuelSulfur: The fuel's fraction of pollution credit per unit of heat content @@ -36,7 +36,7 @@ class FossilFuel(IdentifiedObject): @param FuelAllocationSchedules: A fuel allocation schedule must have a fossil fuel @param ThermalGeneratingUnit: A thermal generating unit may have one or more fossil fuels """ - #: The type of fossil fuel, such as coal, oil, or gas.Values are: "lignite", "coal", "oil", "gas" + #: The type of fossil fuel, such as coal, oil, or gas. Values are: "lignite", "coal", "oil", "gas" self.fossilFuelType = fossilFuelType #: The fuel's fraction of pollution credit per unit of heat content @@ -72,7 +72,14 @@ class FossilFuel(IdentifiedObject): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(FossilFuel, self).__init__(**kw_args) + super(FossilFuel, self).__init__(*args, **kw_args) + + _attrs = ["fossilFuelType", "fuelSulfur", "fuelMixture", "fuelCost", "fuelHandlingCost", "fuelEffFactor", "fuelHeatContent", "fuelDispatchCost", "lowBreakpointP", "highBreakpointP"] + _attr_types = {"fossilFuelType": str, "fuelSulfur": float, "fuelMixture": float, "fuelCost": float, "fuelHandlingCost": float, "fuelEffFactor": float, "fuelHeatContent": float, "fuelDispatchCost": float, "lowBreakpointP": float, "highBreakpointP": float} + _defaults = {"fossilFuelType": "lignite", "fuelSulfur": 0.0, "fuelMixture": 0.0, "fuelCost": 0.0, "fuelHandlingCost": 0.0, "fuelEffFactor": 0.0, "fuelHeatContent": 0.0, "fuelDispatchCost": 0.0, "lowBreakpointP": 0.0, "highBreakpointP": 0.0} + _enums = {"fossilFuelType": "FuelType"} + _refs = ["FuelAllocationSchedules", "ThermalGeneratingUnit"] + _many_refs = ["FuelAllocationSchedules"] def getFuelAllocationSchedules(self): """A fuel allocation schedule must have a fossil fuel diff --git a/schemata/CIM14/IEC61970/Generation/Production/FuelAllocationSchedule.py b/schemata/CIM14/IEC61970/Generation/Production/FuelAllocationSchedule.py index 491721b..aa37211 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/FuelAllocationSchedule.py +++ b/schemata/CIM14/IEC61970/Generation/Production/FuelAllocationSchedule.py @@ -20,8 +20,8 @@ class FuelAllocationSchedule(Curve): """The amount of fuel of a given type which is allocated for consumption over a specified period of time """ - def __init__(self, fuelType='lignite', minFuelAllocation=0.0, fuelAllocationStartDate='', maxFuelAllocation=0.0, fuelAllocationEndDate='', FossilFuel=None, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'FuelAllocationSchedule' instance. + def __init__(self, fuelType="lignite", minFuelAllocation=0.0, fuelAllocationStartDate='', maxFuelAllocation=0.0, fuelAllocationEndDate='', FossilFuel=None, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'FuelAllocationSchedule' instance. @param fuelType: The type of fuel, which also indicates the corresponding measurement unit Values are: "lignite", "coal", "oil", "gas" @param minFuelAllocation: The minimum amount fuel that is allocated for consumption for the scheduled time period, e.g., based on a 'take-or-pay' contract @@ -31,7 +31,7 @@ class FuelAllocationSchedule(Curve): @param FossilFuel: A fuel allocation schedule must have a fossil fuel @param ThermalGeneratingUnit: A thermal generating unit may have one or more fuel allocation schedules """ - #: The type of fuel, which also indicates the corresponding measurement unitValues are: "lignite", "coal", "oil", "gas" + #: The type of fuel, which also indicates the corresponding measurement unit Values are: "lignite", "coal", "oil", "gas" self.fuelType = fuelType #: The minimum amount fuel that is allocated for consumption for the scheduled time period, e.g., based on a 'take-or-pay' contract @@ -52,7 +52,14 @@ class FuelAllocationSchedule(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(FuelAllocationSchedule, self).__init__(**kw_args) + super(FuelAllocationSchedule, self).__init__(*args, **kw_args) + + _attrs = ["fuelType", "minFuelAllocation", "fuelAllocationStartDate", "maxFuelAllocation", "fuelAllocationEndDate"] + _attr_types = {"fuelType": str, "minFuelAllocation": float, "fuelAllocationStartDate": str, "maxFuelAllocation": float, "fuelAllocationEndDate": str} + _defaults = {"fuelType": "lignite", "minFuelAllocation": 0.0, "fuelAllocationStartDate": '', "maxFuelAllocation": 0.0, "fuelAllocationEndDate": ''} + _enums = {"fuelType": "FuelType"} + _refs = ["FossilFuel", "ThermalGeneratingUnit"] + _many_refs = [] def getFossilFuel(self): """A fuel allocation schedule must have a fossil fuel diff --git a/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpCostCurve.py b/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpCostCurve.py index 905fd9b..f8595de 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpCostCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpCostCurve.py @@ -20,8 +20,8 @@ class GenUnitOpCostCurve(Curve): """Relationship between unit operating cost (Y-axis) and unit output active power (X-axis). The operating cost curve for thermal units is derived from heat input and fuel costs. The operating cost curve for hydro units is derived from water flow rates and equivalent water costs. """ - def __init__(self, isNetGrossP=False, GeneratingUnit=None, **kw_args): - """Initializes a new 'GenUnitOpCostCurve' instance. + def __init__(self, isNetGrossP=False, GeneratingUnit=None, *args, **kw_args): + """Initialises a new 'GenUnitOpCostCurve' instance. @param isNetGrossP: Flag is set to true when output is expressed in net active power @param GeneratingUnit: A generating unit may have one or more cost curves, depending upon fuel mixture and fuel cost. @@ -32,7 +32,14 @@ class GenUnitOpCostCurve(Curve): self._GeneratingUnit = None self.GeneratingUnit = GeneratingUnit - super(GenUnitOpCostCurve, self).__init__(**kw_args) + super(GenUnitOpCostCurve, self).__init__(*args, **kw_args) + + _attrs = ["isNetGrossP"] + _attr_types = {"isNetGrossP": bool} + _defaults = {"isNetGrossP": False} + _enums = {} + _refs = ["GeneratingUnit"] + _many_refs = [] def getGeneratingUnit(self): """A generating unit may have one or more cost curves, depending upon fuel mixture and fuel cost. diff --git a/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpSchedule.py b/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpSchedule.py index 77cc1b0..da0e54e 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpSchedule.py +++ b/schemata/CIM14/IEC61970/Generation/Production/GenUnitOpSchedule.py @@ -20,15 +20,22 @@ class GenUnitOpSchedule(RegularIntervalSchedule): """The generating unit's Operator-approved current operating schedule (or plan), typically produced with the aid of unit commitment type analyses. The X-axis represents absolute time. The Y1-axis represents the status (0=off-line and unavailable: 1=available: 2=must run: 3=must run at fixed power value: etc.). The Y2-axis represents the must run fixed power value where required. """ - def __init__(self, GeneratingUnit=None, **kw_args): - """Initializes a new 'GenUnitOpSchedule' instance. + def __init__(self, GeneratingUnit=None, *args, **kw_args): + """Initialises a new 'GenUnitOpSchedule' instance. @param GeneratingUnit: A generating unit may have an operating schedule, indicating the planned operation of the unit """ self._GeneratingUnit = None self.GeneratingUnit = GeneratingUnit - super(GenUnitOpSchedule, self).__init__(**kw_args) + super(GenUnitOpSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["GeneratingUnit"] + _many_refs = [] def getGeneratingUnit(self): """A generating unit may have an operating schedule, indicating the planned operation of the unit diff --git a/schemata/CIM14/IEC61970/Generation/Production/GeneratingUnit.py b/schemata/CIM14/IEC61970/Generation/Production/GeneratingUnit.py index b773ba2..0884b21 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/GeneratingUnit.py +++ b/schemata/CIM14/IEC61970/Generation/Production/GeneratingUnit.py @@ -20,8 +20,8 @@ class GeneratingUnit(Equipment): """A single or set of synchronous machines for converting mechanical power into alternating-current power. For example, individual machines within a set may be defined for scheduling purposes while a single control signal is derived for the set. In this case there would be a GeneratingUnit for each member of the set and an additional GeneratingUnit corresponding to the set. """ - def __init__(self, genControlMode='setpoint', genOperatingMode='fixed', genControlSource='unavailable', startupTime=0.0, minimumOffTime=0.0, spinReserveRamp=0.0, controlDeadband=0.0, maxOperatingP=0.0, fastStartFlag=False, lowControlLimit=0.0, baseP=0.0, maxEconomicP=0.0, efficiency=0.0, shortPF=0.0, lowerRampRate=0.0, stepChange=0.0, penaltyFactor=0.0, longPF=0.0, ratedGrossMinP=0.0, ratedGrossMaxP=0.0, dispReserveFlag=False, variableCost=0.0, modelDetail=0, energyMinP=0.0, maximumAllowableSpinningReserve=0.0, fuelPriority=0, raiseRampRate=0.0, nominalP=0.0, normalPF=0.0, governorMPL=0.0, ratedNetMaxP=0.0, controlResponseRate=0.0, tieLinePF=0.0, governorSCD=0.0, controlPulseLow=0.0, highControlLimit=0.0, initialP=0.0, minEconomicP=0.0, autoCntrlMarginP=0.0, allocSpinResP=0.0, startupCost=0.0, minOperatingP=0.0, controlPulseHigh=0.0, SynchronousMachines=None, GrossToNetActivePowerCurves=None, GenUnitOpCostCurves=None, GenUnitOpSchedule=None, ControlAreaGeneratingUnit=None, **kw_args): - """Initializes a new 'GeneratingUnit' instance. + def __init__(self, genControlMode="setpoint", genOperatingMode="fixed", genControlSource="unavailable", startupTime=0.0, minimumOffTime=0.0, spinReserveRamp=0.0, controlDeadband=0.0, maxOperatingP=0.0, fastStartFlag=False, lowControlLimit=0.0, baseP=0.0, maxEconomicP=0.0, efficiency=0.0, shortPF=0.0, lowerRampRate=0.0, stepChange=0.0, penaltyFactor=0.0, longPF=0.0, ratedGrossMinP=0.0, ratedGrossMaxP=0.0, dispReserveFlag=False, variableCost=0.0, modelDetail=0, energyMinP=0.0, maximumAllowableSpinningReserve=0.0, fuelPriority=0, raiseRampRate=0.0, nominalP=0.0, normalPF=0.0, governorMPL=0.0, ratedNetMaxP=0.0, controlResponseRate=0.0, tieLinePF=0.0, governorSCD=0.0, controlPulseLow=0.0, highControlLimit=0.0, initialP=0.0, minEconomicP=0.0, autoCntrlMarginP=0.0, allocSpinResP=0.0, startupCost=0.0, minOperatingP=0.0, controlPulseHigh=0.0, SynchronousMachines=None, GrossToNetActivePowerCurves=None, GenUnitOpCostCurves=None, GenUnitOpSchedule=None, ControlAreaGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'GeneratingUnit' instance. @param genControlMode: The unit control mode. Values are: "setpoint", "pulse" @param genOperatingMode: Operating mode for secondary control. Values are: "fixed", "EDC", "manual", "off", "MRN", "LFC", "AGC", "REG" @@ -72,13 +72,13 @@ class GeneratingUnit(Equipment): @param GenUnitOpSchedule: A generating unit may have an operating schedule, indicating the planned operation of the unit @param ControlAreaGeneratingUnit: ControlArea specifications for this generating unit. """ - #: The unit control mode.Values are: "setpoint", "pulse" + #: The unit control mode. Values are: "setpoint", "pulse" self.genControlMode = genControlMode - #: Operating mode for secondary control.Values are: "fixed", "EDC", "manual", "off", "MRN", "LFC", "AGC", "REG" + #: Operating mode for secondary control. Values are: "fixed", "EDC", "manual", "off", "MRN", "LFC", "AGC", "REG" self.genOperatingMode = genOperatingMode - #: The source of controls for a generating unit.Values are: "unavailable", "onAGC", "plantControl", "offAGC" + #: The source of controls for a generating unit. Values are: "unavailable", "onAGC", "plantControl", "offAGC" self.genControlSource = genControlSource #: Time it takes to get the unit on-line, from the time that the prime mover mechanical power is applied @@ -216,7 +216,14 @@ class GeneratingUnit(Equipment): self._ControlAreaGeneratingUnit = [] self.ControlAreaGeneratingUnit = [] if ControlAreaGeneratingUnit is None else ControlAreaGeneratingUnit - super(GeneratingUnit, self).__init__(**kw_args) + super(GeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = ["genControlMode", "genOperatingMode", "genControlSource", "startupTime", "minimumOffTime", "spinReserveRamp", "controlDeadband", "maxOperatingP", "fastStartFlag", "lowControlLimit", "baseP", "maxEconomicP", "efficiency", "shortPF", "lowerRampRate", "stepChange", "penaltyFactor", "longPF", "ratedGrossMinP", "ratedGrossMaxP", "dispReserveFlag", "variableCost", "modelDetail", "energyMinP", "maximumAllowableSpinningReserve", "fuelPriority", "raiseRampRate", "nominalP", "normalPF", "governorMPL", "ratedNetMaxP", "controlResponseRate", "tieLinePF", "governorSCD", "controlPulseLow", "highControlLimit", "initialP", "minEconomicP", "autoCntrlMarginP", "allocSpinResP", "startupCost", "minOperatingP", "controlPulseHigh"] + _attr_types = {"genControlMode": str, "genOperatingMode": str, "genControlSource": str, "startupTime": float, "minimumOffTime": float, "spinReserveRamp": float, "controlDeadband": float, "maxOperatingP": float, "fastStartFlag": bool, "lowControlLimit": float, "baseP": float, "maxEconomicP": float, "efficiency": float, "shortPF": float, "lowerRampRate": float, "stepChange": float, "penaltyFactor": float, "longPF": float, "ratedGrossMinP": float, "ratedGrossMaxP": float, "dispReserveFlag": bool, "variableCost": float, "modelDetail": int, "energyMinP": float, "maximumAllowableSpinningReserve": float, "fuelPriority": int, "raiseRampRate": float, "nominalP": float, "normalPF": float, "governorMPL": float, "ratedNetMaxP": float, "controlResponseRate": float, "tieLinePF": float, "governorSCD": float, "controlPulseLow": float, "highControlLimit": float, "initialP": float, "minEconomicP": float, "autoCntrlMarginP": float, "allocSpinResP": float, "startupCost": float, "minOperatingP": float, "controlPulseHigh": float} + _defaults = {"genControlMode": "setpoint", "genOperatingMode": "fixed", "genControlSource": "unavailable", "startupTime": 0.0, "minimumOffTime": 0.0, "spinReserveRamp": 0.0, "controlDeadband": 0.0, "maxOperatingP": 0.0, "fastStartFlag": False, "lowControlLimit": 0.0, "baseP": 0.0, "maxEconomicP": 0.0, "efficiency": 0.0, "shortPF": 0.0, "lowerRampRate": 0.0, "stepChange": 0.0, "penaltyFactor": 0.0, "longPF": 0.0, "ratedGrossMinP": 0.0, "ratedGrossMaxP": 0.0, "dispReserveFlag": False, "variableCost": 0.0, "modelDetail": 0, "energyMinP": 0.0, "maximumAllowableSpinningReserve": 0.0, "fuelPriority": 0, "raiseRampRate": 0.0, "nominalP": 0.0, "normalPF": 0.0, "governorMPL": 0.0, "ratedNetMaxP": 0.0, "controlResponseRate": 0.0, "tieLinePF": 0.0, "governorSCD": 0.0, "controlPulseLow": 0.0, "highControlLimit": 0.0, "initialP": 0.0, "minEconomicP": 0.0, "autoCntrlMarginP": 0.0, "allocSpinResP": 0.0, "startupCost": 0.0, "minOperatingP": 0.0, "controlPulseHigh": 0.0} + _enums = {"genControlMode": "GeneratorControlMode", "genOperatingMode": "GeneratorOperatingMode", "genControlSource": "GeneratorControlSource"} + _refs = ["SynchronousMachines", "GrossToNetActivePowerCurves", "GenUnitOpCostCurves", "GenUnitOpSchedule", "ControlAreaGeneratingUnit"] + _many_refs = ["SynchronousMachines", "GrossToNetActivePowerCurves", "GenUnitOpCostCurves", "ControlAreaGeneratingUnit"] def getSynchronousMachines(self): """A synchronous machine may operate as a generator and as such becomes a member of a generating unit diff --git a/schemata/CIM14/IEC61970/Generation/Production/GrossToNetActivePowerCurve.py b/schemata/CIM14/IEC61970/Generation/Production/GrossToNetActivePowerCurve.py index 67557fb..c3ce4f4 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/GrossToNetActivePowerCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/GrossToNetActivePowerCurve.py @@ -20,15 +20,22 @@ class GrossToNetActivePowerCurve(Curve): """Relationship between the generating unit's gross active power output on the X-axis (measured at the terminals of the machine(s)) and the generating unit's net active power output on the Y-axis (based on utility-defined measurements at the power station). Station service loads, when modeled, should be treated as non-conforming bus loads. There may be more than one curve, depending on the auxiliary equipment that is in service. """ - def __init__(self, GeneratingUnit=None, **kw_args): - """Initializes a new 'GrossToNetActivePowerCurve' instance. + def __init__(self, GeneratingUnit=None, *args, **kw_args): + """Initialises a new 'GrossToNetActivePowerCurve' instance. @param GeneratingUnit: A generating unit may have a gross active power to net active power curve, describing the losses and auxiliary power requirements of the unit """ self._GeneratingUnit = None self.GeneratingUnit = GeneratingUnit - super(GrossToNetActivePowerCurve, self).__init__(**kw_args) + super(GrossToNetActivePowerCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["GeneratingUnit"] + _many_refs = [] def getGeneratingUnit(self): """A generating unit may have a gross active power to net active power curve, describing the losses and auxiliary power requirements of the unit diff --git a/schemata/CIM14/IEC61970/Generation/Production/HeatInputCurve.py b/schemata/CIM14/IEC61970/Generation/Production/HeatInputCurve.py index be255f4..5402e83 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HeatInputCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HeatInputCurve.py @@ -20,8 +20,8 @@ class HeatInputCurve(Curve): """Relationship between unit heat input in energy per time for main fuel (Y1-axis) and supplemental fuel (Y2-axis) versus unit output in active power (X-axis). The quantity of main fuel used to sustain generation at this output level is prorated for throttling between definition points. The quantity of supplemental fuel used at this output level is fixed and not prorated. """ - def __init__(self, heatInputEff=0.0, auxPowerMult=0.0, heatInputOffset=0.0, isNetGrossP=False, auxPowerOffset=0.0, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'HeatInputCurve' instance. + def __init__(self, heatInputEff=0.0, auxPowerMult=0.0, heatInputOffset=0.0, isNetGrossP=False, auxPowerOffset=0.0, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'HeatInputCurve' instance. @param heatInputEff: Heat input - efficiency multiplier adjustment factor. @param auxPowerMult: Power output - auxiliary power multiplier adjustment factor. @@ -48,7 +48,14 @@ class HeatInputCurve(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(HeatInputCurve, self).__init__(**kw_args) + super(HeatInputCurve, self).__init__(*args, **kw_args) + + _attrs = ["heatInputEff", "auxPowerMult", "heatInputOffset", "isNetGrossP", "auxPowerOffset"] + _attr_types = {"heatInputEff": float, "auxPowerMult": float, "heatInputOffset": float, "isNetGrossP": bool, "auxPowerOffset": float} + _defaults = {"heatInputEff": 0.0, "auxPowerMult": 0.0, "heatInputOffset": 0.0, "isNetGrossP": False, "auxPowerOffset": 0.0} + _enums = {} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have a heat input curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/HeatRateCurve.py b/schemata/CIM14/IEC61970/Generation/Production/HeatRateCurve.py index f256978..83cc6cd 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HeatRateCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HeatRateCurve.py @@ -20,8 +20,8 @@ class HeatRateCurve(Curve): """Relationship between unit heat rate per active power (Y-axis) and unit output (X-axis). The heat input is from all fuels. """ - def __init__(self, isNetGrossP=False, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'HeatRateCurve' instance. + def __init__(self, isNetGrossP=False, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'HeatRateCurve' instance. @param isNetGrossP: Flag is set to true when output is expressed in net active power @param ThermalGeneratingUnit: A thermal generating unit may have a heat rate curve @@ -32,7 +32,14 @@ class HeatRateCurve(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(HeatRateCurve, self).__init__(**kw_args) + super(HeatRateCurve, self).__init__(*args, **kw_args) + + _attrs = ["isNetGrossP"] + _attr_types = {"isNetGrossP": bool} + _defaults = {"isNetGrossP": False} + _enums = {} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have a heat rate curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingEfficiencyCurve.py b/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingEfficiencyCurve.py index be1e3d6..849cb9b 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingEfficiencyCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingEfficiencyCurve.py @@ -20,15 +20,22 @@ class HydroGeneratingEfficiencyCurve(Curve): """Relationship between unit efficiency in percent and unit output active power for a given net head in meters. The relationship between efficiency, discharge, head, and power output is expressed as follows: E =KP/HQ Where: (E=percentage) (P=active power) (H=height) (Q=volume/time unit) (K=constant) For example, a curve instance for a given net head could relate efficiency (Y-axis) versus active power output (X-axis) or versus discharge on the X-axis. """ - def __init__(self, HydroGeneratingUnit=None, **kw_args): - """Initializes a new 'HydroGeneratingEfficiencyCurve' instance. + def __init__(self, HydroGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'HydroGeneratingEfficiencyCurve' instance. @param HydroGeneratingUnit: A hydro generating unit has an efficiency curve """ self._HydroGeneratingUnit = None self.HydroGeneratingUnit = HydroGeneratingUnit - super(HydroGeneratingEfficiencyCurve, self).__init__(**kw_args) + super(HydroGeneratingEfficiencyCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["HydroGeneratingUnit"] + _many_refs = [] def getHydroGeneratingUnit(self): """A hydro generating unit has an efficiency curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingUnit.py b/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingUnit.py index 0912aa7..8372814 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingUnit.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HydroGeneratingUnit.py @@ -20,8 +20,8 @@ class HydroGeneratingUnit(GeneratingUnit): """A generating unit whose prime mover is a hydraulic turbine (e.g., Francis, Pelton, Kaplan) """ - def __init__(self, energyConversionCapability='generator', hydroUnitWaterCost=0.0, HydroPowerPlant=None, PenstockLossCurve=None, HydroGeneratingEfficiencyCurves=None, TailbayLossCurve=None, **kw_args): - """Initializes a new 'HydroGeneratingUnit' instance. + def __init__(self, energyConversionCapability="generator", hydroUnitWaterCost=0.0, HydroPowerPlant=None, PenstockLossCurve=None, HydroGeneratingEfficiencyCurves=None, TailbayLossCurve=None, *args, **kw_args): + """Initialises a new 'HydroGeneratingUnit' instance. @param energyConversionCapability: Energy conversion capability for generating. Values are: "generator", "pumpAndGenerator" @param hydroUnitWaterCost: The equivalent cost of water that drives the hydro turbine, expressed as cost per volume. @@ -30,7 +30,7 @@ class HydroGeneratingUnit(GeneratingUnit): @param HydroGeneratingEfficiencyCurves: A hydro generating unit has an efficiency curve @param TailbayLossCurve: A hydro generating unit has a tailbay loss curve """ - #: Energy conversion capability for generating.Values are: "generator", "pumpAndGenerator" + #: Energy conversion capability for generating. Values are: "generator", "pumpAndGenerator" self.energyConversionCapability = energyConversionCapability #: The equivalent cost of water that drives the hydro turbine, expressed as cost per volume. @@ -48,7 +48,14 @@ class HydroGeneratingUnit(GeneratingUnit): self._TailbayLossCurve = [] self.TailbayLossCurve = [] if TailbayLossCurve is None else TailbayLossCurve - super(HydroGeneratingUnit, self).__init__(**kw_args) + super(HydroGeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = ["energyConversionCapability", "hydroUnitWaterCost"] + _attr_types = {"energyConversionCapability": str, "hydroUnitWaterCost": float} + _defaults = {"energyConversionCapability": "generator", "hydroUnitWaterCost": 0.0} + _enums = {"energyConversionCapability": "HydroEnergyConversionKind"} + _refs = ["HydroPowerPlant", "PenstockLossCurve", "HydroGeneratingEfficiencyCurves", "TailbayLossCurve"] + _many_refs = ["HydroGeneratingEfficiencyCurves", "TailbayLossCurve"] def getHydroPowerPlant(self): """The hydro generating unit belongs to a hydro power plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/HydroPowerPlant.py b/schemata/CIM14/IEC61970/Generation/Production/HydroPowerPlant.py index 0f3b09d..46d29fc 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HydroPowerPlant.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HydroPowerPlant.py @@ -20,8 +20,8 @@ class HydroPowerPlant(PowerSystemResource): """A hydro power station which can generate or pump. When generating, the generator turbines receive there water from an upper reservoir. When pumping, the pumps receive their water from a lower reservoir. """ - def __init__(self, hydroPlantType='runOfRiver', penstockType='', surgeTankCode='', plantRatedHead=0.0, plantDischargeCapacity=0.0, surgeTankCrestLevel=0.0, dischargeTravelDelay=0.0, pumpRatedP=0.0, genRatedP=0.0, HydroGeneratingUnits=None, HydroPumps=None, Reservoir=None, GenSourcePumpDischargeReservoir=None, **kw_args): - """Initializes a new 'HydroPowerPlant' instance. + def __init__(self, hydroPlantType="runOfRiver", penstockType="", surgeTankCode="", plantRatedHead=0.0, plantDischargeCapacity=0.0, surgeTankCrestLevel=0.0, dischargeTravelDelay=0.0, pumpRatedP=0.0, genRatedP=0.0, HydroGeneratingUnits=None, HydroPumps=None, Reservoir=None, GenSourcePumpDischargeReservoir=None, *args, **kw_args): + """Initialises a new 'HydroPowerPlant' instance. @param hydroPlantType: The type of hydro power plant. Values are: "runOfRiver", "minorStorage", "majorStorage", "pumpedStorage" @param penstockType: Type and configuration of hydro plant penstock(s) @@ -37,7 +37,7 @@ class HydroPowerPlant(PowerSystemResource): @param Reservoir: Generators discharge water to or pumps are supplied water from a downstream reservoir @param GenSourcePumpDischargeReservoir: Generators are supplied water from or pumps discharge water to an upstream reservoir """ - #: The type of hydro power plant.Values are: "runOfRiver", "minorStorage", "majorStorage", "pumpedStorage" + #: The type of hydro power plant. Values are: "runOfRiver", "minorStorage", "majorStorage", "pumpedStorage" self.hydroPlantType = hydroPlantType #: Type and configuration of hydro plant penstock(s) @@ -76,7 +76,14 @@ class HydroPowerPlant(PowerSystemResource): self._GenSourcePumpDischargeReservoir = None self.GenSourcePumpDischargeReservoir = GenSourcePumpDischargeReservoir - super(HydroPowerPlant, self).__init__(**kw_args) + super(HydroPowerPlant, self).__init__(*args, **kw_args) + + _attrs = ["hydroPlantType", "penstockType", "surgeTankCode", "plantRatedHead", "plantDischargeCapacity", "surgeTankCrestLevel", "dischargeTravelDelay", "pumpRatedP", "genRatedP"] + _attr_types = {"hydroPlantType": str, "penstockType": str, "surgeTankCode": str, "plantRatedHead": float, "plantDischargeCapacity": float, "surgeTankCrestLevel": float, "dischargeTravelDelay": float, "pumpRatedP": float, "genRatedP": float} + _defaults = {"hydroPlantType": "runOfRiver", "penstockType": "", "surgeTankCode": "", "plantRatedHead": 0.0, "plantDischargeCapacity": 0.0, "surgeTankCrestLevel": 0.0, "dischargeTravelDelay": 0.0, "pumpRatedP": 0.0, "genRatedP": 0.0} + _enums = {"hydroPlantType": "HydroPlantType", "penstockType": "PenstockType", "surgeTankCode": "SurgeTankCode"} + _refs = ["HydroGeneratingUnits", "HydroPumps", "Reservoir", "GenSourcePumpDischargeReservoir"] + _many_refs = ["HydroGeneratingUnits", "HydroPumps"] def getHydroGeneratingUnits(self): """The hydro generating unit belongs to a hydro power plant diff --git a/schemata/CIM14/IEC61970/Generation/Production/HydroPump.py b/schemata/CIM14/IEC61970/Generation/Production/HydroPump.py index b6439d8..e28831f 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HydroPump.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HydroPump.py @@ -20,8 +20,8 @@ class HydroPump(PowerSystemResource): """A synchronous motor-driven pump, typically associated with a pumped storage plant """ - def __init__(self, pumpPowerAtMaxHead=0.0, pumpPowerAtMinHead=0.0, pumpDischAtMinHead=0.0, pumpDischAtMaxHead=0.0, SynchronousMachine=None, HydroPumpOpSchedule=None, HydroPowerPlant=None, **kw_args): - """Initializes a new 'HydroPump' instance. + def __init__(self, pumpPowerAtMaxHead=0.0, pumpPowerAtMinHead=0.0, pumpDischAtMinHead=0.0, pumpDischAtMaxHead=0.0, SynchronousMachine=None, HydroPumpOpSchedule=None, HydroPowerPlant=None, *args, **kw_args): + """Initialises a new 'HydroPump' instance. @param pumpPowerAtMaxHead: The pumping power under maximum head conditions, usually at full gate @param pumpPowerAtMinHead: The pumping power under minimum head conditions, usually at full gate. @@ -52,7 +52,14 @@ class HydroPump(PowerSystemResource): self._HydroPowerPlant = None self.HydroPowerPlant = HydroPowerPlant - super(HydroPump, self).__init__(**kw_args) + super(HydroPump, self).__init__(*args, **kw_args) + + _attrs = ["pumpPowerAtMaxHead", "pumpPowerAtMinHead", "pumpDischAtMinHead", "pumpDischAtMaxHead"] + _attr_types = {"pumpPowerAtMaxHead": float, "pumpPowerAtMinHead": float, "pumpDischAtMinHead": float, "pumpDischAtMaxHead": float} + _defaults = {"pumpPowerAtMaxHead": 0.0, "pumpPowerAtMinHead": 0.0, "pumpDischAtMinHead": 0.0, "pumpDischAtMaxHead": 0.0} + _enums = {} + _refs = ["SynchronousMachine", "HydroPumpOpSchedule", "HydroPowerPlant"] + _many_refs = [] def getSynchronousMachine(self): """The synchronous machine drives the turbine which moves the water from a low elevation to a higher elevation. The direction of machine rotation for pumping may or may not be the same as for generating. diff --git a/schemata/CIM14/IEC61970/Generation/Production/HydroPumpOpSchedule.py b/schemata/CIM14/IEC61970/Generation/Production/HydroPumpOpSchedule.py index 6dae7ff..dba05da 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/HydroPumpOpSchedule.py +++ b/schemata/CIM14/IEC61970/Generation/Production/HydroPumpOpSchedule.py @@ -20,15 +20,22 @@ class HydroPumpOpSchedule(RegularIntervalSchedule): """The hydro pump's Operator-approved current operating schedule (or plan), typically produced with the aid of unit commitment type analyses.The unit's operating schedule status is typically given as: (0=unavailable) (1=avilable to startup or shutdown) (2=must pump) """ - def __init__(self, HydroPump=None, **kw_args): - """Initializes a new 'HydroPumpOpSchedule' instance. + def __init__(self, HydroPump=None, *args, **kw_args): + """Initialises a new 'HydroPumpOpSchedule' instance. @param HydroPump: The hydro pump has a pumping schedule over time, indicating when pumping is to occur. """ self._HydroPump = None self.HydroPump = HydroPump - super(HydroPumpOpSchedule, self).__init__(**kw_args) + super(HydroPumpOpSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["HydroPump"] + _many_refs = [] def getHydroPump(self): """The hydro pump has a pumping schedule over time, indicating when pumping is to occur. diff --git a/schemata/CIM14/IEC61970/Generation/Production/IncrementalHeatRateCurve.py b/schemata/CIM14/IEC61970/Generation/Production/IncrementalHeatRateCurve.py index caf4d0a..cb96ed9 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/IncrementalHeatRateCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/IncrementalHeatRateCurve.py @@ -20,8 +20,8 @@ class IncrementalHeatRateCurve(Curve): """Relationship between unit incremental heat rate in (delta energy/time) per (delta active power) and unit output in active power. The IHR curve represents the slope of the HeatInputCurve. Note that the 'incremental heat rate' and the 'heat rate' have the same engineering units. """ - def __init__(self, isNetGrossP=False, ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'IncrementalHeatRateCurve' instance. + def __init__(self, isNetGrossP=False, ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'IncrementalHeatRateCurve' instance. @param isNetGrossP: Flag is set to true when output is expressed in net active power @param ThermalGeneratingUnit: A thermal generating unit may have an incremental heat rate curve @@ -32,7 +32,14 @@ class IncrementalHeatRateCurve(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(IncrementalHeatRateCurve, self).__init__(**kw_args) + super(IncrementalHeatRateCurve, self).__init__(*args, **kw_args) + + _attrs = ["isNetGrossP"] + _attr_types = {"isNetGrossP": bool} + _defaults = {"isNetGrossP": False} + _enums = {} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have an incremental heat rate curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/InflowForecast.py b/schemata/CIM14/IEC61970/Generation/Production/InflowForecast.py index bde4ca6..0a72050 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/InflowForecast.py +++ b/schemata/CIM14/IEC61970/Generation/Production/InflowForecast.py @@ -20,15 +20,22 @@ class InflowForecast(RegularIntervalSchedule): """Natural water inflow to a reservoir, usually forecasted from predicted rain and snowmelt. Typically in one hour increments for up to 10 days. The forecast is given in average cubic meters per second over the time increment. """ - def __init__(self, Reservoir=None, **kw_args): - """Initializes a new 'InflowForecast' instance. + def __init__(self, Reservoir=None, *args, **kw_args): + """Initialises a new 'InflowForecast' instance. @param Reservoir: A reservoir may have a 'natural' inflow forecast. """ self._Reservoir = None self.Reservoir = Reservoir - super(InflowForecast, self).__init__(**kw_args) + super(InflowForecast, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Reservoir"] + _many_refs = [] def getReservoir(self): """A reservoir may have a 'natural' inflow forecast. diff --git a/schemata/CIM14/IEC61970/Generation/Production/LevelVsVolumeCurve.py b/schemata/CIM14/IEC61970/Generation/Production/LevelVsVolumeCurve.py index 7d9e70d..b5bc5be 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/LevelVsVolumeCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/LevelVsVolumeCurve.py @@ -20,15 +20,22 @@ class LevelVsVolumeCurve(Curve): """Relationship between reservoir volume and reservoir level. The volume is at the y-axis and the reservoir level at the x-axis. """ - def __init__(self, Reservoir=None, **kw_args): - """Initializes a new 'LevelVsVolumeCurve' instance. + def __init__(self, Reservoir=None, *args, **kw_args): + """Initialises a new 'LevelVsVolumeCurve' instance. @param Reservoir: A reservoir may have a level versus volume relationship. """ self._Reservoir = None self.Reservoir = Reservoir - super(LevelVsVolumeCurve, self).__init__(**kw_args) + super(LevelVsVolumeCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Reservoir"] + _many_refs = [] def getReservoir(self): """A reservoir may have a level versus volume relationship. diff --git a/schemata/CIM14/IEC61970/Generation/Production/NuclearGeneratingUnit.py b/schemata/CIM14/IEC61970/Generation/Production/NuclearGeneratingUnit.py index 4b03cc9..8bc33fb 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/NuclearGeneratingUnit.py +++ b/schemata/CIM14/IEC61970/Generation/Production/NuclearGeneratingUnit.py @@ -20,9 +20,16 @@ class NuclearGeneratingUnit(GeneratingUnit): """A nuclear generating unit. """ - def __init__(self, **kw_args): - """Initializes a new 'NuclearGeneratingUnit' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'NuclearGeneratingUnit' instance. """ - super(NuclearGeneratingUnit, self).__init__(**kw_args) + super(NuclearGeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Generation/Production/PenstockLossCurve.py b/schemata/CIM14/IEC61970/Generation/Production/PenstockLossCurve.py index d80aad2..528fa30 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/PenstockLossCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/PenstockLossCurve.py @@ -20,15 +20,22 @@ class PenstockLossCurve(Curve): """Relationship between penstock head loss (in meters) and total discharge through the penstock (in cubic meters per second). One or more turbines may be connected to the same penstock. """ - def __init__(self, HydroGeneratingUnit=None, **kw_args): - """Initializes a new 'PenstockLossCurve' instance. + def __init__(self, HydroGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'PenstockLossCurve' instance. @param HydroGeneratingUnit: A hydro generating unit has a penstock loss curve """ self._HydroGeneratingUnit = None self.HydroGeneratingUnit = HydroGeneratingUnit - super(PenstockLossCurve, self).__init__(**kw_args) + super(PenstockLossCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["HydroGeneratingUnit"] + _many_refs = [] def getHydroGeneratingUnit(self): """A hydro generating unit has a penstock loss curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/Reservoir.py b/schemata/CIM14/IEC61970/Generation/Production/Reservoir.py index 466f32d..28b8790 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/Reservoir.py +++ b/schemata/CIM14/IEC61970/Generation/Production/Reservoir.py @@ -20,8 +20,8 @@ class Reservoir(PowerSystemResource): """A water storage facility within a hydro system, including: ponds, lakes, lagoons, and rivers. The storage is usually behind some type of dam. """ - def __init__(self, spillWayGateType='', fullSupplyLevel=0.0, spillTravelDelay=0.0, spillwayCrestLength=0.0, grossCapacity=0.0, riverOutletWorks='', spillwayCapacity=0.0, spillwayCrestLevel=0.0, normalMinOperateLevel=0.0, energyStorageRating=0.0, activeStorageCapacity=0.0, LevelVsVolumeCurves=None, InflowForecasts=None, TargetLevelSchedule=None, HydroPowerPlants=None, UpstreamFromHydroPowerPlants=None, SpillsFromReservoir=None, SpillsIntoReservoirs=None, **kw_args): - """Initializes a new 'Reservoir' instance. + def __init__(self, spillWayGateType="", fullSupplyLevel=0.0, spillTravelDelay=0.0, spillwayCrestLength=0.0, grossCapacity=0.0, riverOutletWorks='', spillwayCapacity=0.0, spillwayCrestLevel=0.0, normalMinOperateLevel=0.0, energyStorageRating=0.0, activeStorageCapacity=0.0, LevelVsVolumeCurves=None, InflowForecasts=None, TargetLevelSchedule=None, HydroPowerPlants=None, UpstreamFromHydroPowerPlants=None, SpillsFromReservoir=None, SpillsIntoReservoirs=None, *args, **kw_args): + """Initialises a new 'Reservoir' instance. @param spillWayGateType: Type of spillway gate, including parameters @param fullSupplyLevel: Full supply level, above which water will spill. This can be the spillway crest level or the top of closed gates. @@ -96,7 +96,14 @@ class Reservoir(PowerSystemResource): self._SpillsIntoReservoirs = [] self.SpillsIntoReservoirs = [] if SpillsIntoReservoirs is None else SpillsIntoReservoirs - super(Reservoir, self).__init__(**kw_args) + super(Reservoir, self).__init__(*args, **kw_args) + + _attrs = ["spillWayGateType", "fullSupplyLevel", "spillTravelDelay", "spillwayCrestLength", "grossCapacity", "riverOutletWorks", "spillwayCapacity", "spillwayCrestLevel", "normalMinOperateLevel", "energyStorageRating", "activeStorageCapacity"] + _attr_types = {"spillWayGateType": str, "fullSupplyLevel": float, "spillTravelDelay": float, "spillwayCrestLength": float, "grossCapacity": float, "riverOutletWorks": str, "spillwayCapacity": float, "spillwayCrestLevel": float, "normalMinOperateLevel": float, "energyStorageRating": float, "activeStorageCapacity": float} + _defaults = {"spillWayGateType": "", "fullSupplyLevel": 0.0, "spillTravelDelay": 0.0, "spillwayCrestLength": 0.0, "grossCapacity": 0.0, "riverOutletWorks": '', "spillwayCapacity": 0.0, "spillwayCrestLevel": 0.0, "normalMinOperateLevel": 0.0, "energyStorageRating": 0.0, "activeStorageCapacity": 0.0} + _enums = {"spillWayGateType": "SpillwayGateType"} + _refs = ["LevelVsVolumeCurves", "InflowForecasts", "TargetLevelSchedule", "HydroPowerPlants", "UpstreamFromHydroPowerPlants", "SpillsFromReservoir", "SpillsIntoReservoirs"] + _many_refs = ["LevelVsVolumeCurves", "InflowForecasts", "HydroPowerPlants", "UpstreamFromHydroPowerPlants", "SpillsIntoReservoirs"] def getLevelVsVolumeCurves(self): """A reservoir may have a level versus volume relationship. diff --git a/schemata/CIM14/IEC61970/Generation/Production/ShutdownCurve.py b/schemata/CIM14/IEC61970/Generation/Production/ShutdownCurve.py index e04b09f..2e7a19d 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/ShutdownCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/ShutdownCurve.py @@ -20,8 +20,8 @@ class ShutdownCurve(Curve): """Relationship between the rate in gross active power/minute (Y-axis) at which a unit should be shutdown and its present gross MW output (X-axis) """ - def __init__(self, shutdownCost=0.0, shutdownDate='', ThermalGeneratingUnit=None, **kw_args): - """Initializes a new 'ShutdownCurve' instance. + def __init__(self, shutdownCost=0.0, shutdownDate='', ThermalGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'ShutdownCurve' instance. @param shutdownCost: Fixed shutdown cost @param shutdownDate: The date and time of the most recent generating unit shutdown @@ -36,7 +36,14 @@ class ShutdownCurve(Curve): self._ThermalGeneratingUnit = None self.ThermalGeneratingUnit = ThermalGeneratingUnit - super(ShutdownCurve, self).__init__(**kw_args) + super(ShutdownCurve, self).__init__(*args, **kw_args) + + _attrs = ["shutdownCost", "shutdownDate"] + _attr_types = {"shutdownCost": float, "shutdownDate": str} + _defaults = {"shutdownCost": 0.0, "shutdownDate": ''} + _enums = {} + _refs = ["ThermalGeneratingUnit"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have a shutdown curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/StartIgnFuelCurve.py b/schemata/CIM14/IEC61970/Generation/Production/StartIgnFuelCurve.py index ec9713b..902d504 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/StartIgnFuelCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/StartIgnFuelCurve.py @@ -20,19 +20,26 @@ class StartIgnFuelCurve(Curve): """The quantity of ignition fuel (Y-axis) used to restart and repay the auxiliary power consumed versus the number of hours (X-axis) the unit was off line """ - def __init__(self, ignitionFuelType='lignite', StartupModel=None, **kw_args): - """Initializes a new 'StartIgnFuelCurve' instance. + def __init__(self, ignitionFuelType="lignite", StartupModel=None, *args, **kw_args): + """Initialises a new 'StartIgnFuelCurve' instance. @param ignitionFuelType: Type of ignition fuel Values are: "lignite", "coal", "oil", "gas" @param StartupModel: The unit's startup model may have a startup ignition fuel curve """ - #: Type of ignition fuelValues are: "lignite", "coal", "oil", "gas" + #: Type of ignition fuel Values are: "lignite", "coal", "oil", "gas" self.ignitionFuelType = ignitionFuelType self._StartupModel = None self.StartupModel = StartupModel - super(StartIgnFuelCurve, self).__init__(**kw_args) + super(StartIgnFuelCurve, self).__init__(*args, **kw_args) + + _attrs = ["ignitionFuelType"] + _attr_types = {"ignitionFuelType": str} + _defaults = {"ignitionFuelType": "lignite"} + _enums = {"ignitionFuelType": "FuelType"} + _refs = ["StartupModel"] + _many_refs = [] def getStartupModel(self): """The unit's startup model may have a startup ignition fuel curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/StartMainFuelCurve.py b/schemata/CIM14/IEC61970/Generation/Production/StartMainFuelCurve.py index 5cbb0a2..409b360 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/StartMainFuelCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/StartMainFuelCurve.py @@ -20,19 +20,26 @@ class StartMainFuelCurve(Curve): """The quantity of main fuel (Y-axis) used to restart and repay the auxiliary power consumed versus the number of hours (X-axis) the unit was off line """ - def __init__(self, mainFuelType='lignite', StartupModel=None, **kw_args): - """Initializes a new 'StartMainFuelCurve' instance. + def __init__(self, mainFuelType="lignite", StartupModel=None, *args, **kw_args): + """Initialises a new 'StartMainFuelCurve' instance. @param mainFuelType: Type of main fuel Values are: "lignite", "coal", "oil", "gas" @param StartupModel: The unit's startup model may have a startup main fuel curve """ - #: Type of main fuelValues are: "lignite", "coal", "oil", "gas" + #: Type of main fuel Values are: "lignite", "coal", "oil", "gas" self.mainFuelType = mainFuelType self._StartupModel = None self.StartupModel = StartupModel - super(StartMainFuelCurve, self).__init__(**kw_args) + super(StartMainFuelCurve, self).__init__(*args, **kw_args) + + _attrs = ["mainFuelType"] + _attr_types = {"mainFuelType": str} + _defaults = {"mainFuelType": "lignite"} + _enums = {"mainFuelType": "FuelType"} + _refs = ["StartupModel"] + _many_refs = [] def getStartupModel(self): """The unit's startup model may have a startup main fuel curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/StartRampCurve.py b/schemata/CIM14/IEC61970/Generation/Production/StartRampCurve.py index a5cd352..e397808 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/StartRampCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/StartRampCurve.py @@ -20,8 +20,8 @@ class StartRampCurve(Curve): """Rate in gross active power/minute (Y-axis) at which a unit can be loaded versus the number of hours (X-axis) the unit was off line """ - def __init__(self, hotStandbyRamp=0.0, StartupModel=None, **kw_args): - """Initializes a new 'StartRampCurve' instance. + def __init__(self, hotStandbyRamp=0.0, StartupModel=None, *args, **kw_args): + """Initialises a new 'StartRampCurve' instance. @param hotStandbyRamp: The startup ramp rate in gross for a unit that is on hot standby @param StartupModel: The unit's startup model may have a startup ramp curve @@ -32,7 +32,14 @@ class StartRampCurve(Curve): self._StartupModel = None self.StartupModel = StartupModel - super(StartRampCurve, self).__init__(**kw_args) + super(StartRampCurve, self).__init__(*args, **kw_args) + + _attrs = ["hotStandbyRamp"] + _attr_types = {"hotStandbyRamp": float} + _defaults = {"hotStandbyRamp": 0.0} + _enums = {} + _refs = ["StartupModel"] + _many_refs = [] def getStartupModel(self): """The unit's startup model may have a startup ramp curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/StartupModel.py b/schemata/CIM14/IEC61970/Generation/Production/StartupModel.py index e999052..073e596 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/StartupModel.py +++ b/schemata/CIM14/IEC61970/Generation/Production/StartupModel.py @@ -20,8 +20,8 @@ class StartupModel(IdentifiedObject): """Unit start up characteristics depending on how long the unit has been off line """ - def __init__(self, stbyAuxP=0.0, incrementalMaintCost=0.0, hotStandbyHeat=0.0, startupPriority=0, fixedMaintCost=0.0, startupDate='', minimumRunTime=0.0, startupCost=0.0, riskFactorCost=0.0, minimumDownTime=0.0, ThermalGeneratingUnit=None, StartRampCurve=None, StartMainFuelCurve=None, StartIgnFuelCurve=None, **kw_args): - """Initializes a new 'StartupModel' instance. + def __init__(self, stbyAuxP=0.0, incrementalMaintCost=0.0, hotStandbyHeat=0.0, startupPriority=0, fixedMaintCost=0.0, startupDate='', minimumRunTime=0.0, startupCost=0.0, riskFactorCost=0.0, minimumDownTime=0.0, ThermalGeneratingUnit=None, StartRampCurve=None, StartMainFuelCurve=None, StartIgnFuelCurve=None, *args, **kw_args): + """Initialises a new 'StartupModel' instance. @param stbyAuxP: The unit's auxiliary active power consumption to maintain standby mode @param incrementalMaintCost: Incremental Maintenance Cost @@ -80,7 +80,14 @@ class StartupModel(IdentifiedObject): self._StartIgnFuelCurve = None self.StartIgnFuelCurve = StartIgnFuelCurve - super(StartupModel, self).__init__(**kw_args) + super(StartupModel, self).__init__(*args, **kw_args) + + _attrs = ["stbyAuxP", "incrementalMaintCost", "hotStandbyHeat", "startupPriority", "fixedMaintCost", "startupDate", "minimumRunTime", "startupCost", "riskFactorCost", "minimumDownTime"] + _attr_types = {"stbyAuxP": float, "incrementalMaintCost": float, "hotStandbyHeat": float, "startupPriority": int, "fixedMaintCost": float, "startupDate": str, "minimumRunTime": float, "startupCost": float, "riskFactorCost": float, "minimumDownTime": float} + _defaults = {"stbyAuxP": 0.0, "incrementalMaintCost": 0.0, "hotStandbyHeat": 0.0, "startupPriority": 0, "fixedMaintCost": 0.0, "startupDate": '', "minimumRunTime": 0.0, "startupCost": 0.0, "riskFactorCost": 0.0, "minimumDownTime": 0.0} + _enums = {} + _refs = ["ThermalGeneratingUnit", "StartRampCurve", "StartMainFuelCurve", "StartIgnFuelCurve"] + _many_refs = [] def getThermalGeneratingUnit(self): """A thermal generating unit may have a startup model diff --git a/schemata/CIM14/IEC61970/Generation/Production/SteamSendoutSchedule.py b/schemata/CIM14/IEC61970/Generation/Production/SteamSendoutSchedule.py index 32066e0..cb9f9e4 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/SteamSendoutSchedule.py +++ b/schemata/CIM14/IEC61970/Generation/Production/SteamSendoutSchedule.py @@ -20,15 +20,22 @@ class SteamSendoutSchedule(RegularIntervalSchedule): """The cogeneration plant's steam sendout schedule in volume per time unit. """ - def __init__(self, CogenerationPlant=None, **kw_args): - """Initializes a new 'SteamSendoutSchedule' instance. + def __init__(self, CogenerationPlant=None, *args, **kw_args): + """Initialises a new 'SteamSendoutSchedule' instance. @param CogenerationPlant: A cogeneration plant has a steam sendout schedule """ self._CogenerationPlant = None self.CogenerationPlant = CogenerationPlant - super(SteamSendoutSchedule, self).__init__(**kw_args) + super(SteamSendoutSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["CogenerationPlant"] + _many_refs = [] def getCogenerationPlant(self): """A cogeneration plant has a steam sendout schedule diff --git a/schemata/CIM14/IEC61970/Generation/Production/TailbayLossCurve.py b/schemata/CIM14/IEC61970/Generation/Production/TailbayLossCurve.py index 10c75e7..53f8e17 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/TailbayLossCurve.py +++ b/schemata/CIM14/IEC61970/Generation/Production/TailbayLossCurve.py @@ -20,15 +20,22 @@ class TailbayLossCurve(Curve): """Relationship between tailbay head loss hight (y-axis) and the total discharge into the power station's tailbay volume per time unit (x-axis) . There could be more than one curve depending on the level of the tailbay reservoir or river level """ - def __init__(self, HydroGeneratingUnit=None, **kw_args): - """Initializes a new 'TailbayLossCurve' instance. + def __init__(self, HydroGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'TailbayLossCurve' instance. @param HydroGeneratingUnit: A hydro generating unit has a tailbay loss curve """ self._HydroGeneratingUnit = None self.HydroGeneratingUnit = HydroGeneratingUnit - super(TailbayLossCurve, self).__init__(**kw_args) + super(TailbayLossCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["HydroGeneratingUnit"] + _many_refs = [] def getHydroGeneratingUnit(self): """A hydro generating unit has a tailbay loss curve diff --git a/schemata/CIM14/IEC61970/Generation/Production/TargetLevelSchedule.py b/schemata/CIM14/IEC61970/Generation/Production/TargetLevelSchedule.py index bb0cf8a..b0b914c 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/TargetLevelSchedule.py +++ b/schemata/CIM14/IEC61970/Generation/Production/TargetLevelSchedule.py @@ -20,8 +20,8 @@ class TargetLevelSchedule(Curve): """Reservoir water level targets from advanced studies or 'rule curves'. Typically in one hour increments for up to 10 days """ - def __init__(self, highLevelLimit=0.0, lowLevelLimit=0.0, Reservoir=None, **kw_args): - """Initializes a new 'TargetLevelSchedule' instance. + def __init__(self, highLevelLimit=0.0, lowLevelLimit=0.0, Reservoir=None, *args, **kw_args): + """Initialises a new 'TargetLevelSchedule' instance. @param highLevelLimit: High target level limit, above which the reservoir operation will be penalized @param lowLevelLimit: Low target level limit, below which the reservoir operation will be penalized @@ -36,7 +36,14 @@ class TargetLevelSchedule(Curve): self._Reservoir = None self.Reservoir = Reservoir - super(TargetLevelSchedule, self).__init__(**kw_args) + super(TargetLevelSchedule, self).__init__(*args, **kw_args) + + _attrs = ["highLevelLimit", "lowLevelLimit"] + _attr_types = {"highLevelLimit": float, "lowLevelLimit": float} + _defaults = {"highLevelLimit": 0.0, "lowLevelLimit": 0.0} + _enums = {} + _refs = ["Reservoir"] + _many_refs = [] def getReservoir(self): """A reservoir may have a water level target schedule. diff --git a/schemata/CIM14/IEC61970/Generation/Production/ThermalGeneratingUnit.py b/schemata/CIM14/IEC61970/Generation/Production/ThermalGeneratingUnit.py index e8aa4f1..e92d581 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/ThermalGeneratingUnit.py +++ b/schemata/CIM14/IEC61970/Generation/Production/ThermalGeneratingUnit.py @@ -20,8 +20,8 @@ class ThermalGeneratingUnit(GeneratingUnit): """A generating unit whose prime mover could be a steam turbine, combustion turbine, or diesel engine. """ - def __init__(self, oMCost=0.0, StartupModel=None, EmmissionAccounts=None, CombinedCyclePlant=None, CogenerationPlant=None, EmissionCurves=None, HeatRateCurve=None, ShutdownCurve=None, IncrementalHeatRateCurve=None, FuelAllocationSchedules=None, FossilFuels=None, HeatInputCurve=None, CAESPlant=None, **kw_args): - """Initializes a new 'ThermalGeneratingUnit' instance. + def __init__(self, oMCost=0.0, StartupModel=None, EmmissionAccounts=None, CombinedCyclePlant=None, CogenerationPlant=None, EmissionCurves=None, HeatRateCurve=None, ShutdownCurve=None, IncrementalHeatRateCurve=None, FuelAllocationSchedules=None, FossilFuels=None, HeatInputCurve=None, CAESPlant=None, *args, **kw_args): + """Initialises a new 'ThermalGeneratingUnit' instance. @param oMCost: Operating and maintenance cost for the thermal unit @param StartupModel: A thermal generating unit may have a startup model @@ -76,7 +76,14 @@ class ThermalGeneratingUnit(GeneratingUnit): self._CAESPlant = None self.CAESPlant = CAESPlant - super(ThermalGeneratingUnit, self).__init__(**kw_args) + super(ThermalGeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = ["oMCost"] + _attr_types = {"oMCost": float} + _defaults = {"oMCost": 0.0} + _enums = {} + _refs = ["StartupModel", "EmmissionAccounts", "CombinedCyclePlant", "CogenerationPlant", "EmissionCurves", "HeatRateCurve", "ShutdownCurve", "IncrementalHeatRateCurve", "FuelAllocationSchedules", "FossilFuels", "HeatInputCurve", "CAESPlant"] + _many_refs = ["EmmissionAccounts", "EmissionCurves", "FuelAllocationSchedules", "FossilFuels"] def getStartupModel(self): """A thermal generating unit may have a startup model diff --git a/schemata/CIM14/IEC61970/Generation/Production/WindGeneratingUnit.py b/schemata/CIM14/IEC61970/Generation/Production/WindGeneratingUnit.py index 325605a..cc14d02 100644 --- a/schemata/CIM14/IEC61970/Generation/Production/WindGeneratingUnit.py +++ b/schemata/CIM14/IEC61970/Generation/Production/WindGeneratingUnit.py @@ -20,9 +20,16 @@ class WindGeneratingUnit(GeneratingUnit): """A wind driven generating unit. """ - def __init__(self, **kw_args): - """Initializes a new 'WindGeneratingUnit' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'WindGeneratingUnit' instance. """ - super(WindGeneratingUnit, self).__init__(**kw_args) + super(WindGeneratingUnit, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/IEC61970CIMVersion.py b/schemata/CIM14/IEC61970/IEC61970CIMVersion.py index 5a022f7..3f42409 100644 --- a/schemata/CIM14/IEC61970/IEC61970CIMVersion.py +++ b/schemata/CIM14/IEC61970/IEC61970CIMVersion.py @@ -20,8 +20,8 @@ class IEC61970CIMVersion(Element): """This is the IEC 61970 CIM version number assigned to this UML model file. """ - def __init__(self, version='', date='', **kw_args): - """Initializes a new 'IEC61970CIMVersion' instance. + def __init__(self, version='', date='', *args, **kw_args): + """Initialises a new 'IEC61970CIMVersion' instance. @param version: Form is IEC61970CIMXXvYY where XX is the major CIM package version and the YY is the minor version. For ecample IEC61970CIM13v18. @param date: Form is YYYY-MM-DD for example for January 5, 2009 it is 2009-01-05. @@ -32,5 +32,12 @@ class IEC61970CIMVersion(Element): #: Form is YYYY-MM-DD for example for January 5, 2009 it is 2009-01-05. self.date = date - super(IEC61970CIMVersion, self).__init__(**kw_args) + super(IEC61970CIMVersion, self).__init__(*args, **kw_args) + + _attrs = ["version", "date"] + _attr_types = {"version": str, "date": str} + _defaults = {"version": '', "date": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthority.py b/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthority.py index f7d0b3f..11c8851 100644 --- a/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthority.py +++ b/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthority.py @@ -20,15 +20,22 @@ class ModelingAuthority(IdentifiedObject): """A Modeling Authority is an entity responsible for supplying and maintaining the data defining a specific set of objects in a network model. """ - def __init__(self, ModelingAuthoritySets=None, **kw_args): - """Initializes a new 'ModelingAuthority' instance. + def __init__(self, ModelingAuthoritySets=None, *args, **kw_args): + """Initialises a new 'ModelingAuthority' instance. @param ModelingAuthoritySets: A Modeling Authority set supplies and maintains the data for the objects in a Modeling Authority Set. """ self._ModelingAuthoritySets = [] self.ModelingAuthoritySets = [] if ModelingAuthoritySets is None else ModelingAuthoritySets - super(ModelingAuthority, self).__init__(**kw_args) + super(ModelingAuthority, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ModelingAuthoritySets"] + _many_refs = ["ModelingAuthoritySets"] def getModelingAuthoritySets(self): """A Modeling Authority set supplies and maintains the data for the objects in a Modeling Authority Set. diff --git a/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthoritySet.py b/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthoritySet.py index d4029c4..4ef1752 100644 --- a/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthoritySet.py +++ b/schemata/CIM14/IEC61970/Informative/InfCore/ModelingAuthoritySet.py @@ -20,8 +20,8 @@ class ModelingAuthoritySet(IdentifiedObject): """A Modeling Authority Set is a group of objects in a network model where the data is supplied and maintained by the same Modeling Authority. """ - def __init__(self, ModelingAuthority=None, IdentifiedObjects=None, **kw_args): - """Initializes a new 'ModelingAuthoritySet' instance. + def __init__(self, ModelingAuthority=None, IdentifiedObjects=None, *args, **kw_args): + """Initialises a new 'ModelingAuthoritySet' instance. @param ModelingAuthority: A Modeling Authority set supplies and maintains the data for the objects in a Modeling Authority Set. @param IdentifiedObjects: An IdentifiedObject belongs to a Modeling Authority Set for purposes of defining a group of data maintained by the same Modeling Authority. @@ -32,7 +32,14 @@ class ModelingAuthoritySet(IdentifiedObject): self._IdentifiedObjects = [] self.IdentifiedObjects = [] if IdentifiedObjects is None else IdentifiedObjects - super(ModelingAuthoritySet, self).__init__(**kw_args) + super(ModelingAuthoritySet, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ModelingAuthority", "IdentifiedObjects"] + _many_refs = ["IdentifiedObjects"] def getModelingAuthority(self): """A Modeling Authority set supplies and maintains the data for the objects in a Modeling Authority Set. diff --git a/schemata/CIM14/IEC61970/LoadModel/ConformLoad.py b/schemata/CIM14/IEC61970/LoadModel/ConformLoad.py index c671e0c..75014fc 100644 --- a/schemata/CIM14/IEC61970/LoadModel/ConformLoad.py +++ b/schemata/CIM14/IEC61970/LoadModel/ConformLoad.py @@ -20,15 +20,22 @@ class ConformLoad(EnergyConsumer): """ConformLoad represent loads that follow a daily load change pattern where the pattern can be used to scale the load with a system load. """ - def __init__(self, LoadGroup=None, **kw_args): - """Initializes a new 'ConformLoad' instance. + def __init__(self, LoadGroup=None, *args, **kw_args): + """Initialises a new 'ConformLoad' instance. @param LoadGroup: Group of this ConformLoad. """ self._LoadGroup = None self.LoadGroup = LoadGroup - super(ConformLoad, self).__init__(**kw_args) + super(ConformLoad, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["LoadGroup"] + _many_refs = [] def getLoadGroup(self): """Group of this ConformLoad. diff --git a/schemata/CIM14/IEC61970/LoadModel/ConformLoadGroup.py b/schemata/CIM14/IEC61970/LoadModel/ConformLoadGroup.py index 7045ec6..688b50a 100644 --- a/schemata/CIM14/IEC61970/LoadModel/ConformLoadGroup.py +++ b/schemata/CIM14/IEC61970/LoadModel/ConformLoadGroup.py @@ -20,8 +20,8 @@ class ConformLoadGroup(LoadGroup): """A group of loads conforming to an allocation pattern. """ - def __init__(self, ConformLoadSchedules=None, EnergyConsumers=None, **kw_args): - """Initializes a new 'ConformLoadGroup' instance. + def __init__(self, ConformLoadSchedules=None, EnergyConsumers=None, *args, **kw_args): + """Initialises a new 'ConformLoadGroup' instance. @param ConformLoadSchedules: The ConformLoadSchedules in the ConformLoadGroup. @param EnergyConsumers: Conform loads assigned to this ConformLoadGroup. @@ -32,7 +32,14 @@ class ConformLoadGroup(LoadGroup): self._EnergyConsumers = [] self.EnergyConsumers = [] if EnergyConsumers is None else EnergyConsumers - super(ConformLoadGroup, self).__init__(**kw_args) + super(ConformLoadGroup, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ConformLoadSchedules", "EnergyConsumers"] + _many_refs = ["ConformLoadSchedules", "EnergyConsumers"] def getConformLoadSchedules(self): """The ConformLoadSchedules in the ConformLoadGroup. diff --git a/schemata/CIM14/IEC61970/LoadModel/ConformLoadSchedule.py b/schemata/CIM14/IEC61970/LoadModel/ConformLoadSchedule.py index ec16a30..658bbb4 100644 --- a/schemata/CIM14/IEC61970/LoadModel/ConformLoadSchedule.py +++ b/schemata/CIM14/IEC61970/LoadModel/ConformLoadSchedule.py @@ -20,15 +20,22 @@ class ConformLoadSchedule(SeasonDayTypeSchedule): """A curve of load versus time (X-axis) showing the active power values (Y1-axis) and reactive power (Y2-axis) for each unit of the period covered. This curve represents a typical pattern of load over the time period for a given day type and season. """ - def __init__(self, ConformLoadGroup=None, **kw_args): - """Initializes a new 'ConformLoadSchedule' instance. + def __init__(self, ConformLoadGroup=None, *args, **kw_args): + """Initialises a new 'ConformLoadSchedule' instance. @param ConformLoadGroup: The ConformLoadGroup where the ConformLoadSchedule belongs. """ self._ConformLoadGroup = None self.ConformLoadGroup = ConformLoadGroup - super(ConformLoadSchedule, self).__init__(**kw_args) + super(ConformLoadSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ConformLoadGroup"] + _many_refs = [] def getConformLoadGroup(self): """The ConformLoadGroup where the ConformLoadSchedule belongs. diff --git a/schemata/CIM14/IEC61970/LoadModel/DayType.py b/schemata/CIM14/IEC61970/LoadModel/DayType.py index 7a1c3fc..8ec67e1 100644 --- a/schemata/CIM14/IEC61970/LoadModel/DayType.py +++ b/schemata/CIM14/IEC61970/LoadModel/DayType.py @@ -20,15 +20,22 @@ class DayType(IdentifiedObject): """Group of similar days, e.g., Mon/Tue/Wed, Thu/Fri, Sat/Sun, Holiday1, Holiday2 """ - def __init__(self, SeasonDayTypeSchedules=None, **kw_args): - """Initializes a new 'DayType' instance. + def __init__(self, SeasonDayTypeSchedules=None, *args, **kw_args): + """Initialises a new 'DayType' instance. @param SeasonDayTypeSchedules: Schedules that use this DayType. """ self._SeasonDayTypeSchedules = [] self.SeasonDayTypeSchedules = [] if SeasonDayTypeSchedules is None else SeasonDayTypeSchedules - super(DayType, self).__init__(**kw_args) + super(DayType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["SeasonDayTypeSchedules"] + _many_refs = ["SeasonDayTypeSchedules"] def getSeasonDayTypeSchedules(self): """Schedules that use this DayType. diff --git a/schemata/CIM14/IEC61970/LoadModel/EnergyArea.py b/schemata/CIM14/IEC61970/LoadModel/EnergyArea.py index 8b6c81b..4af3a3f 100644 --- a/schemata/CIM14/IEC61970/LoadModel/EnergyArea.py +++ b/schemata/CIM14/IEC61970/LoadModel/EnergyArea.py @@ -20,15 +20,22 @@ class EnergyArea(IdentifiedObject): """The class describes an area having energy production or consumption. The class is the basis for further specialization. """ - def __init__(self, ControlArea=None, **kw_args): - """Initializes a new 'EnergyArea' instance. + def __init__(self, ControlArea=None, *args, **kw_args): + """Initialises a new 'EnergyArea' instance. @param ControlArea: The control area specification that is used for the load forecast. """ self._ControlArea = None self.ControlArea = ControlArea - super(EnergyArea, self).__init__(**kw_args) + super(EnergyArea, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ControlArea"] + _many_refs = [] def getControlArea(self): """The control area specification that is used for the load forecast. diff --git a/schemata/CIM14/IEC61970/LoadModel/LoadArea.py b/schemata/CIM14/IEC61970/LoadModel/LoadArea.py index 4e50ef2..dec2fd8 100644 --- a/schemata/CIM14/IEC61970/LoadModel/LoadArea.py +++ b/schemata/CIM14/IEC61970/LoadModel/LoadArea.py @@ -20,15 +20,22 @@ class LoadArea(EnergyArea): """The class is the root or first level in a hierarchical structure for grouping of loads for the purpose of load flow load scaling. """ - def __init__(self, SubLoadAreas=None, **kw_args): - """Initializes a new 'LoadArea' instance. + def __init__(self, SubLoadAreas=None, *args, **kw_args): + """Initialises a new 'LoadArea' instance. @param SubLoadAreas: The SubLoadAreas in the LoadArea. """ self._SubLoadAreas = [] self.SubLoadAreas = [] if SubLoadAreas is None else SubLoadAreas - super(LoadArea, self).__init__(**kw_args) + super(LoadArea, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["SubLoadAreas"] + _many_refs = ["SubLoadAreas"] def getSubLoadAreas(self): """The SubLoadAreas in the LoadArea. diff --git a/schemata/CIM14/IEC61970/LoadModel/LoadGroup.py b/schemata/CIM14/IEC61970/LoadModel/LoadGroup.py index 196addf..3fe127b 100644 --- a/schemata/CIM14/IEC61970/LoadModel/LoadGroup.py +++ b/schemata/CIM14/IEC61970/LoadModel/LoadGroup.py @@ -20,15 +20,22 @@ class LoadGroup(IdentifiedObject): """The class is the third level in a hierarchical structure for grouping of loads for the purpose of load flow load scaling. """ - def __init__(self, SubLoadArea=None, **kw_args): - """Initializes a new 'LoadGroup' instance. + def __init__(self, SubLoadArea=None, *args, **kw_args): + """Initialises a new 'LoadGroup' instance. @param SubLoadArea: The SubLoadArea where the Loadgroup belongs. """ self._SubLoadArea = None self.SubLoadArea = SubLoadArea - super(LoadGroup, self).__init__(**kw_args) + super(LoadGroup, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["SubLoadArea"] + _many_refs = [] def getSubLoadArea(self): """The SubLoadArea where the Loadgroup belongs. diff --git a/schemata/CIM14/IEC61970/LoadModel/LoadResponseCharacteristic.py b/schemata/CIM14/IEC61970/LoadModel/LoadResponseCharacteristic.py index 41794bd..3d46cde 100644 --- a/schemata/CIM14/IEC61970/LoadModel/LoadResponseCharacteristic.py +++ b/schemata/CIM14/IEC61970/LoadModel/LoadResponseCharacteristic.py @@ -20,8 +20,8 @@ class LoadResponseCharacteristic(IdentifiedObject): """Models the characteristic response of the load demand due to to changes in system conditions such as voltage and frequency. This is not related to demand response. If LoadResponseCharacteristic.exponentModel is True, the voltage exponents are specified and used as to calculate: Active power component = Pnominal * (Voltage/cim:BaseVoltage.nominalVoltage) ** cim:LoadResponseCharacteristic.pVoltageExponent Reactive power component = Qnominal * (Voltage/cim:BaseVoltage.nominalVoltage)** cim:LoadResponseCharacteristic.qVoltageExponent Where * means 'multiply' and ** is 'raised to power of'. """ - def __init__(self, pFrequencyExponent=0.0, qFrequencyExponent=0.0, pConstantPower=0.0, pConstantCurrent=0.0, pVoltageExponent=0.0, pConstantImpedance=0.0, qConstantImpedance=0.0, qConstantPower=0.0, qVoltageExponent=0.0, exponentModel=False, qConstantCurrent=0.0, EnergyConsumer=None, **kw_args): - """Initializes a new 'LoadResponseCharacteristic' instance. + def __init__(self, pFrequencyExponent=0.0, qFrequencyExponent=0.0, pConstantPower=0.0, pConstantCurrent=0.0, pVoltageExponent=0.0, pConstantImpedance=0.0, qConstantImpedance=0.0, qConstantPower=0.0, qVoltageExponent=0.0, exponentModel=False, qConstantCurrent=0.0, EnergyConsumer=None, *args, **kw_args): + """Initialises a new 'LoadResponseCharacteristic' instance. @param pFrequencyExponent: Exponent of per unit frequency effecting active power @param qFrequencyExponent: Exponent of per unit frequency effecting reactive power @@ -72,7 +72,14 @@ class LoadResponseCharacteristic(IdentifiedObject): self._EnergyConsumer = [] self.EnergyConsumer = [] if EnergyConsumer is None else EnergyConsumer - super(LoadResponseCharacteristic, self).__init__(**kw_args) + super(LoadResponseCharacteristic, self).__init__(*args, **kw_args) + + _attrs = ["pFrequencyExponent", "qFrequencyExponent", "pConstantPower", "pConstantCurrent", "pVoltageExponent", "pConstantImpedance", "qConstantImpedance", "qConstantPower", "qVoltageExponent", "exponentModel", "qConstantCurrent"] + _attr_types = {"pFrequencyExponent": float, "qFrequencyExponent": float, "pConstantPower": float, "pConstantCurrent": float, "pVoltageExponent": float, "pConstantImpedance": float, "qConstantImpedance": float, "qConstantPower": float, "qVoltageExponent": float, "exponentModel": bool, "qConstantCurrent": float} + _defaults = {"pFrequencyExponent": 0.0, "qFrequencyExponent": 0.0, "pConstantPower": 0.0, "pConstantCurrent": 0.0, "pVoltageExponent": 0.0, "pConstantImpedance": 0.0, "qConstantImpedance": 0.0, "qConstantPower": 0.0, "qVoltageExponent": 0.0, "exponentModel": False, "qConstantCurrent": 0.0} + _enums = {} + _refs = ["EnergyConsumer"] + _many_refs = ["EnergyConsumer"] def getEnergyConsumer(self): """The set of loads that have the response characteristics. diff --git a/schemata/CIM14/IEC61970/LoadModel/NonConformLoad.py b/schemata/CIM14/IEC61970/LoadModel/NonConformLoad.py index f4d7a43..bf19f5d 100644 --- a/schemata/CIM14/IEC61970/LoadModel/NonConformLoad.py +++ b/schemata/CIM14/IEC61970/LoadModel/NonConformLoad.py @@ -20,15 +20,22 @@ class NonConformLoad(EnergyConsumer): """NonConformLoad represent loads that do not follow a daily load change pattern and changes are not correlated with the daily load change pattern. """ - def __init__(self, LoadGroup=None, **kw_args): - """Initializes a new 'NonConformLoad' instance. + def __init__(self, LoadGroup=None, *args, **kw_args): + """Initialises a new 'NonConformLoad' instance. @param LoadGroup: Group of this ConformLoad. """ self._LoadGroup = None self.LoadGroup = LoadGroup - super(NonConformLoad, self).__init__(**kw_args) + super(NonConformLoad, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["LoadGroup"] + _many_refs = [] def getLoadGroup(self): """Group of this ConformLoad. diff --git a/schemata/CIM14/IEC61970/LoadModel/NonConformLoadGroup.py b/schemata/CIM14/IEC61970/LoadModel/NonConformLoadGroup.py index 05f79f1..1d8a346 100644 --- a/schemata/CIM14/IEC61970/LoadModel/NonConformLoadGroup.py +++ b/schemata/CIM14/IEC61970/LoadModel/NonConformLoadGroup.py @@ -20,8 +20,8 @@ class NonConformLoadGroup(LoadGroup): """Loads that do not follow a daily and seasonal load variation pattern. """ - def __init__(self, EnergyConsumers=None, NonConformLoadSchedules=None, **kw_args): - """Initializes a new 'NonConformLoadGroup' instance. + def __init__(self, EnergyConsumers=None, NonConformLoadSchedules=None, *args, **kw_args): + """Initialises a new 'NonConformLoadGroup' instance. @param EnergyConsumers: Conform loads assigned to this ConformLoadGroup. @param NonConformLoadSchedules: The NonConformLoadSchedules in the NonConformLoadGroup. @@ -32,7 +32,14 @@ class NonConformLoadGroup(LoadGroup): self._NonConformLoadSchedules = [] self.NonConformLoadSchedules = [] if NonConformLoadSchedules is None else NonConformLoadSchedules - super(NonConformLoadGroup, self).__init__(**kw_args) + super(NonConformLoadGroup, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["EnergyConsumers", "NonConformLoadSchedules"] + _many_refs = ["EnergyConsumers", "NonConformLoadSchedules"] def getEnergyConsumers(self): """Conform loads assigned to this ConformLoadGroup. diff --git a/schemata/CIM14/IEC61970/LoadModel/NonConformLoadSchedule.py b/schemata/CIM14/IEC61970/LoadModel/NonConformLoadSchedule.py index 53dd6cc..de9479a 100644 --- a/schemata/CIM14/IEC61970/LoadModel/NonConformLoadSchedule.py +++ b/schemata/CIM14/IEC61970/LoadModel/NonConformLoadSchedule.py @@ -20,15 +20,22 @@ class NonConformLoadSchedule(SeasonDayTypeSchedule): """An active power (Y1-axis) and reactive power (Y2-axis) schedule (curves) versus time (X-axis) for non-conforming loads, e.g., large industrial load or power station service (where modeled) """ - def __init__(self, NonConformLoadGroup=None, **kw_args): - """Initializes a new 'NonConformLoadSchedule' instance. + def __init__(self, NonConformLoadGroup=None, *args, **kw_args): + """Initialises a new 'NonConformLoadSchedule' instance. @param NonConformLoadGroup: The NonConformLoadGroup where the NonConformLoadSchedule belongs. """ self._NonConformLoadGroup = None self.NonConformLoadGroup = NonConformLoadGroup - super(NonConformLoadSchedule, self).__init__(**kw_args) + super(NonConformLoadSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["NonConformLoadGroup"] + _many_refs = [] def getNonConformLoadGroup(self): """The NonConformLoadGroup where the NonConformLoadSchedule belongs. diff --git a/schemata/CIM14/IEC61970/LoadModel/PowerCutZone.py b/schemata/CIM14/IEC61970/LoadModel/PowerCutZone.py index 003d6df..228d6ee 100644 --- a/schemata/CIM14/IEC61970/LoadModel/PowerCutZone.py +++ b/schemata/CIM14/IEC61970/LoadModel/PowerCutZone.py @@ -20,8 +20,8 @@ class PowerCutZone(PowerSystemResource): """An area or zone of the power system which is used for load shedding purposes. """ - def __init__(self, cutLevel1=0.0, cutLevel2=0.0, EnergyConsumers=None, **kw_args): - """Initializes a new 'PowerCutZone' instance. + def __init__(self, cutLevel1=0.0, cutLevel2=0.0, EnergyConsumers=None, *args, **kw_args): + """Initialises a new 'PowerCutZone' instance. @param cutLevel1: First level (amount) of load to cut as a percentage of total zone load @param cutLevel2: Second level (amount) of load to cut as a percentage of total zone load @@ -36,7 +36,14 @@ class PowerCutZone(PowerSystemResource): self._EnergyConsumers = [] self.EnergyConsumers = [] if EnergyConsumers is None else EnergyConsumers - super(PowerCutZone, self).__init__(**kw_args) + super(PowerCutZone, self).__init__(*args, **kw_args) + + _attrs = ["cutLevel1", "cutLevel2"] + _attr_types = {"cutLevel1": float, "cutLevel2": float} + _defaults = {"cutLevel1": 0.0, "cutLevel2": 0.0} + _enums = {} + _refs = ["EnergyConsumers"] + _many_refs = ["EnergyConsumers"] def getEnergyConsumers(self): """An energy consumer is assigned to a power cut zone diff --git a/schemata/CIM14/IEC61970/LoadModel/Season.py b/schemata/CIM14/IEC61970/LoadModel/Season.py index f0e4f50..d56189f 100644 --- a/schemata/CIM14/IEC61970/LoadModel/Season.py +++ b/schemata/CIM14/IEC61970/LoadModel/Season.py @@ -20,15 +20,15 @@ class Season(Element): """A specified time period of the year, e.g., Spring, Summer, Fall, Winter """ - def __init__(self, name='fall', startDate='', endDate='', SeasonDayTypeSchedules=None, **kw_args): - """Initializes a new 'Season' instance. + def __init__(self, name="fall", startDate='', endDate='', SeasonDayTypeSchedules=None, *args, **kw_args): + """Initialises a new 'Season' instance. @param name: Name of the Season Values are: "fall", "winter", "summer", "spring" @param startDate: Date season starts @param endDate: Date season ends @param SeasonDayTypeSchedules: Schedules that use this Season. """ - #: Name of the SeasonValues are: "fall", "winter", "summer", "spring" + #: Name of the Season Values are: "fall", "winter", "summer", "spring" self.name = name #: Date season starts @@ -40,7 +40,14 @@ class Season(Element): self._SeasonDayTypeSchedules = [] self.SeasonDayTypeSchedules = [] if SeasonDayTypeSchedules is None else SeasonDayTypeSchedules - super(Season, self).__init__(**kw_args) + super(Season, self).__init__(*args, **kw_args) + + _attrs = ["name", "startDate", "endDate"] + _attr_types = {"name": str, "startDate": str, "endDate": str} + _defaults = {"name": "fall", "startDate": '', "endDate": ''} + _enums = {"name": "SeasonName"} + _refs = ["SeasonDayTypeSchedules"] + _many_refs = ["SeasonDayTypeSchedules"] def getSeasonDayTypeSchedules(self): """Schedules that use this Season. diff --git a/schemata/CIM14/IEC61970/LoadModel/SeasonDayTypeSchedule.py b/schemata/CIM14/IEC61970/LoadModel/SeasonDayTypeSchedule.py index c27f2fd..b9f4f0c 100644 --- a/schemata/CIM14/IEC61970/LoadModel/SeasonDayTypeSchedule.py +++ b/schemata/CIM14/IEC61970/LoadModel/SeasonDayTypeSchedule.py @@ -20,8 +20,8 @@ class SeasonDayTypeSchedule(RegularIntervalSchedule): """The schedule specialize RegularIntervalSchedule with type curve data for a specific type of day and season. This means that curves of this type cover a 24 hour period. """ - def __init__(self, Season=None, DayType=None, **kw_args): - """Initializes a new 'SeasonDayTypeSchedule' instance. + def __init__(self, Season=None, DayType=None, *args, **kw_args): + """Initialises a new 'SeasonDayTypeSchedule' instance. @param Season: Season for the Schedule. @param DayType: DayType for the Schedule. @@ -32,7 +32,14 @@ class SeasonDayTypeSchedule(RegularIntervalSchedule): self._DayType = None self.DayType = DayType - super(SeasonDayTypeSchedule, self).__init__(**kw_args) + super(SeasonDayTypeSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Season", "DayType"] + _many_refs = [] def getSeason(self): """Season for the Schedule. diff --git a/schemata/CIM14/IEC61970/LoadModel/StationSupply.py b/schemata/CIM14/IEC61970/LoadModel/StationSupply.py index a405bfb..277d58e 100644 --- a/schemata/CIM14/IEC61970/LoadModel/StationSupply.py +++ b/schemata/CIM14/IEC61970/LoadModel/StationSupply.py @@ -20,9 +20,16 @@ class StationSupply(EnergyConsumer): """Station supply with load derived from the station output. """ - def __init__(self, **kw_args): - """Initializes a new 'StationSupply' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'StationSupply' instance. """ - super(StationSupply, self).__init__(**kw_args) + super(StationSupply, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/LoadModel/SubLoadArea.py b/schemata/CIM14/IEC61970/LoadModel/SubLoadArea.py index 400c3f2..d5afd20 100644 --- a/schemata/CIM14/IEC61970/LoadModel/SubLoadArea.py +++ b/schemata/CIM14/IEC61970/LoadModel/SubLoadArea.py @@ -20,8 +20,8 @@ class SubLoadArea(EnergyArea): """The class is the second level in a hierarchical structure for grouping of loads for the purpose of load flow load scaling. """ - def __init__(self, LoadGroups=None, LoadArea=None, **kw_args): - """Initializes a new 'SubLoadArea' instance. + def __init__(self, LoadGroups=None, LoadArea=None, *args, **kw_args): + """Initialises a new 'SubLoadArea' instance. @param LoadGroups: The Loadgroups in the SubLoadArea. @param LoadArea: The LoadArea where the SubLoadArea belongs. @@ -32,7 +32,14 @@ class SubLoadArea(EnergyArea): self._LoadArea = None self.LoadArea = LoadArea - super(SubLoadArea, self).__init__(**kw_args) + super(SubLoadArea, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["LoadGroups", "LoadArea"] + _many_refs = ["LoadGroups"] def getLoadGroups(self): """The Loadgroups in the SubLoadArea. diff --git a/schemata/CIM14/IEC61970/Meas/Accumulator.py b/schemata/CIM14/IEC61970/Meas/Accumulator.py index 4a752bd..8dfed58 100644 --- a/schemata/CIM14/IEC61970/Meas/Accumulator.py +++ b/schemata/CIM14/IEC61970/Meas/Accumulator.py @@ -20,8 +20,8 @@ class Accumulator(Measurement): """Accumulator represents a accumulated (counted) Measurement, e.g. an energy value. """ - def __init__(self, maxValue=0, LimitSets=None, AccumulatorValues=None, **kw_args): - """Initializes a new 'Accumulator' instance. + def __init__(self, maxValue=0, LimitSets=None, AccumulatorValues=None, *args, **kw_args): + """Initialises a new 'Accumulator' instance. @param maxValue: Normal value range maximum for any of the MeasurementValue.values. Used for scaling, e.g. in bar graphs or of telemetered raw values. @param LimitSets: A measurement may have zero or more limit ranges defined for it. @@ -36,7 +36,14 @@ class Accumulator(Measurement): self._AccumulatorValues = [] self.AccumulatorValues = [] if AccumulatorValues is None else AccumulatorValues - super(Accumulator, self).__init__(**kw_args) + super(Accumulator, self).__init__(*args, **kw_args) + + _attrs = ["maxValue"] + _attr_types = {"maxValue": int} + _defaults = {"maxValue": 0} + _enums = {} + _refs = ["LimitSets", "AccumulatorValues"] + _many_refs = ["LimitSets", "AccumulatorValues"] def getLimitSets(self): """A measurement may have zero or more limit ranges defined for it. diff --git a/schemata/CIM14/IEC61970/Meas/AccumulatorLimit.py b/schemata/CIM14/IEC61970/Meas/AccumulatorLimit.py index ebb966e..8af4cd2 100644 --- a/schemata/CIM14/IEC61970/Meas/AccumulatorLimit.py +++ b/schemata/CIM14/IEC61970/Meas/AccumulatorLimit.py @@ -20,8 +20,8 @@ class AccumulatorLimit(Limit): """Limit values for Accumulator measurements """ - def __init__(self, value=0, LimitSet=None, **kw_args): - """Initializes a new 'AccumulatorLimit' instance. + def __init__(self, value=0, LimitSet=None, *args, **kw_args): + """Initialises a new 'AccumulatorLimit' instance. @param value: The value to supervise against. The value is positive. @param LimitSet: The set of limits. @@ -32,7 +32,14 @@ class AccumulatorLimit(Limit): self._LimitSet = None self.LimitSet = LimitSet - super(AccumulatorLimit, self).__init__(**kw_args) + super(AccumulatorLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": int} + _defaults = {"value": 0} + _enums = {} + _refs = ["LimitSet"] + _many_refs = [] def getLimitSet(self): """The set of limits. diff --git a/schemata/CIM14/IEC61970/Meas/AccumulatorLimitSet.py b/schemata/CIM14/IEC61970/Meas/AccumulatorLimitSet.py index 8e64f43..92ae2ac 100644 --- a/schemata/CIM14/IEC61970/Meas/AccumulatorLimitSet.py +++ b/schemata/CIM14/IEC61970/Meas/AccumulatorLimitSet.py @@ -20,8 +20,8 @@ class AccumulatorLimitSet(LimitSet): """An AccumulatorLimitSet specifies a set of Limits that are associated with an Accumulator measurement. """ - def __init__(self, Measurements=None, Limits=None, **kw_args): - """Initializes a new 'AccumulatorLimitSet' instance. + def __init__(self, Measurements=None, Limits=None, *args, **kw_args): + """Initialises a new 'AccumulatorLimitSet' instance. @param Measurements: The Measurements using the LimitSet. @param Limits: The limit values used for supervision of Measurements. @@ -32,7 +32,14 @@ class AccumulatorLimitSet(LimitSet): self._Limits = [] self.Limits = [] if Limits is None else Limits - super(AccumulatorLimitSet, self).__init__(**kw_args) + super(AccumulatorLimitSet, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Measurements", "Limits"] + _many_refs = ["Measurements", "Limits"] def getMeasurements(self): """The Measurements using the LimitSet. diff --git a/schemata/CIM14/IEC61970/Meas/AccumulatorValue.py b/schemata/CIM14/IEC61970/Meas/AccumulatorValue.py index 08be63f..0392abe 100644 --- a/schemata/CIM14/IEC61970/Meas/AccumulatorValue.py +++ b/schemata/CIM14/IEC61970/Meas/AccumulatorValue.py @@ -20,8 +20,8 @@ class AccumulatorValue(MeasurementValue): """AccumulatorValue represents a accumulated (counted) MeasurementValue. """ - def __init__(self, value=0, Accumulator=None, **kw_args): - """Initializes a new 'AccumulatorValue' instance. + def __init__(self, value=0, Accumulator=None, *args, **kw_args): + """Initialises a new 'AccumulatorValue' instance. @param value: The value to supervise. The value is positive. @param Accumulator: Measurement to which this value is connected. @@ -32,7 +32,14 @@ class AccumulatorValue(MeasurementValue): self._Accumulator = None self.Accumulator = Accumulator - super(AccumulatorValue, self).__init__(**kw_args) + super(AccumulatorValue, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": int} + _defaults = {"value": 0} + _enums = {} + _refs = ["Accumulator"] + _many_refs = [] def getAccumulator(self): """Measurement to which this value is connected. diff --git a/schemata/CIM14/IEC61970/Meas/Analog.py b/schemata/CIM14/IEC61970/Meas/Analog.py index db6635e..a248e99 100644 --- a/schemata/CIM14/IEC61970/Meas/Analog.py +++ b/schemata/CIM14/IEC61970/Meas/Analog.py @@ -20,8 +20,8 @@ class Analog(Measurement): """Analog represents an analog Measurement. """ - def __init__(self, positiveFlowIn=False, minValue=0.0, maxValue=0.0, normalValue=0.0, LimitSets=None, SetPoint=None, AnalogValues=None, **kw_args): - """Initializes a new 'Analog' instance. + def __init__(self, positiveFlowIn=False, minValue=0.0, maxValue=0.0, normalValue=0.0, LimitSets=None, SetPoint=None, AnalogValues=None, *args, **kw_args): + """Initialises a new 'Analog' instance. @param positiveFlowIn: If true then this measurement is an active power, reactive power or current with the convention that a positive value measured at the Terminal means power is flowing into the related PowerSystemResource. @param minValue: Normal value range minimum for any of the MeasurementValue.values. Used for scaling, e.g. in bar graphs or of telemetered raw values @@ -52,7 +52,14 @@ class Analog(Measurement): self._AnalogValues = [] self.AnalogValues = [] if AnalogValues is None else AnalogValues - super(Analog, self).__init__(**kw_args) + super(Analog, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn", "minValue", "maxValue", "normalValue"] + _attr_types = {"positiveFlowIn": bool, "minValue": float, "maxValue": float, "normalValue": float} + _defaults = {"positiveFlowIn": False, "minValue": 0.0, "maxValue": 0.0, "normalValue": 0.0} + _enums = {} + _refs = ["LimitSets", "SetPoint", "AnalogValues"] + _many_refs = ["LimitSets", "AnalogValues"] def getLimitSets(self): """A measurement may have zero or more limit ranges defined for it. diff --git a/schemata/CIM14/IEC61970/Meas/AnalogLimit.py b/schemata/CIM14/IEC61970/Meas/AnalogLimit.py index 9542d99..3a616d0 100644 --- a/schemata/CIM14/IEC61970/Meas/AnalogLimit.py +++ b/schemata/CIM14/IEC61970/Meas/AnalogLimit.py @@ -20,8 +20,8 @@ class AnalogLimit(Limit): """Limit values for Analog measurements """ - def __init__(self, value=0.0, LimitSet=None, **kw_args): - """Initializes a new 'AnalogLimit' instance. + def __init__(self, value=0.0, LimitSet=None, *args, **kw_args): + """Initialises a new 'AnalogLimit' instance. @param value: The value to supervise against. @param LimitSet: The set of limits. @@ -32,7 +32,14 @@ class AnalogLimit(Limit): self._LimitSet = None self.LimitSet = LimitSet - super(AnalogLimit, self).__init__(**kw_args) + super(AnalogLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["LimitSet"] + _many_refs = [] def getLimitSet(self): """The set of limits. diff --git a/schemata/CIM14/IEC61970/Meas/AnalogLimitSet.py b/schemata/CIM14/IEC61970/Meas/AnalogLimitSet.py index 0554102..05ac034 100644 --- a/schemata/CIM14/IEC61970/Meas/AnalogLimitSet.py +++ b/schemata/CIM14/IEC61970/Meas/AnalogLimitSet.py @@ -20,8 +20,8 @@ class AnalogLimitSet(LimitSet): """An AnalogLimitSet specifies a set of Limits that are associated with an Analog measurement. """ - def __init__(self, Measurements=None, Limits=None, **kw_args): - """Initializes a new 'AnalogLimitSet' instance. + def __init__(self, Measurements=None, Limits=None, *args, **kw_args): + """Initialises a new 'AnalogLimitSet' instance. @param Measurements: The Measurements using the LimitSet. @param Limits: The limit values used for supervision of Measurements. @@ -32,7 +32,14 @@ class AnalogLimitSet(LimitSet): self._Limits = [] self.Limits = [] if Limits is None else Limits - super(AnalogLimitSet, self).__init__(**kw_args) + super(AnalogLimitSet, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Measurements", "Limits"] + _many_refs = ["Measurements", "Limits"] def getMeasurements(self): """The Measurements using the LimitSet. diff --git a/schemata/CIM14/IEC61970/Meas/AnalogValue.py b/schemata/CIM14/IEC61970/Meas/AnalogValue.py index 87f314f..8af7947 100644 --- a/schemata/CIM14/IEC61970/Meas/AnalogValue.py +++ b/schemata/CIM14/IEC61970/Meas/AnalogValue.py @@ -20,8 +20,8 @@ class AnalogValue(MeasurementValue): """AnalogValue represents an analog MeasurementValue. """ - def __init__(self, value=0.0, AltTieMeas=None, Analog=None, AltGeneratingUnit=None, **kw_args): - """Initializes a new 'AnalogValue' instance. + def __init__(self, value=0.0, AltTieMeas=None, Analog=None, AltGeneratingUnit=None, *args, **kw_args): + """Initialises a new 'AnalogValue' instance. @param value: The value to supervise. @param AltTieMeas: The usage of the measurement within the control area specification. @@ -40,7 +40,14 @@ class AnalogValue(MeasurementValue): self._AltGeneratingUnit = [] self.AltGeneratingUnit = [] if AltGeneratingUnit is None else AltGeneratingUnit - super(AnalogValue, self).__init__(**kw_args) + super(AnalogValue, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = ["AltTieMeas", "Analog", "AltGeneratingUnit"] + _many_refs = ["AltTieMeas", "AltGeneratingUnit"] def getAltTieMeas(self): """The usage of the measurement within the control area specification. diff --git a/schemata/CIM14/IEC61970/Meas/Command.py b/schemata/CIM14/IEC61970/Meas/Command.py index a0c073b..ab59d10 100644 --- a/schemata/CIM14/IEC61970/Meas/Command.py +++ b/schemata/CIM14/IEC61970/Meas/Command.py @@ -20,8 +20,8 @@ class Command(Control): """A Command is a discrete control used for supervisory control. """ - def __init__(self, value=0, normalValue=0, ValueAliasSet=None, Discrete=None, **kw_args): - """Initializes a new 'Command' instance. + def __init__(self, value=0, normalValue=0, ValueAliasSet=None, Discrete=None, *args, **kw_args): + """Initialises a new 'Command' instance. @param value: The value representing the actuator output @param normalValue: Normal value for Control.value e.g. used for percentage scaling @@ -40,7 +40,14 @@ class Command(Control): self._Discrete = None self.Discrete = Discrete - super(Command, self).__init__(**kw_args) + super(Command, self).__init__(*args, **kw_args) + + _attrs = ["value", "normalValue"] + _attr_types = {"value": int, "normalValue": int} + _defaults = {"value": 0, "normalValue": 0} + _enums = {} + _refs = ["ValueAliasSet", "Discrete"] + _many_refs = [] def getValueAliasSet(self): """The Commands using the set for translation. diff --git a/schemata/CIM14/IEC61970/Meas/Control.py b/schemata/CIM14/IEC61970/Meas/Control.py index c7016b9..132b799 100644 --- a/schemata/CIM14/IEC61970/Meas/Control.py +++ b/schemata/CIM14/IEC61970/Meas/Control.py @@ -20,8 +20,8 @@ class Control(IdentifiedObject): """Control is used for supervisory/device control. It represents control outputs that are used to change the state in a process, e.g. close or open breaker, a set point value or a raise lower command. """ - def __init__(self, timeStamp='', operationInProgress=False, Unit=None, RegulatingCondEq=None, ControlType=None, RemoteControl=None, **kw_args): - """Initializes a new 'Control' instance. + def __init__(self, timeStamp='', operationInProgress=False, Unit=None, RegulatingCondEq=None, ControlType=None, RemoteControl=None, *args, **kw_args): + """Initialises a new 'Control' instance. @param timeStamp: The last time a control output was sent @param operationInProgress: Indicates that a client is currently sending control commands that has not completed @@ -48,7 +48,14 @@ class Control(IdentifiedObject): self._RemoteControl = None self.RemoteControl = RemoteControl - super(Control, self).__init__(**kw_args) + super(Control, self).__init__(*args, **kw_args) + + _attrs = ["timeStamp", "operationInProgress"] + _attr_types = {"timeStamp": str, "operationInProgress": bool} + _defaults = {"timeStamp": '', "operationInProgress": False} + _enums = {} + _refs = ["Unit", "RegulatingCondEq", "ControlType", "RemoteControl"] + _many_refs = [] def getUnit(self): """The Unit for the Control. diff --git a/schemata/CIM14/IEC61970/Meas/ControlType.py b/schemata/CIM14/IEC61970/Meas/ControlType.py index 0c6513b..3bbedf4 100644 --- a/schemata/CIM14/IEC61970/Meas/ControlType.py +++ b/schemata/CIM14/IEC61970/Meas/ControlType.py @@ -20,15 +20,22 @@ class ControlType(IdentifiedObject): """Specifies the type of Control, e.g. BreakerOn/Off, GeneratorVoltageSetPoint, TieLineFlow etc. The ControlType.name shall be unique among all specified types and describe the type. The ControlType.aliasName is meant to be used for localization. """ - def __init__(self, Controls=None, **kw_args): - """Initializes a new 'ControlType' instance. + def __init__(self, Controls=None, *args, **kw_args): + """Initialises a new 'ControlType' instance. @param Controls: The Controls having the ControlType """ self._Controls = [] self.Controls = [] if Controls is None else Controls - super(ControlType, self).__init__(**kw_args) + super(ControlType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Controls"] + _many_refs = ["Controls"] def getControls(self): """The Controls having the ControlType diff --git a/schemata/CIM14/IEC61970/Meas/CurrentTransformer.py b/schemata/CIM14/IEC61970/Meas/CurrentTransformer.py index 4860bed..7ffeee0 100644 --- a/schemata/CIM14/IEC61970/Meas/CurrentTransformer.py +++ b/schemata/CIM14/IEC61970/Meas/CurrentTransformer.py @@ -20,8 +20,8 @@ class CurrentTransformer(Equipment): """Instrument transformer used to measure electrical qualities of the circuit that is being protected and/or monitored. Typically used as current transducer for the purpose of metering or protection. A typical secondary current rating would be 5A. """ - def __init__(self, maxRatio=0.0, accuracyClass='', coreCount=0, ctClass='', usage='', accuracyLimit='', **kw_args): - """Initializes a new 'CurrentTransformer' instance. + def __init__(self, maxRatio=0.0, accuracyClass='', coreCount=0, ctClass='', usage='', accuracyLimit='', *args, **kw_args): + """Initialises a new 'CurrentTransformer' instance. @param maxRatio: For multi-ratio CT's, the maximum permissable ratio attainable. @param accuracyClass: CT accuracy classification. @@ -48,5 +48,12 @@ class CurrentTransformer(Equipment): #: Percent of rated current for which the CT remains accurate within specified limits. self.accuracyLimit = accuracyLimit - super(CurrentTransformer, self).__init__(**kw_args) + super(CurrentTransformer, self).__init__(*args, **kw_args) + + _attrs = ["maxRatio", "accuracyClass", "coreCount", "ctClass", "usage", "accuracyLimit"] + _attr_types = {"maxRatio": float, "accuracyClass": str, "coreCount": int, "ctClass": str, "usage": str, "accuracyLimit": str} + _defaults = {"maxRatio": 0.0, "accuracyClass": '', "coreCount": 0, "ctClass": '', "usage": '', "accuracyLimit": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Meas/Discrete.py b/schemata/CIM14/IEC61970/Meas/Discrete.py index ed021fa..3cec98f 100644 --- a/schemata/CIM14/IEC61970/Meas/Discrete.py +++ b/schemata/CIM14/IEC61970/Meas/Discrete.py @@ -20,8 +20,8 @@ class Discrete(Measurement): """Discrete represents a discrete Measurement, i.e. a Measurement reprsenting discrete values, e.g. a Breaker position. """ - def __init__(self, normalValue=0, minValue=0, maxValue=0, Command=None, DiscreteValues=None, ValueAliasSet=None, **kw_args): - """Initializes a new 'Discrete' instance. + def __init__(self, normalValue=0, minValue=0, maxValue=0, Command=None, DiscreteValues=None, ValueAliasSet=None, *args, **kw_args): + """Initialises a new 'Discrete' instance. @param normalValue: Normal measurement value, e.g., used for percentage calculations. @param minValue: Normal value range minimum for any of the MeasurementValue.values. Used for scaling, e.g. in bar graphs or of telemetered raw values @@ -48,7 +48,14 @@ class Discrete(Measurement): self._ValueAliasSet = None self.ValueAliasSet = ValueAliasSet - super(Discrete, self).__init__(**kw_args) + super(Discrete, self).__init__(*args, **kw_args) + + _attrs = ["normalValue", "minValue", "maxValue"] + _attr_types = {"normalValue": int, "minValue": int, "maxValue": int} + _defaults = {"normalValue": 0, "minValue": 0, "maxValue": 0} + _enums = {} + _refs = ["Command", "DiscreteValues", "ValueAliasSet"] + _many_refs = ["DiscreteValues"] def getCommand(self): """The Control variable associated with the Measurement. diff --git a/schemata/CIM14/IEC61970/Meas/DiscreteValue.py b/schemata/CIM14/IEC61970/Meas/DiscreteValue.py index dbe6344..be6f118 100644 --- a/schemata/CIM14/IEC61970/Meas/DiscreteValue.py +++ b/schemata/CIM14/IEC61970/Meas/DiscreteValue.py @@ -20,8 +20,8 @@ class DiscreteValue(MeasurementValue): """DiscreteValue represents a discrete MeasurementValue. """ - def __init__(self, value=0, Discrete=None, **kw_args): - """Initializes a new 'DiscreteValue' instance. + def __init__(self, value=0, Discrete=None, *args, **kw_args): + """Initialises a new 'DiscreteValue' instance. @param value: The value to supervise. @param Discrete: Measurement to which this value is connected. @@ -32,7 +32,14 @@ class DiscreteValue(MeasurementValue): self._Discrete = None self.Discrete = Discrete - super(DiscreteValue, self).__init__(**kw_args) + super(DiscreteValue, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": int} + _defaults = {"value": 0} + _enums = {} + _refs = ["Discrete"] + _many_refs = [] def getDiscrete(self): """Measurement to which this value is connected. diff --git a/schemata/CIM14/IEC61970/Meas/Limit.py b/schemata/CIM14/IEC61970/Meas/Limit.py index bccd6dc..9777b51 100644 --- a/schemata/CIM14/IEC61970/Meas/Limit.py +++ b/schemata/CIM14/IEC61970/Meas/Limit.py @@ -20,9 +20,16 @@ class Limit(IdentifiedObject): """Specifies one limit value for a Measurement. A Measurement typically has several limits that are kept together by the LimitSet class. The actual meaning and use of a Limit instance (i.e., if it is an alarm or warning limit or if it is a high or low limit) is not captured in the Limit class. However the name of a Limit instance may indicate both meaning and use. """ - def __init__(self, **kw_args): - """Initializes a new 'Limit' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Limit' instance. """ - super(Limit, self).__init__(**kw_args) + super(Limit, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Meas/LimitSet.py b/schemata/CIM14/IEC61970/Meas/LimitSet.py index 6cbdc86..772e016 100644 --- a/schemata/CIM14/IEC61970/Meas/LimitSet.py +++ b/schemata/CIM14/IEC61970/Meas/LimitSet.py @@ -20,13 +20,20 @@ class LimitSet(IdentifiedObject): """Specifies a set of Limits that are associated with a Measurement. A Measurement may have several LimitSets corresponding to seasonal or other changing conditions. The condition is captured in the name and description attributes. The same LimitSet may be used for several Measurements. In particular percentage limits are used this way. """ - def __init__(self, isPercentageLimits=False, **kw_args): - """Initializes a new 'LimitSet' instance. + def __init__(self, isPercentageLimits=False, *args, **kw_args): + """Initialises a new 'LimitSet' instance. @param isPercentageLimits: Tells if the limit values are in percentage of normalValue or the specified Unit for Measurements and Controls. """ #: Tells if the limit values are in percentage of normalValue or the specified Unit for Measurements and Controls. self.isPercentageLimits = isPercentageLimits - super(LimitSet, self).__init__(**kw_args) + super(LimitSet, self).__init__(*args, **kw_args) + + _attrs = ["isPercentageLimits"] + _attr_types = {"isPercentageLimits": bool} + _defaults = {"isPercentageLimits": False} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Meas/Measurement.py b/schemata/CIM14/IEC61970/Meas/Measurement.py index dc37c5f..abfe7a2 100644 --- a/schemata/CIM14/IEC61970/Meas/Measurement.py +++ b/schemata/CIM14/IEC61970/Meas/Measurement.py @@ -20,8 +20,8 @@ class Measurement(IdentifiedObject): """A Measurement represents any measured, calculated or non-measured non-calculated quantity. Any piece of equipment may contain Measurements, e.g. a substation may have temperature measurements and door open indications, a transformer may have oil temperature and tank pressure measurements, a bay may contain a number of power flow measurements and a Breaker may contain a switch status measurement. The PSR - Measurement association is intended to capture this use of Measurement and is included in the naming hierarchy based on EquipmentContainer. The naming hierarchy typically has Measurements as leafs, e.g. Substation-VoltageLevel-Bay-Switch-Measurement. Some Measurements represent quantities related to a particular sensor location in the network, e.g. a voltage transformer (PT) at a busbar or a current transformer (CT) at the bar between a breaker and an isolator. The sensing position is not captured in the PSR - Measurement association. Instead it is captured by the Measurement - Terminal association that is used to define the sensing location in the network topology. The location is defined by the connection of the Terminal to ConductingEquipment. Two possible paths exist: 1) Measurement-Terminal- ConnectivityNode-Terminal-ConductingEquipment 2) Measurement-Terminal-ConductingEquipment Alternative 2 is the only allowed use. When the sensor location is needed both Measurement-PSR and Measurement-Terminal are used. The Measurement-Terminal association is never used alone. """ - def __init__(self, measurementType='', PowerSystemResource=None, Locations=None, Terminal=None, Unit=None, tieToMeasurement0=None, Asset=None, Documents=None, **kw_args): - """Initializes a new 'Measurement' instance. + def __init__(self, measurementType='', PowerSystemResource=None, Locations=None, Terminal=None, Unit=None, tieToMeasurement0=None, Asset=None, Documents=None, *args, **kw_args): + """Initialises a new 'Measurement' instance. @param measurementType: Specifies the type of Measurement, e.g. IndoorTemperature, OutDoorTemperature, BusVoltage, GeneratorVoltage, LineFlow etc. @param PowerSystemResource: The PowerSystemResource that contains the Measurement in the naming hierarchy @@ -56,7 +56,14 @@ class Measurement(IdentifiedObject): self._Documents = [] self.Documents = [] if Documents is None else Documents - super(Measurement, self).__init__(**kw_args) + super(Measurement, self).__init__(*args, **kw_args) + + _attrs = ["measurementType"] + _attr_types = {"measurementType": str} + _defaults = {"measurementType": ''} + _enums = {} + _refs = ["PowerSystemResource", "Locations", "Terminal", "Unit", "tieToMeasurement0", "Asset", "Documents"] + _many_refs = ["Locations", "tieToMeasurement0", "Documents"] def getPowerSystemResource(self): """The PowerSystemResource that contains the Measurement in the naming hierarchy diff --git a/schemata/CIM14/IEC61970/Meas/MeasurementValue.py b/schemata/CIM14/IEC61970/Meas/MeasurementValue.py index 53891d1..0048d49 100644 --- a/schemata/CIM14/IEC61970/Meas/MeasurementValue.py +++ b/schemata/CIM14/IEC61970/Meas/MeasurementValue.py @@ -20,8 +20,8 @@ class MeasurementValue(IdentifiedObject): """The current state for a measurement. A state value is an instance of a measurement from a specific source. Measurements can be associated with many state values, each representing a different source for the measurement. """ - def __init__(self, sensorAccuracy=0.0, timeStamp='', MeasurementValueSource=None, RemoteSource=None, MeasurementValueQuality=None, **kw_args): - """Initializes a new 'MeasurementValue' instance. + def __init__(self, sensorAccuracy=0.0, timeStamp='', MeasurementValueSource=None, RemoteSource=None, MeasurementValueQuality=None, *args, **kw_args): + """Initialises a new 'MeasurementValue' instance. @param sensorAccuracy: The limit, expressed as a percentage of the sensor maximum, that errors will not exceed when the sensor is used under reference conditions. @param timeStamp: The time when the value was last updated @@ -44,7 +44,14 @@ class MeasurementValue(IdentifiedObject): self._MeasurementValueQuality = None self.MeasurementValueQuality = MeasurementValueQuality - super(MeasurementValue, self).__init__(**kw_args) + super(MeasurementValue, self).__init__(*args, **kw_args) + + _attrs = ["sensorAccuracy", "timeStamp"] + _attr_types = {"sensorAccuracy": float, "timeStamp": str} + _defaults = {"sensorAccuracy": 0.0, "timeStamp": ''} + _enums = {} + _refs = ["MeasurementValueSource", "RemoteSource", "MeasurementValueQuality"] + _many_refs = [] def getMeasurementValueSource(self): """A reference to the type of source that updates the MeasurementValue, e.g. SCADA, CCLink, manual, etc. User conventions for the names of sources are contained in the introduction to IEC 61970-301. diff --git a/schemata/CIM14/IEC61970/Meas/MeasurementValueQuality.py b/schemata/CIM14/IEC61970/Meas/MeasurementValueQuality.py index a5b8d29..08185c2 100644 --- a/schemata/CIM14/IEC61970/Meas/MeasurementValueQuality.py +++ b/schemata/CIM14/IEC61970/Meas/MeasurementValueQuality.py @@ -20,15 +20,22 @@ class MeasurementValueQuality(Quality61850): """Measurement quality flags. Bits 0-10 are defined for substation automation in draft IEC 61850 part 7-3. Bits 11-15 are reserved for future expansion by that document. Bits 16-31 are reserved for EMS applications. """ - def __init__(self, MeasurementValue=None, **kw_args): - """Initializes a new 'MeasurementValueQuality' instance. + def __init__(self, MeasurementValue=None, *args, **kw_args): + """Initialises a new 'MeasurementValueQuality' instance. @param MeasurementValue: A MeasurementValue has a MeasurementValueQuality associated with it. """ self._MeasurementValue = None self.MeasurementValue = MeasurementValue - super(MeasurementValueQuality, self).__init__(**kw_args) + super(MeasurementValueQuality, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MeasurementValue"] + _many_refs = [] def getMeasurementValue(self): """A MeasurementValue has a MeasurementValueQuality associated with it. diff --git a/schemata/CIM14/IEC61970/Meas/MeasurementValueSource.py b/schemata/CIM14/IEC61970/Meas/MeasurementValueSource.py index cbea0d7..077b183 100644 --- a/schemata/CIM14/IEC61970/Meas/MeasurementValueSource.py +++ b/schemata/CIM14/IEC61970/Meas/MeasurementValueSource.py @@ -20,15 +20,22 @@ class MeasurementValueSource(IdentifiedObject): """MeasurementValueSource describes the alternative sources updating a MeasurementValue. User conventions for how to use the MeasurementValueSource attributes are described in the introduction to IEC 61970-301. """ - def __init__(self, MeasurementValues=None, **kw_args): - """Initializes a new 'MeasurementValueSource' instance. + def __init__(self, MeasurementValues=None, *args, **kw_args): + """Initialises a new 'MeasurementValueSource' instance. @param MeasurementValues: The MeasurementValues updated by the source """ self._MeasurementValues = [] self.MeasurementValues = [] if MeasurementValues is None else MeasurementValues - super(MeasurementValueSource, self).__init__(**kw_args) + super(MeasurementValueSource, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["MeasurementValues"] + _many_refs = ["MeasurementValues"] def getMeasurementValues(self): """The MeasurementValues updated by the source diff --git a/schemata/CIM14/IEC61970/Meas/PotentialTransformer.py b/schemata/CIM14/IEC61970/Meas/PotentialTransformer.py index 793792e..5398680 100644 --- a/schemata/CIM14/IEC61970/Meas/PotentialTransformer.py +++ b/schemata/CIM14/IEC61970/Meas/PotentialTransformer.py @@ -20,8 +20,8 @@ class PotentialTransformer(Equipment): """Instrument transformer (also known as Voltage Transformer) used to measure electrical qualities of the circuit that is being protected and/or monitored. Typically used as voltage transducer for the purpose of metering, protection, or sometimes auxiliary substation supply. A typical secondary voltage rating would be 120V. """ - def __init__(self, ptClass='', accuracyClass='', nominalRatio=0.0, **kw_args): - """Initializes a new 'PotentialTransformer' instance. + def __init__(self, ptClass='', accuracyClass='', nominalRatio=0.0, *args, **kw_args): + """Initialises a new 'PotentialTransformer' instance. @param ptClass: PT classification. @param accuracyClass: PT accuracy classification. @@ -36,5 +36,12 @@ class PotentialTransformer(Equipment): #: Nominal ratio between the primary and secondary voltage. self.nominalRatio = nominalRatio - super(PotentialTransformer, self).__init__(**kw_args) + super(PotentialTransformer, self).__init__(*args, **kw_args) + + _attrs = ["ptClass", "accuracyClass", "nominalRatio"] + _attr_types = {"ptClass": str, "accuracyClass": str, "nominalRatio": float} + _defaults = {"ptClass": '', "accuracyClass": '', "nominalRatio": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Meas/Quality61850.py b/schemata/CIM14/IEC61970/Meas/Quality61850.py index 90ebbe3..116ca21 100644 --- a/schemata/CIM14/IEC61970/Meas/Quality61850.py +++ b/schemata/CIM14/IEC61970/Meas/Quality61850.py @@ -20,8 +20,8 @@ class Quality61850(Element): """Quality flags in this class are as defined in IEC 61850, except for estimatorReplaced, which has been included in this class for convenience. """ - def __init__(self, validity='QUESTIONABLE', source='SUBSTITUTED', failure=False, suspect=False, oldData=False, badReference=False, test=False, outOfRange=False, estimatorReplaced=False, oscillatory=False, operatorBlocked=False, overFlow=False, **kw_args): - """Initializes a new 'Quality61850' instance. + def __init__(self, validity="QUESTIONABLE", source="SUBSTITUTED", failure=False, suspect=False, oldData=False, badReference=False, test=False, outOfRange=False, estimatorReplaced=False, oscillatory=False, operatorBlocked=False, overFlow=False, *args, **kw_args): + """Initialises a new 'Quality61850' instance. @param validity: Validity of the measurement value. Values are: "QUESTIONABLE", "INVALID", "GOOD" @param source: Source gives information related to the origin of a value. The value may be acquired from the process, defaulted or substituted. Values are: "SUBSTITUTED", "DEFAULTED", "PROCESS" @@ -36,10 +36,10 @@ class Quality61850(Element): @param operatorBlocked: Measurement value is blocked and hence unavailable for transmission. @param overFlow: Measurement value is beyond the capability of being represented properly. For example, a counter value overflows from maximum count back to a value of zero. """ - #: Validity of the measurement value.Values are: "QUESTIONABLE", "INVALID", "GOOD" + #: Validity of the measurement value. Values are: "QUESTIONABLE", "INVALID", "GOOD" self.validity = validity - #: Source gives information related to the origin of a value. The value may be acquired from the process, defaulted or substituted.Values are: "SUBSTITUTED", "DEFAULTED", "PROCESS" + #: Source gives information related to the origin of a value. The value may be acquired from the process, defaulted or substituted. Values are: "SUBSTITUTED", "DEFAULTED", "PROCESS" self.source = source #: This identifier indicates that a supervision function has detected an internal or external failure, e.g. communication failure. @@ -72,5 +72,12 @@ class Quality61850(Element): #: Measurement value is beyond the capability of being represented properly. For example, a counter value overflows from maximum count back to a value of zero. self.overFlow = overFlow - super(Quality61850, self).__init__(**kw_args) + super(Quality61850, self).__init__(*args, **kw_args) + + _attrs = ["validity", "source", "failure", "suspect", "oldData", "badReference", "test", "outOfRange", "estimatorReplaced", "oscillatory", "operatorBlocked", "overFlow"] + _attr_types = {"validity": str, "source": str, "failure": bool, "suspect": bool, "oldData": bool, "badReference": bool, "test": bool, "outOfRange": bool, "estimatorReplaced": bool, "oscillatory": bool, "operatorBlocked": bool, "overFlow": bool} + _defaults = {"validity": "QUESTIONABLE", "source": "SUBSTITUTED", "failure": False, "suspect": False, "oldData": False, "badReference": False, "test": False, "outOfRange": False, "estimatorReplaced": False, "oscillatory": False, "operatorBlocked": False, "overFlow": False} + _enums = {"validity": "Validity", "source": "Source"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Meas/SetPoint.py b/schemata/CIM14/IEC61970/Meas/SetPoint.py index 46ce2a9..033b995 100644 --- a/schemata/CIM14/IEC61970/Meas/SetPoint.py +++ b/schemata/CIM14/IEC61970/Meas/SetPoint.py @@ -20,8 +20,8 @@ class SetPoint(Control): """A SetPoint is an analog control used for supervisory control. """ - def __init__(self, minValue=0.0, value=0.0, maxValue=0.0, normalValue=0.0, Analog=None, **kw_args): - """Initializes a new 'SetPoint' instance. + def __init__(self, minValue=0.0, value=0.0, maxValue=0.0, normalValue=0.0, Analog=None, *args, **kw_args): + """Initialises a new 'SetPoint' instance. @param minValue: Normal value range minimum for any of the Control.value. Used for scaling, e.g. in bar graphs. @param value: The value representing the actuator output @@ -44,7 +44,14 @@ class SetPoint(Control): self._Analog = None self.Analog = Analog - super(SetPoint, self).__init__(**kw_args) + super(SetPoint, self).__init__(*args, **kw_args) + + _attrs = ["minValue", "value", "maxValue", "normalValue"] + _attr_types = {"minValue": float, "value": float, "maxValue": float, "normalValue": float} + _defaults = {"minValue": 0.0, "value": 0.0, "maxValue": 0.0, "normalValue": 0.0} + _enums = {} + _refs = ["Analog"] + _many_refs = [] def getAnalog(self): """The Measurement variable used for control diff --git a/schemata/CIM14/IEC61970/Meas/StringMeasurement.py b/schemata/CIM14/IEC61970/Meas/StringMeasurement.py index b763ba5..a8fd477 100644 --- a/schemata/CIM14/IEC61970/Meas/StringMeasurement.py +++ b/schemata/CIM14/IEC61970/Meas/StringMeasurement.py @@ -20,15 +20,22 @@ class StringMeasurement(Measurement): """StringMeasurement represents a measurement with values of type string. """ - def __init__(self, StringMeasurementValues=None, **kw_args): - """Initializes a new 'StringMeasurement' instance. + def __init__(self, StringMeasurementValues=None, *args, **kw_args): + """Initialises a new 'StringMeasurement' instance. @param StringMeasurementValues: The values connected to this measurement. """ self._StringMeasurementValues = [] self.StringMeasurementValues = [] if StringMeasurementValues is None else StringMeasurementValues - super(StringMeasurement, self).__init__(**kw_args) + super(StringMeasurement, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["StringMeasurementValues"] + _many_refs = ["StringMeasurementValues"] def getStringMeasurementValues(self): """The values connected to this measurement. diff --git a/schemata/CIM14/IEC61970/Meas/StringMeasurementValue.py b/schemata/CIM14/IEC61970/Meas/StringMeasurementValue.py index c0d1fbf..32cd129 100644 --- a/schemata/CIM14/IEC61970/Meas/StringMeasurementValue.py +++ b/schemata/CIM14/IEC61970/Meas/StringMeasurementValue.py @@ -20,8 +20,8 @@ class StringMeasurementValue(MeasurementValue): """StringMeasurementValue represents a measurement value of type string. """ - def __init__(self, value='', StringMeasurement=None, **kw_args): - """Initializes a new 'StringMeasurementValue' instance. + def __init__(self, value='', StringMeasurement=None, *args, **kw_args): + """Initialises a new 'StringMeasurementValue' instance. @param value: The value to supervise. @param StringMeasurement: Measurement to which this value is connected. @@ -32,7 +32,14 @@ class StringMeasurementValue(MeasurementValue): self._StringMeasurement = None self.StringMeasurement = StringMeasurement - super(StringMeasurementValue, self).__init__(**kw_args) + super(StringMeasurementValue, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": str} + _defaults = {"value": ''} + _enums = {} + _refs = ["StringMeasurement"] + _many_refs = [] def getStringMeasurement(self): """Measurement to which this value is connected. diff --git a/schemata/CIM14/IEC61970/Meas/ValueAliasSet.py b/schemata/CIM14/IEC61970/Meas/ValueAliasSet.py index bee20e4..61ab9ab 100644 --- a/schemata/CIM14/IEC61970/Meas/ValueAliasSet.py +++ b/schemata/CIM14/IEC61970/Meas/ValueAliasSet.py @@ -20,8 +20,8 @@ class ValueAliasSet(IdentifiedObject): """Describes the translation of a set of values into a name and is intendend to facilitate cusom translations. Each ValueAliasSet has a name, description etc. A specific Measurement may represent a discrete state like Open, Closed, Intermediate etc. This requires a translation from the MeasurementValue.value number to a string, e.g. 0->'Invalid', 1->'Open', 2->'Closed', 3->'Intermediate'. Each ValueToAlias member in ValueAliasSet.Value describe a mapping for one particular value to a name. """ - def __init__(self, Commands=None, Values=None, Discretes=None, **kw_args): - """Initializes a new 'ValueAliasSet' instance. + def __init__(self, Commands=None, Values=None, Discretes=None, *args, **kw_args): + """Initialises a new 'ValueAliasSet' instance. @param Commands: The ValueAliasSet used for translation of a Control value to a name. @param Values: The ValueToAlias mappings included in the set @@ -36,7 +36,14 @@ class ValueAliasSet(IdentifiedObject): self._Discretes = [] self.Discretes = [] if Discretes is None else Discretes - super(ValueAliasSet, self).__init__(**kw_args) + super(ValueAliasSet, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Commands", "Values", "Discretes"] + _many_refs = ["Commands", "Values", "Discretes"] def getCommands(self): """The ValueAliasSet used for translation of a Control value to a name. diff --git a/schemata/CIM14/IEC61970/Meas/ValueToAlias.py b/schemata/CIM14/IEC61970/Meas/ValueToAlias.py index 1f489a6..39c3b9f 100644 --- a/schemata/CIM14/IEC61970/Meas/ValueToAlias.py +++ b/schemata/CIM14/IEC61970/Meas/ValueToAlias.py @@ -20,8 +20,8 @@ class ValueToAlias(IdentifiedObject): """Describes the translation of one particular value into a name, e.g. 1->'Open' """ - def __init__(self, value=0, ValueAliasSet=None, **kw_args): - """Initializes a new 'ValueToAlias' instance. + def __init__(self, value=0, ValueAliasSet=None, *args, **kw_args): + """Initialises a new 'ValueToAlias' instance. @param value: The value that is mapped @param ValueAliasSet: The ValueAliasSet having the ValueToAlias mappings @@ -32,7 +32,14 @@ class ValueToAlias(IdentifiedObject): self._ValueAliasSet = None self.ValueAliasSet = ValueAliasSet - super(ValueToAlias, self).__init__(**kw_args) + super(ValueToAlias, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": int} + _defaults = {"value": 0} + _enums = {} + _refs = ["ValueAliasSet"] + _many_refs = [] def getValueAliasSet(self): """The ValueAliasSet having the ValueToAlias mappings diff --git a/schemata/CIM14/IEC61970/OperationalLimits/ActivePowerLimit.py b/schemata/CIM14/IEC61970/OperationalLimits/ActivePowerLimit.py index cdf97ed..4a729e2 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/ActivePowerLimit.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/ActivePowerLimit.py @@ -20,13 +20,20 @@ class ActivePowerLimit(OperationalLimit): """Limit on active power flow. """ - def __init__(self, value=0.0, **kw_args): - """Initializes a new 'ActivePowerLimit' instance. + def __init__(self, value=0.0, *args, **kw_args): + """Initialises a new 'ActivePowerLimit' instance. @param value: Value of active power limit. """ #: Value of active power limit. self.value = value - super(ActivePowerLimit, self).__init__(**kw_args) + super(ActivePowerLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/OperationalLimits/ApparentPowerLimit.py b/schemata/CIM14/IEC61970/OperationalLimits/ApparentPowerLimit.py index d7e0957..adb4e9f 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/ApparentPowerLimit.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/ApparentPowerLimit.py @@ -20,13 +20,20 @@ class ApparentPowerLimit(OperationalLimit): """Apparent power limit. """ - def __init__(self, value=0.0, **kw_args): - """Initializes a new 'ApparentPowerLimit' instance. + def __init__(self, value=0.0, *args, **kw_args): + """Initialises a new 'ApparentPowerLimit' instance. @param value: The apparent power limit. """ #: The apparent power limit. self.value = value - super(ApparentPowerLimit, self).__init__(**kw_args) + super(ApparentPowerLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/OperationalLimits/BranchGroup.py b/schemata/CIM14/IEC61970/OperationalLimits/BranchGroup.py index 7de247d..8426e99 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/BranchGroup.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/BranchGroup.py @@ -20,8 +20,8 @@ class BranchGroup(IdentifiedObject): """A group of branch terminals whose directed flow summation is to be monitored. Abranch group need not form a cutset of the network. """ - def __init__(self, minimumReactivePower=0.0, monitorActivePower=False, minimumActivePower=0.0, maximumReactivePower=0.0, maximumActivePower=0.0, monitorReactivePower=False, BranchGroupTerminal=None, **kw_args): - """Initializes a new 'BranchGroup' instance. + def __init__(self, minimumReactivePower=0.0, monitorActivePower=False, minimumActivePower=0.0, maximumReactivePower=0.0, maximumActivePower=0.0, monitorReactivePower=False, BranchGroupTerminal=None, *args, **kw_args): + """Initialises a new 'BranchGroup' instance. @param minimumReactivePower: The minimum reactive power flow. @param monitorActivePower: Monitor the active power flow. @@ -52,7 +52,14 @@ class BranchGroup(IdentifiedObject): self._BranchGroupTerminal = [] self.BranchGroupTerminal = [] if BranchGroupTerminal is None else BranchGroupTerminal - super(BranchGroup, self).__init__(**kw_args) + super(BranchGroup, self).__init__(*args, **kw_args) + + _attrs = ["minimumReactivePower", "monitorActivePower", "minimumActivePower", "maximumReactivePower", "maximumActivePower", "monitorReactivePower"] + _attr_types = {"minimumReactivePower": float, "monitorActivePower": bool, "minimumActivePower": float, "maximumReactivePower": float, "maximumActivePower": float, "monitorReactivePower": bool} + _defaults = {"minimumReactivePower": 0.0, "monitorActivePower": False, "minimumActivePower": 0.0, "maximumReactivePower": 0.0, "maximumActivePower": 0.0, "monitorReactivePower": False} + _enums = {} + _refs = ["BranchGroupTerminal"] + _many_refs = ["BranchGroupTerminal"] def getBranchGroupTerminal(self): """The directed branch group terminals to be summed. diff --git a/schemata/CIM14/IEC61970/OperationalLimits/BranchGroupTerminal.py b/schemata/CIM14/IEC61970/OperationalLimits/BranchGroupTerminal.py index a58001e..0db2379 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/BranchGroupTerminal.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/BranchGroupTerminal.py @@ -20,8 +20,8 @@ class BranchGroupTerminal(Element): """A specific directed terminal flow for a branch group. """ - def __init__(self, positiveFlowIn=False, BranchGroup=None, Terminal=None, **kw_args): - """Initializes a new 'BranchGroupTerminal' instance. + def __init__(self, positiveFlowIn=False, BranchGroup=None, Terminal=None, *args, **kw_args): + """Initialises a new 'BranchGroupTerminal' instance. @param positiveFlowIn: The flow into the terminal is summed if set true. The flow out of the terminanl is summed if set false. @param BranchGroup: The branch group to which the directed branch group terminals belong. @@ -36,7 +36,14 @@ class BranchGroupTerminal(Element): self._Terminal = None self.Terminal = Terminal - super(BranchGroupTerminal, self).__init__(**kw_args) + super(BranchGroupTerminal, self).__init__(*args, **kw_args) + + _attrs = ["positiveFlowIn"] + _attr_types = {"positiveFlowIn": bool} + _defaults = {"positiveFlowIn": False} + _enums = {} + _refs = ["BranchGroup", "Terminal"] + _many_refs = [] def getBranchGroup(self): """The branch group to which the directed branch group terminals belong. diff --git a/schemata/CIM14/IEC61970/OperationalLimits/CurrentLimit.py b/schemata/CIM14/IEC61970/OperationalLimits/CurrentLimit.py index c8a4001..178ed80 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/CurrentLimit.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/CurrentLimit.py @@ -20,13 +20,20 @@ class CurrentLimit(OperationalLimit): """Operational limit on current. """ - def __init__(self, value=0.0, **kw_args): - """Initializes a new 'CurrentLimit' instance. + def __init__(self, value=0.0, *args, **kw_args): + """Initialises a new 'CurrentLimit' instance. @param value: Limit on current flow. """ #: Limit on current flow. self.value = value - super(CurrentLimit, self).__init__(**kw_args) + super(CurrentLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimit.py b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimit.py index 8c324b8..5c9eb48 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimit.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimit.py @@ -20,8 +20,8 @@ class OperationalLimit(IdentifiedObject): """A value associated with a specific kind of limit. """ - def __init__(self, type='', OperationalLimitType=None, OperationalLimitSet=None, **kw_args): - """Initializes a new 'OperationalLimit' instance. + def __init__(self, type='', OperationalLimitType=None, OperationalLimitSet=None, *args, **kw_args): + """Initialises a new 'OperationalLimit' instance. @param type: Used to specify high/low and limit levels. @param OperationalLimitType: The limit type associated with this limit. @@ -36,7 +36,14 @@ class OperationalLimit(IdentifiedObject): self._OperationalLimitSet = None self.OperationalLimitSet = OperationalLimitSet - super(OperationalLimit, self).__init__(**kw_args) + super(OperationalLimit, self).__init__(*args, **kw_args) + + _attrs = ["type"] + _attr_types = {"type": str} + _defaults = {"type": ''} + _enums = {} + _refs = ["OperationalLimitType", "OperationalLimitSet"] + _many_refs = [] def getOperationalLimitType(self): """The limit type associated with this limit. diff --git a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitSet.py b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitSet.py index 32f9f8d..10036ca 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitSet.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitSet.py @@ -20,8 +20,8 @@ class OperationalLimitSet(IdentifiedObject): """A set of limits associated with equipmnet. Sets of limits might apply to a specific temperature, or season for example. A set of limits may contain may different severities of limit levels that would apply to the same equipment. The set may contain limits of different types such as apparent power and current limits or high and low voltage limits that are logically applied together as a set. """ - def __init__(self, Equipment=None, Terminal=None, OperationalLimitValue=None, **kw_args): - """Initializes a new 'OperationalLimitSet' instance. + def __init__(self, Equipment=None, Terminal=None, OperationalLimitValue=None, *args, **kw_args): + """Initialises a new 'OperationalLimitSet' instance. @param Equipment: The equpment to which the limit set applies. @param Terminal: The terminal specifically associated to this operational limit set. If no terminal is associated, all terminals of the equipment are implied. @@ -36,7 +36,14 @@ class OperationalLimitSet(IdentifiedObject): self._OperationalLimitValue = [] self.OperationalLimitValue = [] if OperationalLimitValue is None else OperationalLimitValue - super(OperationalLimitSet, self).__init__(**kw_args) + super(OperationalLimitSet, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Equipment", "Terminal", "OperationalLimitValue"] + _many_refs = ["OperationalLimitValue"] def getEquipment(self): """The equpment to which the limit set applies. diff --git a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitType.py b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitType.py index c5153b6..a8a84c6 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitType.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/OperationalLimitType.py @@ -20,14 +20,14 @@ class OperationalLimitType(IdentifiedObject): """A type of limit. The meaning of a specific limit is described in this class. """ - def __init__(self, direction='low', acceptableDuration=0.0, OperationalLimit=None, **kw_args): - """Initializes a new 'OperationalLimitType' instance. + def __init__(self, direction="low", acceptableDuration=0.0, OperationalLimit=None, *args, **kw_args): + """Initialises a new 'OperationalLimitType' instance. @param direction: The direction of the limit. Values are: "low", "absoluteValue", "high" @param acceptableDuration: The nominal acceptable duration of the limit. Limits are commonly expressed in terms of the a time limit for which the limit is normally acceptable. The actual acceptable duration of a specific limit may depend on other local factors such as temperature or wind speed. @param OperationalLimit: The operational limits associated with this type of limit. """ - #: The direction of the limit.Values are: "low", "absoluteValue", "high" + #: The direction of the limit. Values are: "low", "absoluteValue", "high" self.direction = direction #: The nominal acceptable duration of the limit. Limits are commonly expressed in terms of the a time limit for which the limit is normally acceptable. The actual acceptable duration of a specific limit may depend on other local factors such as temperature or wind speed. @@ -36,7 +36,14 @@ class OperationalLimitType(IdentifiedObject): self._OperationalLimit = [] self.OperationalLimit = [] if OperationalLimit is None else OperationalLimit - super(OperationalLimitType, self).__init__(**kw_args) + super(OperationalLimitType, self).__init__(*args, **kw_args) + + _attrs = ["direction", "acceptableDuration"] + _attr_types = {"direction": str, "acceptableDuration": float} + _defaults = {"direction": "low", "acceptableDuration": 0.0} + _enums = {"direction": "OperationalLimitDirectionKind"} + _refs = ["OperationalLimit"] + _many_refs = ["OperationalLimit"] def getOperationalLimit(self): """The operational limits associated with this type of limit. diff --git a/schemata/CIM14/IEC61970/OperationalLimits/VoltageLimit.py b/schemata/CIM14/IEC61970/OperationalLimits/VoltageLimit.py index d1aec18..bfce846 100644 --- a/schemata/CIM14/IEC61970/OperationalLimits/VoltageLimit.py +++ b/schemata/CIM14/IEC61970/OperationalLimits/VoltageLimit.py @@ -20,13 +20,20 @@ class VoltageLimit(OperationalLimit): """Operational limit applied to voltage. """ - def __init__(self, value=0.0, **kw_args): - """Initializes a new 'VoltageLimit' instance. + def __init__(self, value=0.0, *args, **kw_args): + """Initialises a new 'VoltageLimit' instance. @param value: Limit on voltage. High or low limit depends on the OperatoinalLimit.limitKind """ #: Limit on voltage. High or low limit depends on the OperatoinalLimit.limitKind self.value = value - super(VoltageLimit, self).__init__(**kw_args) + super(VoltageLimit, self).__init__(*args, **kw_args) + + _attrs = ["value"] + _attr_types = {"value": float} + _defaults = {"value": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Outage/ClearanceTag.py b/schemata/CIM14/IEC61970/Outage/ClearanceTag.py index c9891db..9278803 100644 --- a/schemata/CIM14/IEC61970/Outage/ClearanceTag.py +++ b/schemata/CIM14/IEC61970/Outage/ClearanceTag.py @@ -20,8 +20,8 @@ class ClearanceTag(IdentifiedObject): """A clearance tag that is used to authorize and schedule work on conducting equipment in the field. Tagged equipment is not available for commercial service. """ - def __init__(self, workStartTime='', workDescription='', workEndTime='', authorityName='', deenergizeReqFlag=False, groundReqFlag=False, tagIssueTime='', phaseCheckReqFlag=False, ClearanceTagType=None, ConductingEquipment=None, **kw_args): - """Initializes a new 'ClearanceTag' instance. + def __init__(self, workStartTime='', workDescription='', workEndTime='', authorityName='', deenergizeReqFlag=False, groundReqFlag=False, tagIssueTime='', phaseCheckReqFlag=False, ClearanceTagType=None, ConductingEquipment=None, *args, **kw_args): + """Initialises a new 'ClearanceTag' instance. @param workStartTime: The time at which the clearance tag is scheduled to be set. @param workDescription: Description of the work to be performed @@ -64,7 +64,14 @@ class ClearanceTag(IdentifiedObject): self._ConductingEquipment = None self.ConductingEquipment = ConductingEquipment - super(ClearanceTag, self).__init__(**kw_args) + super(ClearanceTag, self).__init__(*args, **kw_args) + + _attrs = ["workStartTime", "workDescription", "workEndTime", "authorityName", "deenergizeReqFlag", "groundReqFlag", "tagIssueTime", "phaseCheckReqFlag"] + _attr_types = {"workStartTime": str, "workDescription": str, "workEndTime": str, "authorityName": str, "deenergizeReqFlag": bool, "groundReqFlag": bool, "tagIssueTime": str, "phaseCheckReqFlag": bool} + _defaults = {"workStartTime": '', "workDescription": '', "workEndTime": '', "authorityName": '', "deenergizeReqFlag": False, "groundReqFlag": False, "tagIssueTime": '', "phaseCheckReqFlag": False} + _enums = {} + _refs = ["ClearanceTagType", "ConductingEquipment"] + _many_refs = [] def getClearanceTagType(self): """The type of tag, depending on the purpose of the work to be performed and/or the type of supervisory control allowed. diff --git a/schemata/CIM14/IEC61970/Outage/ClearanceTagType.py b/schemata/CIM14/IEC61970/Outage/ClearanceTagType.py index 113e294..e776831 100644 --- a/schemata/CIM14/IEC61970/Outage/ClearanceTagType.py +++ b/schemata/CIM14/IEC61970/Outage/ClearanceTagType.py @@ -20,15 +20,22 @@ class ClearanceTagType(IdentifiedObject): """Type of ClearanceTag. Could indicate the type of work to be performed and/or the type of supervisory control. """ - def __init__(self, ClearanceTags=None, **kw_args): - """Initializes a new 'ClearanceTagType' instance. + def __init__(self, ClearanceTags=None, *args, **kw_args): + """Initialises a new 'ClearanceTagType' instance. @param ClearanceTags: The ClearanceTags currently being defined for this type. """ self._ClearanceTags = [] self.ClearanceTags = [] if ClearanceTags is None else ClearanceTags - super(ClearanceTagType, self).__init__(**kw_args) + super(ClearanceTagType, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ClearanceTags"] + _many_refs = ["ClearanceTags"] def getClearanceTags(self): """The ClearanceTags currently being defined for this type. diff --git a/schemata/CIM14/IEC61970/Outage/OutageSchedule.py b/schemata/CIM14/IEC61970/Outage/OutageSchedule.py index aedc44d..1bb1750 100644 --- a/schemata/CIM14/IEC61970/Outage/OutageSchedule.py +++ b/schemata/CIM14/IEC61970/Outage/OutageSchedule.py @@ -20,8 +20,8 @@ class OutageSchedule(IrregularIntervalSchedule): """The period of time that a piece of equipment is out of service, for example, for maintenance or testing; including the equipment's active power rating while under maintenance. The X-axis represents absolute time and the Y-axis represents the equipment's available rating while out of service. """ - def __init__(self, SwitchingOperations=None, PowerSystemResource=None, **kw_args): - """Initializes a new 'OutageSchedule' instance. + def __init__(self, SwitchingOperations=None, PowerSystemResource=None, *args, **kw_args): + """Initialises a new 'OutageSchedule' instance. @param SwitchingOperations: An OutageSchedule may operate many switches. @param PowerSystemResource: A power system resource may have an outage schedule @@ -32,7 +32,14 @@ class OutageSchedule(IrregularIntervalSchedule): self._PowerSystemResource = None self.PowerSystemResource = PowerSystemResource - super(OutageSchedule, self).__init__(**kw_args) + super(OutageSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["SwitchingOperations", "PowerSystemResource"] + _many_refs = ["SwitchingOperations"] def getSwitchingOperations(self): """An OutageSchedule may operate many switches. diff --git a/schemata/CIM14/IEC61970/Outage/SwitchingOperation.py b/schemata/CIM14/IEC61970/Outage/SwitchingOperation.py index ed2012f..ea89e7b 100644 --- a/schemata/CIM14/IEC61970/Outage/SwitchingOperation.py +++ b/schemata/CIM14/IEC61970/Outage/SwitchingOperation.py @@ -20,15 +20,15 @@ class SwitchingOperation(IdentifiedObject): """A SwitchingOperation is used to define individual switch operations for an OutageSchedule. This OutageSchedule may be associated with another item of Substation such as a Transformer, Line, or Generator; or with the Switch itself as a PowerSystemResource. A Switch may be referenced by many OutageSchedules. """ - def __init__(self, newState='open', operationTime='', Switches=None, OutageSchedule=None, **kw_args): - """Initializes a new 'SwitchingOperation' instance. + def __init__(self, newState="open", operationTime='', Switches=None, OutageSchedule=None, *args, **kw_args): + """Initialises a new 'SwitchingOperation' instance. @param newState: The switch position that shall result from this SwitchingOperation Values are: "open", "close" @param operationTime: Time of operation in same units as OutageSchedule.xAxixUnits. @param Switches: A switch may be operated by many schedules. @param OutageSchedule: An OutageSchedule may operate many switches. """ - #: The switch position that shall result from this SwitchingOperationValues are: "open", "close" + #: The switch position that shall result from this SwitchingOperation Values are: "open", "close" self.newState = newState #: Time of operation in same units as OutageSchedule.xAxixUnits. @@ -40,7 +40,14 @@ class SwitchingOperation(IdentifiedObject): self._OutageSchedule = None self.OutageSchedule = OutageSchedule - super(SwitchingOperation, self).__init__(**kw_args) + super(SwitchingOperation, self).__init__(*args, **kw_args) + + _attrs = ["newState", "operationTime"] + _attr_types = {"newState": str, "operationTime": str} + _defaults = {"newState": "open", "operationTime": ''} + _enums = {"newState": "SwitchState"} + _refs = ["Switches", "OutageSchedule"] + _many_refs = ["Switches"] def getSwitches(self): """A switch may be operated by many schedules. diff --git a/schemata/CIM14/IEC61970/Protection/CurrentRelay.py b/schemata/CIM14/IEC61970/Protection/CurrentRelay.py index 483b99a..5ad4f5f 100644 --- a/schemata/CIM14/IEC61970/Protection/CurrentRelay.py +++ b/schemata/CIM14/IEC61970/Protection/CurrentRelay.py @@ -20,8 +20,8 @@ class CurrentRelay(ProtectionEquipment): """A device that checks current flow values in any direction or designated direction """ - def __init__(self, currentLimit1=0.0, timeDelay3=0.0, timeDelay2=0.0, currentLimit3=0.0, currentLimit2=0.0, inverseTimeFlag=False, timeDelay1=0.0, **kw_args): - """Initializes a new 'CurrentRelay' instance. + def __init__(self, currentLimit1=0.0, timeDelay3=0.0, timeDelay2=0.0, currentLimit3=0.0, currentLimit2=0.0, inverseTimeFlag=False, timeDelay1=0.0, *args, **kw_args): + """Initialises a new 'CurrentRelay' instance. @param currentLimit1: Current limit #1 for inverse time pickup @param timeDelay3: Inverse time delay #3 for current limit #3 @@ -52,5 +52,12 @@ class CurrentRelay(ProtectionEquipment): #: Inverse time delay #1 for current limit #1 self.timeDelay1 = timeDelay1 - super(CurrentRelay, self).__init__(**kw_args) + super(CurrentRelay, self).__init__(*args, **kw_args) + + _attrs = ["currentLimit1", "timeDelay3", "timeDelay2", "currentLimit3", "currentLimit2", "inverseTimeFlag", "timeDelay1"] + _attr_types = {"currentLimit1": float, "timeDelay3": float, "timeDelay2": float, "currentLimit3": float, "currentLimit2": float, "inverseTimeFlag": bool, "timeDelay1": float} + _defaults = {"currentLimit1": 0.0, "timeDelay3": 0.0, "timeDelay2": 0.0, "currentLimit3": 0.0, "currentLimit2": 0.0, "inverseTimeFlag": False, "timeDelay1": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Protection/FaultIndicator.py b/schemata/CIM14/IEC61970/Protection/FaultIndicator.py index 257b4c3..0246093 100644 --- a/schemata/CIM14/IEC61970/Protection/FaultIndicator.py +++ b/schemata/CIM14/IEC61970/Protection/FaultIndicator.py @@ -20,9 +20,16 @@ class FaultIndicator(Equipment): """A FaultIndicator is typically only an indicator (which may or may not be remotely monitored), and not a piece of equipment that actually initiates a protection event. It is used for FLISR (Fault Location, Isolation and Restoration) purposes, assisting with the dispatch of crews to 'most likely' part of the network (i.e. assists with determining circuit section where the fault most likely happened). """ - def __init__(self, **kw_args): - """Initializes a new 'FaultIndicator' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'FaultIndicator' instance. """ - super(FaultIndicator, self).__init__(**kw_args) + super(FaultIndicator, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Protection/ProtectionEquipment.py b/schemata/CIM14/IEC61970/Protection/ProtectionEquipment.py index d1d8a06..0f9f9d1 100644 --- a/schemata/CIM14/IEC61970/Protection/ProtectionEquipment.py +++ b/schemata/CIM14/IEC61970/Protection/ProtectionEquipment.py @@ -20,8 +20,8 @@ class ProtectionEquipment(Equipment): """An electrical device designed to respond to input conditions in a prescribed manner and after specified conditions are met to cause contact operation or similar abrupt change in associated electric control circuits, or simply to display the detected condition. Protection equipment are associated with conducting equipment and usually operate circuit breakers. """ - def __init__(self, lowLimit=0.0, powerDirectionFlag=False, highLimit=0.0, relayDelayTime=0.0, ProtectedSwitches=None, Unit=None, ConductingEquipments=None, **kw_args): - """Initializes a new 'ProtectionEquipment' instance. + def __init__(self, lowLimit=0.0, powerDirectionFlag=False, highLimit=0.0, relayDelayTime=0.0, ProtectedSwitches=None, Unit=None, ConductingEquipments=None, *args, **kw_args): + """Initialises a new 'ProtectionEquipment' instance. @param lowLimit: The minimum allowable value. @param powerDirectionFlag: Direction same as positive active power flow value. @@ -51,7 +51,14 @@ class ProtectionEquipment(Equipment): self._ConductingEquipments = [] self.ConductingEquipments = [] if ConductingEquipments is None else ConductingEquipments - super(ProtectionEquipment, self).__init__(**kw_args) + super(ProtectionEquipment, self).__init__(*args, **kw_args) + + _attrs = ["lowLimit", "powerDirectionFlag", "highLimit", "relayDelayTime"] + _attr_types = {"lowLimit": float, "powerDirectionFlag": bool, "highLimit": float, "relayDelayTime": float} + _defaults = {"lowLimit": 0.0, "powerDirectionFlag": False, "highLimit": 0.0, "relayDelayTime": 0.0} + _enums = {} + _refs = ["ProtectedSwitches", "Unit", "ConductingEquipments"] + _many_refs = ["ProtectedSwitches", "ConductingEquipments"] def add_ProtectedSwitches(self, *ProtectedSwitches): for obj in ProtectedSwitches: diff --git a/schemata/CIM14/IEC61970/Protection/RecloseSequence.py b/schemata/CIM14/IEC61970/Protection/RecloseSequence.py index 5b99fc4..3b40518 100644 --- a/schemata/CIM14/IEC61970/Protection/RecloseSequence.py +++ b/schemata/CIM14/IEC61970/Protection/RecloseSequence.py @@ -20,8 +20,8 @@ class RecloseSequence(IdentifiedObject): """A reclose sequence (open and close) is defined for each possible reclosure of a breaker. """ - def __init__(self, recloseDelay=0.0, recloseStep=0, ProtectedSwitch=None, **kw_args): - """Initializes a new 'RecloseSequence' instance. + def __init__(self, recloseDelay=0.0, recloseStep=0, ProtectedSwitch=None, *args, **kw_args): + """Initialises a new 'RecloseSequence' instance. @param recloseDelay: Indicates the time lapse before the reclose step will execute a reclose. @param recloseStep: Indicates the ordinal position of the reclose step relative to other steps in the sequence. @@ -36,7 +36,14 @@ class RecloseSequence(IdentifiedObject): self._ProtectedSwitch = None self.ProtectedSwitch = ProtectedSwitch - super(RecloseSequence, self).__init__(**kw_args) + super(RecloseSequence, self).__init__(*args, **kw_args) + + _attrs = ["recloseDelay", "recloseStep"] + _attr_types = {"recloseDelay": float, "recloseStep": int} + _defaults = {"recloseDelay": 0.0, "recloseStep": 0} + _enums = {} + _refs = ["ProtectedSwitch"] + _many_refs = [] def getProtectedSwitch(self): """A breaker may have zero or more automatic reclosures after a trip occurs. diff --git a/schemata/CIM14/IEC61970/Protection/SurgeProtector.py b/schemata/CIM14/IEC61970/Protection/SurgeProtector.py index 7ffca71..908f594 100644 --- a/schemata/CIM14/IEC61970/Protection/SurgeProtector.py +++ b/schemata/CIM14/IEC61970/Protection/SurgeProtector.py @@ -20,9 +20,16 @@ class SurgeProtector(Equipment): """Shunt device, installed on the network, usually in the proximity of electrical equipment in order to protect the said equipment against transient voltage spikes caused by lightning or switching activity. """ - def __init__(self, **kw_args): - """Initializes a new 'SurgeProtector' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'SurgeProtector' instance. """ - super(SurgeProtector, self).__init__(**kw_args) + super(SurgeProtector, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Protection/SynchrocheckRelay.py b/schemata/CIM14/IEC61970/Protection/SynchrocheckRelay.py index 0808e26..1925713 100644 --- a/schemata/CIM14/IEC61970/Protection/SynchrocheckRelay.py +++ b/schemata/CIM14/IEC61970/Protection/SynchrocheckRelay.py @@ -20,8 +20,8 @@ class SynchrocheckRelay(ProtectionEquipment): """A device that operates when two AC circuits are within the desired limits of frequency, phase angle, and voltage, to permit or to cause the paralleling of these two circuits. Used to prevent the paralleling of non-synchronous topological islands. """ - def __init__(self, maxFreqDiff=0.0, maxVoltDiff=0.0, maxAngleDiff=0.0, **kw_args): - """Initializes a new 'SynchrocheckRelay' instance. + def __init__(self, maxFreqDiff=0.0, maxVoltDiff=0.0, maxAngleDiff=0.0, *args, **kw_args): + """Initialises a new 'SynchrocheckRelay' instance. @param maxFreqDiff: The maximum allowable frequency difference across the open device @param maxVoltDiff: The maximum allowable difference voltage across the open device @@ -36,5 +36,12 @@ class SynchrocheckRelay(ProtectionEquipment): #: The maximum allowable voltage vector phase angle difference across the open device self.maxAngleDiff = maxAngleDiff - super(SynchrocheckRelay, self).__init__(**kw_args) + super(SynchrocheckRelay, self).__init__(*args, **kw_args) + + _attrs = ["maxFreqDiff", "maxVoltDiff", "maxAngleDiff"] + _attr_types = {"maxFreqDiff": float, "maxVoltDiff": float, "maxAngleDiff": float} + _defaults = {"maxFreqDiff": 0.0, "maxVoltDiff": 0.0, "maxAngleDiff": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/SCADA/CommunicationLink.py b/schemata/CIM14/IEC61970/SCADA/CommunicationLink.py index d8b81c4..1e62b5c 100644 --- a/schemata/CIM14/IEC61970/SCADA/CommunicationLink.py +++ b/schemata/CIM14/IEC61970/SCADA/CommunicationLink.py @@ -20,15 +20,22 @@ class CommunicationLink(PowerSystemResource): """The connection to remote units is through one or more communication links. Reduntant links may exist. The CommunicationLink class inherit PowerSystemResource. The intention is to allow CommunicationLinks to have Measurements. These Measurements can be used to model link status as operational, out of service, unit failure etc. """ - def __init__(self, RemoteUnits=None, **kw_args): - """Initializes a new 'CommunicationLink' instance. + def __init__(self, RemoteUnits=None, *args, **kw_args): + """Initialises a new 'CommunicationLink' instance. @param RemoteUnits: RTUs may be attached to communication links. """ self._RemoteUnits = [] self.RemoteUnits = [] if RemoteUnits is None else RemoteUnits - super(CommunicationLink, self).__init__(**kw_args) + super(CommunicationLink, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["RemoteUnits"] + _many_refs = ["RemoteUnits"] def getRemoteUnits(self): """RTUs may be attached to communication links. diff --git a/schemata/CIM14/IEC61970/SCADA/RemoteControl.py b/schemata/CIM14/IEC61970/SCADA/RemoteControl.py index a9a21c1..a86b37e 100644 --- a/schemata/CIM14/IEC61970/SCADA/RemoteControl.py +++ b/schemata/CIM14/IEC61970/SCADA/RemoteControl.py @@ -20,8 +20,8 @@ class RemoteControl(RemotePoint): """Remote controls are ouputs that are sent by the remote unit to actuators in the process. """ - def __init__(self, actuatorMinimum=0.0, remoteControlled=False, actuatorMaximum=0.0, Control=None, **kw_args): - """Initializes a new 'RemoteControl' instance. + def __init__(self, actuatorMinimum=0.0, remoteControlled=False, actuatorMaximum=0.0, Control=None, *args, **kw_args): + """Initialises a new 'RemoteControl' instance. @param actuatorMinimum: The minimum set point value accepted by the remote control point. @param remoteControlled: Set to true if the actuator is remotely controlled. @@ -40,7 +40,14 @@ class RemoteControl(RemotePoint): self._Control = None self.Control = Control - super(RemoteControl, self).__init__(**kw_args) + super(RemoteControl, self).__init__(*args, **kw_args) + + _attrs = ["actuatorMinimum", "remoteControlled", "actuatorMaximum"] + _attr_types = {"actuatorMinimum": float, "remoteControlled": bool, "actuatorMaximum": float} + _defaults = {"actuatorMinimum": 0.0, "remoteControlled": False, "actuatorMaximum": 0.0} + _enums = {} + _refs = ["Control"] + _many_refs = [] def getControl(self): """The Control for the RemoteControl point. diff --git a/schemata/CIM14/IEC61970/SCADA/RemotePoint.py b/schemata/CIM14/IEC61970/SCADA/RemotePoint.py index 53aa769..8db05c6 100644 --- a/schemata/CIM14/IEC61970/SCADA/RemotePoint.py +++ b/schemata/CIM14/IEC61970/SCADA/RemotePoint.py @@ -20,15 +20,22 @@ class RemotePoint(IdentifiedObject): """For a RTU remote points correspond to telemetered values or control outputs. Other units (e.g. control centers) usually also contain calculated values. """ - def __init__(self, RemoteUnit=None, **kw_args): - """Initializes a new 'RemotePoint' instance. + def __init__(self, RemoteUnit=None, *args, **kw_args): + """Initialises a new 'RemotePoint' instance. @param RemoteUnit: Remote unit this point belongs to. """ self._RemoteUnit = None self.RemoteUnit = RemoteUnit - super(RemotePoint, self).__init__(**kw_args) + super(RemotePoint, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["RemoteUnit"] + _many_refs = [] def getRemoteUnit(self): """Remote unit this point belongs to. diff --git a/schemata/CIM14/IEC61970/SCADA/RemoteSource.py b/schemata/CIM14/IEC61970/SCADA/RemoteSource.py index 907009a..034240c 100644 --- a/schemata/CIM14/IEC61970/SCADA/RemoteSource.py +++ b/schemata/CIM14/IEC61970/SCADA/RemoteSource.py @@ -20,8 +20,8 @@ class RemoteSource(RemotePoint): """Remote sources are state variables that are telemetered or calculated within the remote unit. """ - def __init__(self, scanInterval=0.0, sensorMaximum=0.0, deadband=0.0, sensorMinimum=0.0, MeasurementValue=None, **kw_args): - """Initializes a new 'RemoteSource' instance. + def __init__(self, scanInterval=0.0, sensorMaximum=0.0, deadband=0.0, sensorMinimum=0.0, MeasurementValue=None, *args, **kw_args): + """Initialises a new 'RemoteSource' instance. @param scanInterval: The time interval between scans. @param sensorMaximum: The maximum value the telemetry item can return. @@ -44,7 +44,14 @@ class RemoteSource(RemotePoint): self._MeasurementValue = None self.MeasurementValue = MeasurementValue - super(RemoteSource, self).__init__(**kw_args) + super(RemoteSource, self).__init__(*args, **kw_args) + + _attrs = ["scanInterval", "sensorMaximum", "deadband", "sensorMinimum"] + _attr_types = {"scanInterval": float, "sensorMaximum": float, "deadband": float, "sensorMinimum": float} + _defaults = {"scanInterval": 0.0, "sensorMaximum": 0.0, "deadband": 0.0, "sensorMinimum": 0.0} + _enums = {} + _refs = ["MeasurementValue"] + _many_refs = [] def getMeasurementValue(self): """Link to the physical telemetered point associated with this measurement. diff --git a/schemata/CIM14/IEC61970/SCADA/RemoteUnit.py b/schemata/CIM14/IEC61970/SCADA/RemoteUnit.py index 0b90e24..fe6cae8 100644 --- a/schemata/CIM14/IEC61970/SCADA/RemoteUnit.py +++ b/schemata/CIM14/IEC61970/SCADA/RemoteUnit.py @@ -20,14 +20,14 @@ class RemoteUnit(PowerSystemResource): """A remote unit can be a RTU, IED, substation control system, control center etc. The communication with the remote unit can be through various standard protocols (e.g. IEC 61870, IEC 61850) or non standard protocols (e.g. DNP, RP570 etc.). A remote unit contain remote data points that might be telemetered, collected or calculated. The RemoteUnit class inherit PowerSystemResource. The intention is to allow RemotUnits to have Measurements. These Measurements can be used to model unit status as operational, out of service, unit failure etc. """ - def __init__(self, remoteUnitType='IED', CommunicationLinks=None, RemotePoints=None, **kw_args): - """Initializes a new 'RemoteUnit' instance. + def __init__(self, remoteUnitType="IED", CommunicationLinks=None, RemotePoints=None, *args, **kw_args): + """Initialises a new 'RemoteUnit' instance. @param remoteUnitType: Type of remote unit. Values are: "IED", "ControlCenter", "RTU", "SubstationControlSystem" @param CommunicationLinks: RTUs may be attached to communication links. @param RemotePoints: Remote points this Remote unit contains. """ - #: Type of remote unit.Values are: "IED", "ControlCenter", "RTU", "SubstationControlSystem" + #: Type of remote unit. Values are: "IED", "ControlCenter", "RTU", "SubstationControlSystem" self.remoteUnitType = remoteUnitType self._CommunicationLinks = [] @@ -36,7 +36,14 @@ class RemoteUnit(PowerSystemResource): self._RemotePoints = [] self.RemotePoints = [] if RemotePoints is None else RemotePoints - super(RemoteUnit, self).__init__(**kw_args) + super(RemoteUnit, self).__init__(*args, **kw_args) + + _attrs = ["remoteUnitType"] + _attr_types = {"remoteUnitType": str} + _defaults = {"remoteUnitType": "IED"} + _enums = {"remoteUnitType": "RemoteUnitType"} + _refs = ["CommunicationLinks", "RemotePoints"] + _many_refs = ["CommunicationLinks", "RemotePoints"] def getCommunicationLinks(self): """RTUs may be attached to communication links. diff --git a/schemata/CIM14/IEC61970/StateVariables/StateVariable.py b/schemata/CIM14/IEC61970/StateVariables/StateVariable.py index 8a42f53..c9c0f2e 100644 --- a/schemata/CIM14/IEC61970/StateVariables/StateVariable.py +++ b/schemata/CIM14/IEC61970/StateVariables/StateVariable.py @@ -20,9 +20,16 @@ class StateVariable(Element): """An abstract class for state variables. """ - def __init__(self, **kw_args): - """Initializes a new 'StateVariable' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'StateVariable' instance. """ - super(StateVariable, self).__init__(**kw_args) + super(StateVariable, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/StateVariables/SvInjection.py b/schemata/CIM14/IEC61970/StateVariables/SvInjection.py index fdae219..a66c6a8 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvInjection.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvInjection.py @@ -20,8 +20,8 @@ class SvInjection(StateVariable): """Injection state variable. """ - def __init__(self, pNetInjection=0.0, qNetInjection=0.0, TopologicalNode=None, **kw_args): - """Initializes a new 'SvInjection' instance. + def __init__(self, pNetInjection=0.0, qNetInjection=0.0, TopologicalNode=None, *args, **kw_args): + """Initialises a new 'SvInjection' instance. @param pNetInjection: The active power injected into the bus at this location. Positive sign means injection into the bus. @param qNetInjection: The reactive power injected into the bus at this location. Positive sign means injection into the bus. @@ -36,7 +36,14 @@ class SvInjection(StateVariable): self._TopologicalNode = None self.TopologicalNode = TopologicalNode - super(SvInjection, self).__init__(**kw_args) + super(SvInjection, self).__init__(*args, **kw_args) + + _attrs = ["pNetInjection", "qNetInjection"] + _attr_types = {"pNetInjection": float, "qNetInjection": float} + _defaults = {"pNetInjection": 0.0, "qNetInjection": 0.0} + _enums = {} + _refs = ["TopologicalNode"] + _many_refs = [] def getTopologicalNode(self): """The topological node associated with the state injection. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvPowerFlow.py b/schemata/CIM14/IEC61970/StateVariables/SvPowerFlow.py index 7cecb55..e9d1245 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvPowerFlow.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvPowerFlow.py @@ -20,8 +20,8 @@ class SvPowerFlow(StateVariable): """State variable for power flow. """ - def __init__(self, q=0.0, p=0.0, Terminal=None, **kw_args): - """Initializes a new 'SvPowerFlow' instance. + def __init__(self, q=0.0, p=0.0, Terminal=None, *args, **kw_args): + """Initialises a new 'SvPowerFlow' instance. @param q: The reactive power flow into the terminal. @param p: The active power flow into the terminal. @@ -36,7 +36,14 @@ class SvPowerFlow(StateVariable): self._Terminal = None self.Terminal = Terminal - super(SvPowerFlow, self).__init__(**kw_args) + super(SvPowerFlow, self).__init__(*args, **kw_args) + + _attrs = ["q", "p"] + _attr_types = {"q": float, "p": float} + _defaults = {"q": 0.0, "p": 0.0} + _enums = {} + _refs = ["Terminal"] + _many_refs = [] def getTerminal(self): """The terminal associated with the power flow state. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvShortCircuit.py b/schemata/CIM14/IEC61970/StateVariables/SvShortCircuit.py index 6496539..8fae7a8 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvShortCircuit.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvShortCircuit.py @@ -20,8 +20,8 @@ class SvShortCircuit(StateVariable): """State variable for short circuit. """ - def __init__(self, x0PerX=0.0, sShortCircuit=0.0, r0PerR=0.0, xPerR=0.0, TopologicalNode=None, **kw_args): - """Initializes a new 'SvShortCircuit' instance. + def __init__(self, x0PerX=0.0, sShortCircuit=0.0, r0PerR=0.0, xPerR=0.0, TopologicalNode=None, *args, **kw_args): + """Initialises a new 'SvShortCircuit' instance. @param x0PerX: The ratio of zero sequence reactance per positive sequence reactance. @param sShortCircuit: The short circuit apparent power drawn at this node when faulted. @@ -44,7 +44,14 @@ class SvShortCircuit(StateVariable): self._TopologicalNode = None self.TopologicalNode = TopologicalNode - super(SvShortCircuit, self).__init__(**kw_args) + super(SvShortCircuit, self).__init__(*args, **kw_args) + + _attrs = ["x0PerX", "sShortCircuit", "r0PerR", "xPerR"] + _attr_types = {"x0PerX": float, "sShortCircuit": float, "r0PerR": float, "xPerR": float} + _defaults = {"x0PerX": 0.0, "sShortCircuit": 0.0, "r0PerR": 0.0, "xPerR": 0.0} + _enums = {} + _refs = ["TopologicalNode"] + _many_refs = [] def getTopologicalNode(self): """The topological node associated with the short circuit state. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvShuntCompensatorSections.py b/schemata/CIM14/IEC61970/StateVariables/SvShuntCompensatorSections.py index 84a9533..9b8c57e 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvShuntCompensatorSections.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvShuntCompensatorSections.py @@ -20,8 +20,8 @@ class SvShuntCompensatorSections(StateVariable): """State variable for the number of sections in service for a shunt compensator. """ - def __init__(self, continuousSections=0.0, sections=0, ShuntCompensator=None, **kw_args): - """Initializes a new 'SvShuntCompensatorSections' instance. + def __init__(self, continuousSections=0.0, sections=0, ShuntCompensator=None, *args, **kw_args): + """Initialises a new 'SvShuntCompensatorSections' instance. @param continuousSections: The number of sections in service as a continous variable. @param sections: The number of sections in service. @@ -36,7 +36,14 @@ class SvShuntCompensatorSections(StateVariable): self._ShuntCompensator = None self.ShuntCompensator = ShuntCompensator - super(SvShuntCompensatorSections, self).__init__(**kw_args) + super(SvShuntCompensatorSections, self).__init__(*args, **kw_args) + + _attrs = ["continuousSections", "sections"] + _attr_types = {"continuousSections": float, "sections": int} + _defaults = {"continuousSections": 0.0, "sections": 0} + _enums = {} + _refs = ["ShuntCompensator"] + _many_refs = [] def getShuntCompensator(self): """The shunt compensator for which the state applies. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvStatus.py b/schemata/CIM14/IEC61970/StateVariables/SvStatus.py index 1fa9016..f1b5f7b 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvStatus.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvStatus.py @@ -20,8 +20,8 @@ class SvStatus(StateVariable): """State variable for status. """ - def __init__(self, inService=False, ConductingEquipment=None, **kw_args): - """Initializes a new 'SvStatus' instance. + def __init__(self, inService=False, ConductingEquipment=None, *args, **kw_args): + """Initialises a new 'SvStatus' instance. @param inService: The in service status as a result of topology processing. @param ConductingEquipment: The conducting equipment associated with the status state. @@ -32,7 +32,14 @@ class SvStatus(StateVariable): self._ConductingEquipment = None self.ConductingEquipment = ConductingEquipment - super(SvStatus, self).__init__(**kw_args) + super(SvStatus, self).__init__(*args, **kw_args) + + _attrs = ["inService"] + _attr_types = {"inService": bool} + _defaults = {"inService": False} + _enums = {} + _refs = ["ConductingEquipment"] + _many_refs = [] def getConductingEquipment(self): """The conducting equipment associated with the status state. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvTapStep.py b/schemata/CIM14/IEC61970/StateVariables/SvTapStep.py index 7d3d973..53e4806 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvTapStep.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvTapStep.py @@ -20,8 +20,8 @@ class SvTapStep(StateVariable): """State variable for transformer tap step. This class is to be used for taps of LTC (load tap changing) transformers, not fixed tap transformers. Normally a profile specifies only one of the attributes 'position'or 'tapRatio'. """ - def __init__(self, continuousPosition=0.0, position=0, TapChanger=None, **kw_args): - """Initializes a new 'SvTapStep' instance. + def __init__(self, continuousPosition=0.0, position=0, TapChanger=None, *args, **kw_args): + """Initialises a new 'SvTapStep' instance. @param continuousPosition: The floating point tap position. @param position: The integer tap position. @@ -36,7 +36,14 @@ class SvTapStep(StateVariable): self._TapChanger = None self.TapChanger = TapChanger - super(SvTapStep, self).__init__(**kw_args) + super(SvTapStep, self).__init__(*args, **kw_args) + + _attrs = ["continuousPosition", "position"] + _attr_types = {"continuousPosition": float, "position": int} + _defaults = {"continuousPosition": 0.0, "position": 0} + _enums = {} + _refs = ["TapChanger"] + _many_refs = [] def getTapChanger(self): """The tap changer associated with the tap step state. diff --git a/schemata/CIM14/IEC61970/StateVariables/SvVoltage.py b/schemata/CIM14/IEC61970/StateVariables/SvVoltage.py index 68217d1..f2e0aa0 100644 --- a/schemata/CIM14/IEC61970/StateVariables/SvVoltage.py +++ b/schemata/CIM14/IEC61970/StateVariables/SvVoltage.py @@ -20,8 +20,8 @@ class SvVoltage(StateVariable): """State variable for voltage. """ - def __init__(self, angle=0.0, v=0.0, TopologicalNode=None, **kw_args): - """Initializes a new 'SvVoltage' instance. + def __init__(self, angle=0.0, v=0.0, TopologicalNode=None, *args, **kw_args): + """Initialises a new 'SvVoltage' instance. @param angle: The voltage angle in radians of the topological node. @param v: The voltage magnitude of the topological node. @@ -36,7 +36,14 @@ class SvVoltage(StateVariable): self._TopologicalNode = None self.TopologicalNode = TopologicalNode - super(SvVoltage, self).__init__(**kw_args) + super(SvVoltage, self).__init__(*args, **kw_args) + + _attrs = ["angle", "v"] + _attr_types = {"angle": float, "v": float} + _defaults = {"angle": 0.0, "v": 0.0} + _enums = {} + _refs = ["TopologicalNode"] + _many_refs = [] def getTopologicalNode(self): """The topological node associated with the voltage state. diff --git a/schemata/CIM14/IEC61970/StateVariables/TopologicalIsland.py b/schemata/CIM14/IEC61970/StateVariables/TopologicalIsland.py index bbf3132..09bb30c 100644 --- a/schemata/CIM14/IEC61970/StateVariables/TopologicalIsland.py +++ b/schemata/CIM14/IEC61970/StateVariables/TopologicalIsland.py @@ -20,8 +20,8 @@ class TopologicalIsland(IdentifiedObject): """An electrically connected subset of the network. Topological islands can change as the current network state changes (i.e. switch or Terminal.connected status changes). """ - def __init__(self, TopologicalNodes=None, AngleRef_TopologicalNode=None, **kw_args): - """Initializes a new 'TopologicalIsland' instance. + def __init__(self, TopologicalNodes=None, AngleRef_TopologicalNode=None, *args, **kw_args): + """Initialises a new 'TopologicalIsland' instance. @param TopologicalNodes: A topological node belongs to a topological island @param AngleRef_TopologicalNode: The angle reference for the island. Normally there is one TopologicalNode that is selected as the angle reference for each island. Other reference schemes exist, so the association is optional. @@ -32,7 +32,14 @@ class TopologicalIsland(IdentifiedObject): self._AngleRef_TopologicalNode = None self.AngleRef_TopologicalNode = AngleRef_TopologicalNode - super(TopologicalIsland, self).__init__(**kw_args) + super(TopologicalIsland, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["TopologicalNodes", "AngleRef_TopologicalNode"] + _many_refs = ["TopologicalNodes"] def getTopologicalNodes(self): """A topological node belongs to a topological island diff --git a/schemata/CIM14/IEC61970/Topology/BusNameMarker.py b/schemata/CIM14/IEC61970/Topology/BusNameMarker.py index de463de..0e2546a 100644 --- a/schemata/CIM14/IEC61970/Topology/BusNameMarker.py +++ b/schemata/CIM14/IEC61970/Topology/BusNameMarker.py @@ -20,8 +20,8 @@ class BusNameMarker(IdentifiedObject): """Used to apply user standard names to topology buses. Typically used for 'bus/branch' case generation. Associated with one or more ConnectivityNodes that are normally a part of the bus name. The associated ConnectivityNodes are to be connected by non-retained switches. For a ring bus station configuration, all busbar connectivity nodes in the ring are typically associated. For a breaker and a half scheme, both busbars would be associated. For a ring bus, all busbars would be associated. For a 'straight' busbar configuration, only the main connectivity node at the busbar would be associated. """ - def __init__(self, ReportingGroup=None, ConnectivityNode=None, **kw_args): - """Initializes a new 'BusNameMarker' instance. + def __init__(self, ReportingGroup=None, ConnectivityNode=None, *args, **kw_args): + """Initialises a new 'BusNameMarker' instance. @param ReportingGroup: The reporting group to which this BusNameMarker belongs. @param ConnectivityNode: The list of nodes which have the same bus name in the normal topology. Note that this list of ConnectivityNodes should be connected by objects derived from Switch that are normally closed. @@ -32,7 +32,14 @@ class BusNameMarker(IdentifiedObject): self._ConnectivityNode = [] self.ConnectivityNode = [] if ConnectivityNode is None else ConnectivityNode - super(BusNameMarker, self).__init__(**kw_args) + super(BusNameMarker, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["ReportingGroup", "ConnectivityNode"] + _many_refs = ["ConnectivityNode"] def getReportingGroup(self): """The reporting group to which this BusNameMarker belongs. diff --git a/schemata/CIM14/IEC61970/Topology/TopologicalNode.py b/schemata/CIM14/IEC61970/Topology/TopologicalNode.py index c8b4b11..127bce6 100644 --- a/schemata/CIM14/IEC61970/Topology/TopologicalNode.py +++ b/schemata/CIM14/IEC61970/Topology/TopologicalNode.py @@ -20,8 +20,8 @@ class TopologicalNode(IdentifiedObject): """For a detailed substation model a TopologicalNode is a set of connectivity nodes that, in the current network state, are connected together through any type of closed switches, including jumpers. Topological nodes changes as the current network state changes (i.e., switches, breakers, etc. change state). For a planning model switch statuses are not used to form TopologicalNodes. Instead they are manually created or deleted in a model builder tool. TopologialNodes maintained this way are also called 'busses'. """ - def __init__(self, Terminal=None, TopologicalIsland=None, ReportingGroup=None, ConnectivityNodes=None, SvInjection=None, SvVoltage=None, SvShortCircuit=None, BaseVoltage=None, ConnectivityNodeContainer=None, AngleRef_TopologicalIsland=None, **kw_args): - """Initializes a new 'TopologicalNode' instance. + def __init__(self, Terminal=None, TopologicalIsland=None, ReportingGroup=None, ConnectivityNodes=None, SvInjection=None, SvVoltage=None, SvShortCircuit=None, BaseVoltage=None, ConnectivityNodeContainer=None, AngleRef_TopologicalIsland=None, *args, **kw_args): + """Initialises a new 'TopologicalNode' instance. @param Terminal: The terminals associated with the topological node. This can be used as an alternative to the connectivity node path to terminal, thus making it unneccesary to model connedtivity nodes in some cases. Note that the if connectivity nodes are in the model, this association would proably not be used. @param TopologicalIsland: A topological node belongs to a topological island @@ -64,7 +64,14 @@ class TopologicalNode(IdentifiedObject): self._AngleRef_TopologicalIsland = None self.AngleRef_TopologicalIsland = AngleRef_TopologicalIsland - super(TopologicalNode, self).__init__(**kw_args) + super(TopologicalNode, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Terminal", "TopologicalIsland", "ReportingGroup", "ConnectivityNodes", "SvInjection", "SvVoltage", "SvShortCircuit", "BaseVoltage", "ConnectivityNodeContainer", "AngleRef_TopologicalIsland"] + _many_refs = ["Terminal", "ConnectivityNodes"] def getTerminal(self): """The terminals associated with the topological node. This can be used as an alternative to the connectivity node path to terminal, thus making it unneccesary to model connedtivity nodes in some cases. Note that the if connectivity nodes are in the model, this association would proably not be used. diff --git a/schemata/CIM14/IEC61970/Wires/ACLineSegment.py b/schemata/CIM14/IEC61970/Wires/ACLineSegment.py index db5a238..c9947a3 100644 --- a/schemata/CIM14/IEC61970/Wires/ACLineSegment.py +++ b/schemata/CIM14/IEC61970/Wires/ACLineSegment.py @@ -20,8 +20,8 @@ class ACLineSegment(Conductor): """A wire or combination of wires, with consistent electrical characteristics, building a single electrical system, used to carry alternating current between points in the power system. """ - def __init__(self, gch=0.0, r=0.0, x0=0.0, bch=0.0, x=0.0, r0=0.0, g0ch=0.0, b0ch=0.0, **kw_args): - """Initializes a new 'ACLineSegment' instance. + def __init__(self, gch=0.0, r=0.0, x0=0.0, bch=0.0, x=0.0, r0=0.0, g0ch=0.0, b0ch=0.0, *args, **kw_args): + """Initialises a new 'ACLineSegment' instance. @param gch: Positive sequence shunt (charging) conductance, uniformly distributed, of the entire line section. @param r: Positive sequence series resistance of the entire line section. @@ -56,5 +56,12 @@ class ACLineSegment(Conductor): #: Zero sequence shunt (charging) susceptance, uniformly distributed, of the entire line section. self.b0ch = b0ch - super(ACLineSegment, self).__init__(**kw_args) + super(ACLineSegment, self).__init__(*args, **kw_args) + + _attrs = ["gch", "r", "x0", "bch", "x", "r0", "g0ch", "b0ch"] + _attr_types = {"gch": float, "r": float, "x0": float, "bch": float, "x": float, "r0": float, "g0ch": float, "b0ch": float} + _defaults = {"gch": 0.0, "r": 0.0, "x0": 0.0, "bch": 0.0, "x": 0.0, "r0": 0.0, "g0ch": 0.0, "b0ch": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Breaker.py b/schemata/CIM14/IEC61970/Wires/Breaker.py index e2ea907..3fd8e8e 100644 --- a/schemata/CIM14/IEC61970/Wires/Breaker.py +++ b/schemata/CIM14/IEC61970/Wires/Breaker.py @@ -20,8 +20,8 @@ class Breaker(ProtectedSwitch): """A mechanical switching device capable of making, carrying, and breaking currents under normal circuit conditions and also making, carrying for a specified time, and breaking currents under specified abnormal circuit conditions e.g. those of short circuit. """ - def __init__(self, inTransitTime=0.0, ratedCurrent=0.0, **kw_args): - """Initializes a new 'Breaker' instance. + def __init__(self, inTransitTime=0.0, ratedCurrent=0.0, *args, **kw_args): + """Initialises a new 'Breaker' instance. @param inTransitTime: The transition time from open to close. @param ratedCurrent: Fault interrupting current rating. @@ -32,5 +32,12 @@ class Breaker(ProtectedSwitch): #: Fault interrupting current rating. self.ratedCurrent = ratedCurrent - super(Breaker, self).__init__(**kw_args) + super(Breaker, self).__init__(*args, **kw_args) + + _attrs = ["inTransitTime", "ratedCurrent"] + _attr_types = {"inTransitTime": float, "ratedCurrent": float} + _defaults = {"inTransitTime": 0.0, "ratedCurrent": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/BusbarSection.py b/schemata/CIM14/IEC61970/Wires/BusbarSection.py index 1a9d106..b67a332 100644 --- a/schemata/CIM14/IEC61970/Wires/BusbarSection.py +++ b/schemata/CIM14/IEC61970/Wires/BusbarSection.py @@ -20,15 +20,22 @@ class BusbarSection(Connector): """A conductor, or group of conductors, with negligible impedance, that serve to connect other conducting equipment within a single substation. Voltage measurements are typically obtained from VoltageTransformers that are connected to busbar sections. A bus bar section may have many physical terminals but for analysis is modelled with exactly one logical terminal. """ - def __init__(self, VoltageControlZone=None, **kw_args): - """Initializes a new 'BusbarSection' instance. + def __init__(self, VoltageControlZone=None, *args, **kw_args): + """Initialises a new 'BusbarSection' instance. @param VoltageControlZone: A VoltageControlZone is controlled by a designated BusbarSection. """ self._VoltageControlZone = None self.VoltageControlZone = VoltageControlZone - super(BusbarSection, self).__init__(**kw_args) + super(BusbarSection, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["VoltageControlZone"] + _many_refs = [] def getVoltageControlZone(self): """A VoltageControlZone is controlled by a designated BusbarSection. diff --git a/schemata/CIM14/IEC61970/Wires/CompositeSwitch.py b/schemata/CIM14/IEC61970/Wires/CompositeSwitch.py index 4ce5b4c..535014f 100644 --- a/schemata/CIM14/IEC61970/Wires/CompositeSwitch.py +++ b/schemata/CIM14/IEC61970/Wires/CompositeSwitch.py @@ -20,8 +20,8 @@ class CompositeSwitch(Equipment): """A model of a set of individual Switches normally enclosed within the same cabinet and possibly with interlocks that restrict the combination of switch positions. These are typically found in medium voltage distribution networks. A CompositeSwitch could represent a Ring-Main-Unit (RMU), or pad-mounted switchgear, with primitive internal devices such as an internal bus-bar plus 3 or 4 internal switches each of which may individually be open or closed. A CompositeSwitch and a set of contained Switches can also be used to represent a multi-position switch e.g. a switch that can connect a circuit to Ground, Open or Busbar. """ - def __init__(self, compositeSwitchType='', Switches=None, **kw_args): - """Initializes a new 'CompositeSwitch' instance. + def __init__(self, compositeSwitchType='', Switches=None, *args, **kw_args): + """Initialises a new 'CompositeSwitch' instance. @param compositeSwitchType: An alphanumeric code that can be used as a reference to extar information such as the description of the interlocking scheme if any @param Switches: Switches contained in this Composite switch. @@ -32,7 +32,14 @@ class CompositeSwitch(Equipment): self._Switches = [] self.Switches = [] if Switches is None else Switches - super(CompositeSwitch, self).__init__(**kw_args) + super(CompositeSwitch, self).__init__(*args, **kw_args) + + _attrs = ["compositeSwitchType"] + _attr_types = {"compositeSwitchType": str} + _defaults = {"compositeSwitchType": ''} + _enums = {} + _refs = ["Switches"] + _many_refs = ["Switches"] def getSwitches(self): """Switches contained in this Composite switch. diff --git a/schemata/CIM14/IEC61970/Wires/Conductor.py b/schemata/CIM14/IEC61970/Wires/Conductor.py index b2e85ef..bb2c3a0 100644 --- a/schemata/CIM14/IEC61970/Wires/Conductor.py +++ b/schemata/CIM14/IEC61970/Wires/Conductor.py @@ -20,13 +20,20 @@ class Conductor(ConductingEquipment): """Combination of conducting material with consistent electrical characteristics, building a single electrical system, used to carry current between points in the power system. """ - def __init__(self, length=0.0, **kw_args): - """Initializes a new 'Conductor' instance. + def __init__(self, length=0.0, *args, **kw_args): + """Initialises a new 'Conductor' instance. @param length: Segment length for calculating line section capabilities """ #: Segment length for calculating line section capabilities self.length = length - super(Conductor, self).__init__(**kw_args) + super(Conductor, self).__init__(*args, **kw_args) + + _attrs = ["length"] + _attr_types = {"length": float} + _defaults = {"length": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Connector.py b/schemata/CIM14/IEC61970/Wires/Connector.py index 9d784ff..8835491 100644 --- a/schemata/CIM14/IEC61970/Wires/Connector.py +++ b/schemata/CIM14/IEC61970/Wires/Connector.py @@ -20,9 +20,16 @@ class Connector(ConductingEquipment): """A conductor, or group of conductors, with negligible impedance, that serve to connect other conducting equipment within a single substation and are modelled with a single logical terminal. """ - def __init__(self, **kw_args): - """Initializes a new 'Connector' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Connector' instance. """ - super(Connector, self).__init__(**kw_args) + super(Connector, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/DCLineSegment.py b/schemata/CIM14/IEC61970/Wires/DCLineSegment.py index 812a646..03f24ca 100644 --- a/schemata/CIM14/IEC61970/Wires/DCLineSegment.py +++ b/schemata/CIM14/IEC61970/Wires/DCLineSegment.py @@ -20,8 +20,8 @@ class DCLineSegment(Conductor): """A wire or combination of wires not insulated from one another, with consistent electrical characteristics, used to carry direct current between points in the DC region of the power system. """ - def __init__(self, dcSegmentInductance=0.0, dcSegmentResistance=0.0, **kw_args): - """Initializes a new 'DCLineSegment' instance. + def __init__(self, dcSegmentInductance=0.0, dcSegmentResistance=0.0, *args, **kw_args): + """Initialises a new 'DCLineSegment' instance. @param dcSegmentInductance: Inductance of the DC line segment. @param dcSegmentResistance: Resistance of the DC line segment. @@ -32,5 +32,12 @@ class DCLineSegment(Conductor): #: Resistance of the DC line segment. self.dcSegmentResistance = dcSegmentResistance - super(DCLineSegment, self).__init__(**kw_args) + super(DCLineSegment, self).__init__(*args, **kw_args) + + _attrs = ["dcSegmentInductance", "dcSegmentResistance"] + _attr_types = {"dcSegmentInductance": float, "dcSegmentResistance": float} + _defaults = {"dcSegmentInductance": 0.0, "dcSegmentResistance": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Disconnector.py b/schemata/CIM14/IEC61970/Wires/Disconnector.py index 87fea37..987b98e 100644 --- a/schemata/CIM14/IEC61970/Wires/Disconnector.py +++ b/schemata/CIM14/IEC61970/Wires/Disconnector.py @@ -20,9 +20,16 @@ class Disconnector(Switch): """A manually operated or motor operated mechanical switching device used for changing the connections in a circuit, or for isolating a circuit or equipment from a source of power. It is required to open or close circuits when negligible current is broken or made. """ - def __init__(self, **kw_args): - """Initializes a new 'Disconnector' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Disconnector' instance. """ - super(Disconnector, self).__init__(**kw_args) + super(Disconnector, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/EnergyConsumer.py b/schemata/CIM14/IEC61970/Wires/EnergyConsumer.py index 841eac2..ebf24ff 100644 --- a/schemata/CIM14/IEC61970/Wires/EnergyConsumer.py +++ b/schemata/CIM14/IEC61970/Wires/EnergyConsumer.py @@ -20,8 +20,8 @@ class EnergyConsumer(ConductingEquipment): """Generic user of energy - a point of consumption on the power system model """ - def __init__(self, customerCount=0, qfixedPct=0.0, pfixed=0.0, pfixedPct=0.0, qfixed=0.0, aggregateLoad0=None, PowerCutZone=None, ServiceDeliveryPoints=None, LoadResponse=None, **kw_args): - """Initializes a new 'EnergyConsumer' instance. + def __init__(self, customerCount=0, qfixedPct=0.0, pfixed=0.0, pfixedPct=0.0, qfixed=0.0, aggregateLoad0=None, PowerCutZone=None, ServiceDeliveryPoints=None, LoadResponse=None, *args, **kw_args): + """Initialises a new 'EnergyConsumer' instance. @param customerCount: Number of individual customers represented by this Demand @param qfixedPct: Fixed reactive power as per cent of load group fixed reactive power. @@ -60,7 +60,14 @@ class EnergyConsumer(ConductingEquipment): self._LoadResponse = None self.LoadResponse = LoadResponse - super(EnergyConsumer, self).__init__(**kw_args) + super(EnergyConsumer, self).__init__(*args, **kw_args) + + _attrs = ["customerCount", "qfixedPct", "pfixed", "pfixedPct", "qfixed"] + _attr_types = {"customerCount": int, "qfixedPct": float, "pfixed": float, "pfixedPct": float, "qfixed": float} + _defaults = {"customerCount": 0, "qfixedPct": 0.0, "pfixed": 0.0, "pfixedPct": 0.0, "qfixed": 0.0} + _enums = {} + _refs = ["aggregateLoad0", "PowerCutZone", "ServiceDeliveryPoints", "LoadResponse"] + _many_refs = ["aggregateLoad0", "ServiceDeliveryPoints"] def getaggregateLoad0(self): diff --git a/schemata/CIM14/IEC61970/Wires/EnergySource.py b/schemata/CIM14/IEC61970/Wires/EnergySource.py index 45b47ba..a9fbf22 100644 --- a/schemata/CIM14/IEC61970/Wires/EnergySource.py +++ b/schemata/CIM14/IEC61970/Wires/EnergySource.py @@ -20,8 +20,8 @@ class EnergySource(ConductingEquipment): """A generic equivalent for an energy supplier on a transmission or distribution voltage level. """ - def __init__(self, x=0.0, activePower=0.0, r=0.0, nominalVoltage=0.0, voltageMagnitude=0.0, xn=0.0, x0=0.0, rn=0.0, voltageAngle=0.0, r0=0.0, **kw_args): - """Initializes a new 'EnergySource' instance. + def __init__(self, x=0.0, activePower=0.0, r=0.0, nominalVoltage=0.0, voltageMagnitude=0.0, xn=0.0, x0=0.0, rn=0.0, voltageAngle=0.0, r0=0.0, *args, **kw_args): + """Initialises a new 'EnergySource' instance. @param x: Positive sequence Thevenin reactance. @param activePower: High voltage source load @@ -64,5 +64,12 @@ class EnergySource(ConductingEquipment): #: Zero sequence Thevenin resistance. self.r0 = r0 - super(EnergySource, self).__init__(**kw_args) + super(EnergySource, self).__init__(*args, **kw_args) + + _attrs = ["x", "activePower", "r", "nominalVoltage", "voltageMagnitude", "xn", "x0", "rn", "voltageAngle", "r0"] + _attr_types = {"x": float, "activePower": float, "r": float, "nominalVoltage": float, "voltageMagnitude": float, "xn": float, "x0": float, "rn": float, "voltageAngle": float, "r0": float} + _defaults = {"x": 0.0, "activePower": 0.0, "r": 0.0, "nominalVoltage": 0.0, "voltageMagnitude": 0.0, "xn": 0.0, "x0": 0.0, "rn": 0.0, "voltageAngle": 0.0, "r0": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/FrequencyConverter.py b/schemata/CIM14/IEC61970/Wires/FrequencyConverter.py index 616e9e7..40ac591 100644 --- a/schemata/CIM14/IEC61970/Wires/FrequencyConverter.py +++ b/schemata/CIM14/IEC61970/Wires/FrequencyConverter.py @@ -20,8 +20,8 @@ class FrequencyConverter(RegulatingCondEq): """A device to convert from one frequency to another (e.g., frequency F1 to F2) comprises a pair of FrequencyConverter instances. One converts from F1 to DC, the other converts the DC to F2. """ - def __init__(self, minU=0.0, maxU=0.0, maxP=0.0, minP=0.0, frequency=0.0, operatingMode='', **kw_args): - """Initializes a new 'FrequencyConverter' instance. + def __init__(self, minU=0.0, maxU=0.0, maxP=0.0, minP=0.0, frequency=0.0, operatingMode='', *args, **kw_args): + """Initialises a new 'FrequencyConverter' instance. @param minU: The minimum voltage on the DC side at which the frequency converter should operate. @param maxU: The maximum voltage on the DC side at which the frequency converter should operate. @@ -48,5 +48,12 @@ class FrequencyConverter(RegulatingCondEq): #: Operating mode for the frequency converter self.operatingMode = operatingMode - super(FrequencyConverter, self).__init__(**kw_args) + super(FrequencyConverter, self).__init__(*args, **kw_args) + + _attrs = ["minU", "maxU", "maxP", "minP", "frequency", "operatingMode"] + _attr_types = {"minU": float, "maxU": float, "maxP": float, "minP": float, "frequency": float, "operatingMode": str} + _defaults = {"minU": 0.0, "maxU": 0.0, "maxP": 0.0, "minP": 0.0, "frequency": 0.0, "operatingMode": ''} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Fuse.py b/schemata/CIM14/IEC61970/Wires/Fuse.py index f7f20c4..8c856b2 100644 --- a/schemata/CIM14/IEC61970/Wires/Fuse.py +++ b/schemata/CIM14/IEC61970/Wires/Fuse.py @@ -20,13 +20,20 @@ class Fuse(Switch): """An overcurrent protective device with a circuit opening fusible part that is heated and severed by the passage of overcurrent through it. A fuse is considered a switching device because it breaks current. """ - def __init__(self, ratingCurrent=0.0, **kw_args): - """Initializes a new 'Fuse' instance. + def __init__(self, ratingCurrent=0.0, *args, **kw_args): + """Initialises a new 'Fuse' instance. @param ratingCurrent: Fault interrupting current rating. """ #: Fault interrupting current rating. self.ratingCurrent = ratingCurrent - super(Fuse, self).__init__(**kw_args) + super(Fuse, self).__init__(*args, **kw_args) + + _attrs = ["ratingCurrent"] + _attr_types = {"ratingCurrent": float} + _defaults = {"ratingCurrent": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Ground.py b/schemata/CIM14/IEC61970/Wires/Ground.py index 4bf8590..f3e8c83 100644 --- a/schemata/CIM14/IEC61970/Wires/Ground.py +++ b/schemata/CIM14/IEC61970/Wires/Ground.py @@ -20,9 +20,16 @@ class Ground(ConductingEquipment): """A common point for connecting grounded conducting equipment such as shunt capacitors. The power system model can have more than one ground. """ - def __init__(self, **kw_args): - """Initializes a new 'Ground' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Ground' instance. """ - super(Ground, self).__init__(**kw_args) + super(Ground, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/GroundDisconnector.py b/schemata/CIM14/IEC61970/Wires/GroundDisconnector.py index f219638..86f493a 100644 --- a/schemata/CIM14/IEC61970/Wires/GroundDisconnector.py +++ b/schemata/CIM14/IEC61970/Wires/GroundDisconnector.py @@ -20,9 +20,16 @@ class GroundDisconnector(Switch): """A manually operated or motor operated mechanical switching device used for isolating a circuit or equipment from Ground. """ - def __init__(self, **kw_args): - """Initializes a new 'GroundDisconnector' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'GroundDisconnector' instance. """ - super(GroundDisconnector, self).__init__(**kw_args) + super(GroundDisconnector, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/HeatExchanger.py b/schemata/CIM14/IEC61970/Wires/HeatExchanger.py index 941a191..b120f82 100644 --- a/schemata/CIM14/IEC61970/Wires/HeatExchanger.py +++ b/schemata/CIM14/IEC61970/Wires/HeatExchanger.py @@ -20,15 +20,22 @@ class HeatExchanger(Equipment): """Equipment for the cooling of electrical equipment and the extraction of heat """ - def __init__(self, PowerTransformer=None, **kw_args): - """Initializes a new 'HeatExchanger' instance. + def __init__(self, PowerTransformer=None, *args, **kw_args): + """Initialises a new 'HeatExchanger' instance. @param PowerTransformer: A transformer may have a heat exchanger """ self._PowerTransformer = None self.PowerTransformer = PowerTransformer - super(HeatExchanger, self).__init__(**kw_args) + super(HeatExchanger, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["PowerTransformer"] + _many_refs = [] def getPowerTransformer(self): """A transformer may have a heat exchanger diff --git a/schemata/CIM14/IEC61970/Wires/ImpedanceVariationCurve.py b/schemata/CIM14/IEC61970/Wires/ImpedanceVariationCurve.py index f958921..caa26f8 100644 --- a/schemata/CIM14/IEC61970/Wires/ImpedanceVariationCurve.py +++ b/schemata/CIM14/IEC61970/Wires/ImpedanceVariationCurve.py @@ -20,15 +20,22 @@ class ImpedanceVariationCurve(Curve): """An Impedance Variation Curve describes the change in Transformer Winding impedance values in relationship to tap step changes. The tap step is represented using the xValue, resistance using y1value, reactance using y2value, and magnetizing susceptance using y3value. The resistance (r), reactance (x), and magnetizing susceptance (b) of the associated TransformerWinding define the impedance when the tap is at neutral step. The curve values represent the change to the impedance from the neutral step values. The impedance at a non-neutral step is calculated by adding the neutral step impedance (from the TransformerWinding) to the delta value from the curve. """ - def __init__(self, TapChanger=None, **kw_args): - """Initializes a new 'ImpedanceVariationCurve' instance. + def __init__(self, TapChanger=None, *args, **kw_args): + """Initialises a new 'ImpedanceVariationCurve' instance. @param TapChanger: An ImpedanceVariationCurve is defines impedance changes for a TapChanger. """ self._TapChanger = None self.TapChanger = TapChanger - super(ImpedanceVariationCurve, self).__init__(**kw_args) + super(ImpedanceVariationCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["TapChanger"] + _many_refs = [] def getTapChanger(self): """An ImpedanceVariationCurve is defines impedance changes for a TapChanger. diff --git a/schemata/CIM14/IEC61970/Wires/Jumper.py b/schemata/CIM14/IEC61970/Wires/Jumper.py index 61b1c74..caa7440 100644 --- a/schemata/CIM14/IEC61970/Wires/Jumper.py +++ b/schemata/CIM14/IEC61970/Wires/Jumper.py @@ -20,9 +20,16 @@ class Jumper(Switch): """A short section of conductor with negligible impedance which can be manually removed and replaced if the circuit is de-energized. Note that zero-impedance branches can be modelled by an ACLineSegment with a zero impedance ConductorType """ - def __init__(self, **kw_args): - """Initializes a new 'Jumper' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Jumper' instance. """ - super(Jumper, self).__init__(**kw_args) + super(Jumper, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Junction.py b/schemata/CIM14/IEC61970/Wires/Junction.py index 84b07c3..d0f8adb 100644 --- a/schemata/CIM14/IEC61970/Wires/Junction.py +++ b/schemata/CIM14/IEC61970/Wires/Junction.py @@ -20,9 +20,16 @@ class Junction(Connector): """A point where one or more conducting equipments are connected with zero resistance. """ - def __init__(self, **kw_args): - """Initializes a new 'Junction' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Junction' instance. """ - super(Junction, self).__init__(**kw_args) + super(Junction, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Line.py b/schemata/CIM14/IEC61970/Wires/Line.py index 557d20f..659abbe 100644 --- a/schemata/CIM14/IEC61970/Wires/Line.py +++ b/schemata/CIM14/IEC61970/Wires/Line.py @@ -20,15 +20,22 @@ class Line(EquipmentContainer): """Contains equipment beyond a substation belonging to a power transmission line. """ - def __init__(self, Region=None, **kw_args): - """Initializes a new 'Line' instance. + def __init__(self, Region=None, *args, **kw_args): + """Initialises a new 'Line' instance. @param Region: A Line can be contained by a SubGeographical Region. """ self._Region = None self.Region = Region - super(Line, self).__init__(**kw_args) + super(Line, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Region"] + _many_refs = [] def getRegion(self): """A Line can be contained by a SubGeographical Region. diff --git a/schemata/CIM14/IEC61970/Wires/LoadBreakSwitch.py b/schemata/CIM14/IEC61970/Wires/LoadBreakSwitch.py index c0e0de7..2f88311 100644 --- a/schemata/CIM14/IEC61970/Wires/LoadBreakSwitch.py +++ b/schemata/CIM14/IEC61970/Wires/LoadBreakSwitch.py @@ -20,13 +20,20 @@ class LoadBreakSwitch(ProtectedSwitch): """A mechanical switching device capable of making, carrying, and breaking currents under normal operating conditions. """ - def __init__(self, ratedCurrent=0.0, **kw_args): - """Initializes a new 'LoadBreakSwitch' instance. + def __init__(self, ratedCurrent=0.0, *args, **kw_args): + """Initialises a new 'LoadBreakSwitch' instance. @param ratedCurrent: Current carrying capacity of a wire or cable under stated thermal conditions. """ #: Current carrying capacity of a wire or cable under stated thermal conditions. self.ratedCurrent = ratedCurrent - super(LoadBreakSwitch, self).__init__(**kw_args) + super(LoadBreakSwitch, self).__init__(*args, **kw_args) + + _attrs = ["ratedCurrent"] + _attr_types = {"ratedCurrent": float} + _defaults = {"ratedCurrent": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/MutualCoupling.py b/schemata/CIM14/IEC61970/Wires/MutualCoupling.py index 31273ba..a411833 100644 --- a/schemata/CIM14/IEC61970/Wires/MutualCoupling.py +++ b/schemata/CIM14/IEC61970/Wires/MutualCoupling.py @@ -20,8 +20,8 @@ class MutualCoupling(IdentifiedObject): """This class represents the zero sequence line mutual coupling. """ - def __init__(self, distance22=0.0, g0ch=0.0, distance12=0.0, distance21=0.0, x0=0.0, b0ch=0.0, r0=0.0, distance11=0.0, Second_Terminal=None, First_Terminal=None, **kw_args): - """Initializes a new 'MutualCoupling' instance. + def __init__(self, distance22=0.0, g0ch=0.0, distance12=0.0, distance21=0.0, x0=0.0, b0ch=0.0, r0=0.0, distance11=0.0, Second_Terminal=None, First_Terminal=None, *args, **kw_args): + """Initialises a new 'MutualCoupling' instance. @param distance22: Distance from the second line's specified terminal to end of coupled region @param g0ch: Zero sequence mutual coupling shunt (charging) conductance, uniformly distributed, of the entire line section. @@ -64,7 +64,14 @@ class MutualCoupling(IdentifiedObject): self._First_Terminal = None self.First_Terminal = First_Terminal - super(MutualCoupling, self).__init__(**kw_args) + super(MutualCoupling, self).__init__(*args, **kw_args) + + _attrs = ["distance22", "g0ch", "distance12", "distance21", "x0", "b0ch", "r0", "distance11"] + _attr_types = {"distance22": float, "g0ch": float, "distance12": float, "distance21": float, "x0": float, "b0ch": float, "r0": float, "distance11": float} + _defaults = {"distance22": 0.0, "g0ch": 0.0, "distance12": 0.0, "distance21": 0.0, "x0": 0.0, "b0ch": 0.0, "r0": 0.0, "distance11": 0.0} + _enums = {} + _refs = ["Second_Terminal", "First_Terminal"] + _many_refs = [] def getSecond_Terminal(self): """The starting terminal for the calculation of distances along the second branch of the mutual coupling. diff --git a/schemata/CIM14/IEC61970/Wires/PhaseTapChanger.py b/schemata/CIM14/IEC61970/Wires/PhaseTapChanger.py index fd4a678..b43386e 100644 --- a/schemata/CIM14/IEC61970/Wires/PhaseTapChanger.py +++ b/schemata/CIM14/IEC61970/Wires/PhaseTapChanger.py @@ -20,8 +20,8 @@ class PhaseTapChanger(TapChanger): """A specialization of a voltage tap changer that has detailed modeling for phase shifting capabilities. A phase shifting tap changer is also in general a voltage magnitude transformer. The symmetrical and asymmetrical transformer tap changer models are defined here. """ - def __init__(self, phaseTapChangerType='asymmetrical', nominalVoltageOutOfPhase=0.0, xStepMin=0.0, stepPhaseShiftIncrement=0.0, windingConnectionAngle=0.0, xStepMax=0.0, voltageStepIncrementOutOfPhase=0.0, PhaseVariationCurve=None, Winding=None, TransformerWinding=None, **kw_args): - """Initializes a new 'PhaseTapChanger' instance. + def __init__(self, phaseTapChangerType="asymmetrical", nominalVoltageOutOfPhase=0.0, xStepMin=0.0, stepPhaseShiftIncrement=0.0, windingConnectionAngle=0.0, xStepMax=0.0, voltageStepIncrementOutOfPhase=0.0, PhaseVariationCurve=None, Winding=None, TransformerWinding=None, *args, **kw_args): + """Initialises a new 'PhaseTapChanger' instance. @param phaseTapChangerType: The type of phase shifter construction. Values are: "asymmetrical", "unknown", "symmetrical" @param nominalVoltageOutOfPhase: Similar to TapChanger.nominalVoltage, but this is the nominal voltage in the out of phase winding at the nominal tap step. A typical case may have zero voltage at the nominal step, indicating no phase shift at the nominal voltage. @@ -34,7 +34,7 @@ class PhaseTapChanger(TapChanger): @param Winding: Transformer winding to which this phase tap changer belongs. @param TransformerWinding: The transformer winding to which the phase tap changer belongs. """ - #: The type of phase shifter construction.Values are: "asymmetrical", "unknown", "symmetrical" + #: The type of phase shifter construction. Values are: "asymmetrical", "unknown", "symmetrical" self.phaseTapChangerType = phaseTapChangerType #: Similar to TapChanger.nominalVoltage, but this is the nominal voltage in the out of phase winding at the nominal tap step. A typical case may have zero voltage at the nominal step, indicating no phase shift at the nominal voltage. @@ -64,7 +64,14 @@ class PhaseTapChanger(TapChanger): self._TransformerWinding = None self.TransformerWinding = TransformerWinding - super(PhaseTapChanger, self).__init__(**kw_args) + super(PhaseTapChanger, self).__init__(*args, **kw_args) + + _attrs = ["phaseTapChangerType", "nominalVoltageOutOfPhase", "xStepMin", "stepPhaseShiftIncrement", "windingConnectionAngle", "xStepMax", "voltageStepIncrementOutOfPhase"] + _attr_types = {"phaseTapChangerType": str, "nominalVoltageOutOfPhase": float, "xStepMin": float, "stepPhaseShiftIncrement": float, "windingConnectionAngle": float, "xStepMax": float, "voltageStepIncrementOutOfPhase": float} + _defaults = {"phaseTapChangerType": "asymmetrical", "nominalVoltageOutOfPhase": 0.0, "xStepMin": 0.0, "stepPhaseShiftIncrement": 0.0, "windingConnectionAngle": 0.0, "xStepMax": 0.0, "voltageStepIncrementOutOfPhase": 0.0} + _enums = {"phaseTapChangerType": "PhaseTapChangerKind"} + _refs = ["PhaseVariationCurve", "Winding", "TransformerWinding"] + _many_refs = [] def getPhaseVariationCurve(self): """A PhaseTapChanger can have an associated PhaseVariationCurve to define phase shift variations with tap step changes. diff --git a/schemata/CIM14/IEC61970/Wires/PhaseVariationCurve.py b/schemata/CIM14/IEC61970/Wires/PhaseVariationCurve.py index bce7794..9b197bc 100644 --- a/schemata/CIM14/IEC61970/Wires/PhaseVariationCurve.py +++ b/schemata/CIM14/IEC61970/Wires/PhaseVariationCurve.py @@ -20,15 +20,22 @@ class PhaseVariationCurve(Curve): """A Phase Variation Curve describes the phase shift in relationship to tap step changes. The tap step is represented using the xValue and the phase shift using y1value. """ - def __init__(self, PhaseTapChanger=None, **kw_args): - """Initializes a new 'PhaseVariationCurve' instance. + def __init__(self, PhaseTapChanger=None, *args, **kw_args): + """Initialises a new 'PhaseVariationCurve' instance. @param PhaseTapChanger: A PhaseVariationCurve defines phase shift changes for a PhaseTapChanger. """ self._PhaseTapChanger = None self.PhaseTapChanger = PhaseTapChanger - super(PhaseVariationCurve, self).__init__(**kw_args) + super(PhaseVariationCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["PhaseTapChanger"] + _many_refs = [] def getPhaseTapChanger(self): """A PhaseVariationCurve defines phase shift changes for a PhaseTapChanger. diff --git a/schemata/CIM14/IEC61970/Wires/Plant.py b/schemata/CIM14/IEC61970/Wires/Plant.py index 4ab6aa4..9532041 100644 --- a/schemata/CIM14/IEC61970/Wires/Plant.py +++ b/schemata/CIM14/IEC61970/Wires/Plant.py @@ -20,9 +20,16 @@ class Plant(EquipmentContainer): """A Plant is a collection of equipment for purposes of generation. """ - def __init__(self, **kw_args): - """Initializes a new 'Plant' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Plant' instance. """ - super(Plant, self).__init__(**kw_args) + super(Plant, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/PowerTransformer.py b/schemata/CIM14/IEC61970/Wires/PowerTransformer.py index f9d3b2d..c9b3e38 100644 --- a/schemata/CIM14/IEC61970/Wires/PowerTransformer.py +++ b/schemata/CIM14/IEC61970/Wires/PowerTransformer.py @@ -20,8 +20,8 @@ class PowerTransformer(Equipment): """An electrical device consisting of two or more coupled windings, with or without a magnetic core, for introducing mutual coupling between electric circuits. Transformers can be used to control voltage and phase shift (active power flow). """ - def __init__(self, magSatFlux=0.0, magBaseU=0.0, bmagSat=0.0, TransformerWindings=None, HeatExchanger=None, **kw_args): - """Initializes a new 'PowerTransformer' instance. + def __init__(self, magSatFlux=0.0, magBaseU=0.0, bmagSat=0.0, TransformerWindings=None, HeatExchanger=None, *args, **kw_args): + """Initialises a new 'PowerTransformer' instance. @param magSatFlux: Core magnetizing saturation curve knee flux level. @param magBaseU: The reference voltage at which the magnetizing saturation measurements were made @@ -44,7 +44,14 @@ class PowerTransformer(Equipment): self._HeatExchanger = None self.HeatExchanger = HeatExchanger - super(PowerTransformer, self).__init__(**kw_args) + super(PowerTransformer, self).__init__(*args, **kw_args) + + _attrs = ["magSatFlux", "magBaseU", "bmagSat"] + _attr_types = {"magSatFlux": float, "magBaseU": float, "bmagSat": float} + _defaults = {"magSatFlux": 0.0, "magBaseU": 0.0, "bmagSat": 0.0} + _enums = {} + _refs = ["TransformerWindings", "HeatExchanger"] + _many_refs = ["TransformerWindings"] def getTransformerWindings(self): """A transformer has windings diff --git a/schemata/CIM14/IEC61970/Wires/ProtectedSwitch.py b/schemata/CIM14/IEC61970/Wires/ProtectedSwitch.py index 6c326f5..ca75119 100644 --- a/schemata/CIM14/IEC61970/Wires/ProtectedSwitch.py +++ b/schemata/CIM14/IEC61970/Wires/ProtectedSwitch.py @@ -20,15 +20,22 @@ class ProtectedSwitch(Switch): """A ProtectedSwitch is a switching device that can be operated by ProtectionEquipment. """ - def __init__(self, RecloseSequences=None, **kw_args): - """Initializes a new 'ProtectedSwitch' instance. + def __init__(self, RecloseSequences=None, *args, **kw_args): + """Initialises a new 'ProtectedSwitch' instance. @param RecloseSequences: A breaker may have zero or more automatic reclosures after a trip occurs. """ self._RecloseSequences = [] self.RecloseSequences = [] if RecloseSequences is None else RecloseSequences - super(ProtectedSwitch, self).__init__(**kw_args) + super(ProtectedSwitch, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["RecloseSequences"] + _many_refs = ["RecloseSequences"] def getRecloseSequences(self): """A breaker may have zero or more automatic reclosures after a trip occurs. diff --git a/schemata/CIM14/IEC61970/Wires/RatioTapChanger.py b/schemata/CIM14/IEC61970/Wires/RatioTapChanger.py index c196de8..f980e87 100644 --- a/schemata/CIM14/IEC61970/Wires/RatioTapChanger.py +++ b/schemata/CIM14/IEC61970/Wires/RatioTapChanger.py @@ -20,15 +20,15 @@ class RatioTapChanger(TapChanger): """A tap changer that changes the voltage ratio impacting the voltage magnitude but not direclty the phase angle across the transformer.. """ - def __init__(self, tculControlMode='volt', Winding=None, TransformerWinding=None, RatioVariationCurve=None, **kw_args): - """Initializes a new 'RatioTapChanger' instance. + def __init__(self, tculControlMode="volt", Winding=None, TransformerWinding=None, RatioVariationCurve=None, *args, **kw_args): + """Initialises a new 'RatioTapChanger' instance. @param tculControlMode: Specifies the regulation control mode (voltage or reactive) of the RatioTapChanger. Values are: "volt", "reactive" @param Winding: Winding to which this ratio tap changer belongs. @param TransformerWinding: The transformer winding to which the ratio tap changer belongs. @param RatioVariationCurve: A RatioTapChanger can have an associated RatioVariationCurve to define tap ratio variations with tap step changes. """ - #: Specifies the regulation control mode (voltage or reactive) of the RatioTapChanger.Values are: "volt", "reactive" + #: Specifies the regulation control mode (voltage or reactive) of the RatioTapChanger. Values are: "volt", "reactive" self.tculControlMode = tculControlMode self._Winding = None @@ -40,7 +40,14 @@ class RatioTapChanger(TapChanger): self._RatioVariationCurve = None self.RatioVariationCurve = RatioVariationCurve - super(RatioTapChanger, self).__init__(**kw_args) + super(RatioTapChanger, self).__init__(*args, **kw_args) + + _attrs = ["tculControlMode"] + _attr_types = {"tculControlMode": str} + _defaults = {"tculControlMode": "volt"} + _enums = {"tculControlMode": "TransformerControlMode"} + _refs = ["Winding", "TransformerWinding", "RatioVariationCurve"] + _many_refs = [] def getWinding(self): """Winding to which this ratio tap changer belongs. diff --git a/schemata/CIM14/IEC61970/Wires/RatioVariationCurve.py b/schemata/CIM14/IEC61970/Wires/RatioVariationCurve.py index e0354f9..fc74440 100644 --- a/schemata/CIM14/IEC61970/Wires/RatioVariationCurve.py +++ b/schemata/CIM14/IEC61970/Wires/RatioVariationCurve.py @@ -20,15 +20,22 @@ class RatioVariationCurve(Curve): """A Ratio Variation Curve describes the change in tap ratio in relationship to tap step changes. The tap step is represented using the xValue and the ratio using y1value. """ - def __init__(self, RatioTapChanger=None, **kw_args): - """Initializes a new 'RatioVariationCurve' instance. + def __init__(self, RatioTapChanger=None, *args, **kw_args): + """Initialises a new 'RatioVariationCurve' instance. @param RatioTapChanger: A RatioVariationCurve defines tap ratio changes for a RatioTapChanger. """ self._RatioTapChanger = None self.RatioTapChanger = RatioTapChanger - super(RatioVariationCurve, self).__init__(**kw_args) + super(RatioVariationCurve, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["RatioTapChanger"] + _many_refs = [] def getRatioTapChanger(self): """A RatioVariationCurve defines tap ratio changes for a RatioTapChanger. diff --git a/schemata/CIM14/IEC61970/Wires/ReactiveCapabilityCurve.py b/schemata/CIM14/IEC61970/Wires/ReactiveCapabilityCurve.py index 642acec..3defa0f 100644 --- a/schemata/CIM14/IEC61970/Wires/ReactiveCapabilityCurve.py +++ b/schemata/CIM14/IEC61970/Wires/ReactiveCapabilityCurve.py @@ -20,8 +20,8 @@ class ReactiveCapabilityCurve(Curve): """Reactive power rating envelope versus the synchronous machine's active power, in both the generating and motoring modes. For each active power value there is a corresponding high and low reactive power limit value. Typically there will be a separate curve for each coolant condition, such as hydrogen pressure. The Y1 axis values represent reactive minimum and the Y2 axis values represent reactive maximum. """ - def __init__(self, coolantTemperature=0.0, hydrogenPressure=0.0, InitiallyUsedBySynchronousMachines=None, SynchronousMachines=None, **kw_args): - """Initializes a new 'ReactiveCapabilityCurve' instance. + def __init__(self, coolantTemperature=0.0, hydrogenPressure=0.0, InitiallyUsedBySynchronousMachines=None, SynchronousMachines=None, *args, **kw_args): + """Initialises a new 'ReactiveCapabilityCurve' instance. @param coolantTemperature: The machine's coolant temperature (e.g., ambient air or stator circulating water). @param hydrogenPressure: The hydrogen coolant pressure @@ -40,7 +40,14 @@ class ReactiveCapabilityCurve(Curve): self._SynchronousMachines = [] self.SynchronousMachines = [] if SynchronousMachines is None else SynchronousMachines - super(ReactiveCapabilityCurve, self).__init__(**kw_args) + super(ReactiveCapabilityCurve, self).__init__(*args, **kw_args) + + _attrs = ["coolantTemperature", "hydrogenPressure"] + _attr_types = {"coolantTemperature": float, "hydrogenPressure": float} + _defaults = {"coolantTemperature": 0.0, "hydrogenPressure": 0.0} + _enums = {} + _refs = ["InitiallyUsedBySynchronousMachines", "SynchronousMachines"] + _many_refs = ["InitiallyUsedBySynchronousMachines", "SynchronousMachines"] def getInitiallyUsedBySynchronousMachines(self): """Synchronous machines using this curve as default. diff --git a/schemata/CIM14/IEC61970/Wires/RectifierInverter.py b/schemata/CIM14/IEC61970/Wires/RectifierInverter.py index 2910035..2d1cfbf 100644 --- a/schemata/CIM14/IEC61970/Wires/RectifierInverter.py +++ b/schemata/CIM14/IEC61970/Wires/RectifierInverter.py @@ -20,8 +20,8 @@ class RectifierInverter(ConductingEquipment): """Bi-directional AC-DC conversion equipment that can be used to control DC current, DC voltage, DC power flow, or firing angle. """ - def __init__(self, ratedU=0.0, compoundResistance=0.0, frequency=0.0, minCompoundVoltage=0.0, minP=0.0, maxP=0.0, operatingMode='', commutatingResistance=0.0, bridges=0, maxU=0.0, commutatingReactance=0.0, minU=0.0, **kw_args): - """Initializes a new 'RectifierInverter' instance. + def __init__(self, ratedU=0.0, compoundResistance=0.0, frequency=0.0, minCompoundVoltage=0.0, minP=0.0, maxP=0.0, operatingMode='', commutatingResistance=0.0, bridges=0, maxU=0.0, commutatingReactance=0.0, minU=0.0, *args, **kw_args): + """Initialises a new 'RectifierInverter' instance. @param ratedU: Rectifier/inverter primary base voltage @param compoundResistance: Compounding resistance. @@ -72,5 +72,12 @@ class RectifierInverter(ConductingEquipment): #: The minimum voltage on the DC side at which the converter should operate. self.minU = minU - super(RectifierInverter, self).__init__(**kw_args) + super(RectifierInverter, self).__init__(*args, **kw_args) + + _attrs = ["ratedU", "compoundResistance", "frequency", "minCompoundVoltage", "minP", "maxP", "operatingMode", "commutatingResistance", "bridges", "maxU", "commutatingReactance", "minU"] + _attr_types = {"ratedU": float, "compoundResistance": float, "frequency": float, "minCompoundVoltage": float, "minP": float, "maxP": float, "operatingMode": str, "commutatingResistance": float, "bridges": int, "maxU": float, "commutatingReactance": float, "minU": float} + _defaults = {"ratedU": 0.0, "compoundResistance": 0.0, "frequency": 0.0, "minCompoundVoltage": 0.0, "minP": 0.0, "maxP": 0.0, "operatingMode": '', "commutatingResistance": 0.0, "bridges": 0, "maxU": 0.0, "commutatingReactance": 0.0, "minU": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/RegulatingCondEq.py b/schemata/CIM14/IEC61970/Wires/RegulatingCondEq.py index 37877cd..e877843 100644 --- a/schemata/CIM14/IEC61970/Wires/RegulatingCondEq.py +++ b/schemata/CIM14/IEC61970/Wires/RegulatingCondEq.py @@ -20,8 +20,8 @@ class RegulatingCondEq(ConductingEquipment): """A type of conducting equipment that can regulate a quanity (i.e. voltage or flow) at a specific point in the network. """ - def __init__(self, Controls=None, RegulatingControl=None, **kw_args): - """Initializes a new 'RegulatingCondEq' instance. + def __init__(self, Controls=None, RegulatingControl=None, *args, **kw_args): + """Initialises a new 'RegulatingCondEq' instance. @param Controls: The controller outputs used to actually govern a regulating device, e.g. the magnetization of a synchronous machine or capacitor bank breaker actuator. @param RegulatingControl: The regulating control scheme in which this equipment participates. @@ -32,7 +32,14 @@ class RegulatingCondEq(ConductingEquipment): self._RegulatingControl = None self.RegulatingControl = RegulatingControl - super(RegulatingCondEq, self).__init__(**kw_args) + super(RegulatingCondEq, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Controls", "RegulatingControl"] + _many_refs = ["Controls"] def getControls(self): """The controller outputs used to actually govern a regulating device, e.g. the magnetization of a synchronous machine or capacitor bank breaker actuator. diff --git a/schemata/CIM14/IEC61970/Wires/RegulatingControl.py b/schemata/CIM14/IEC61970/Wires/RegulatingControl.py index e24bb1c..5a9076d 100644 --- a/schemata/CIM14/IEC61970/Wires/RegulatingControl.py +++ b/schemata/CIM14/IEC61970/Wires/RegulatingControl.py @@ -20,8 +20,8 @@ class RegulatingControl(PowerSystemResource): """Specifies a set of equipment that works together to control a power system quantity such as voltage or flow. """ - def __init__(self, mode='fixed', targetRange=0.0, discrete=False, targetValue=0.0, RegulationSchedule=None, Terminal=None, TapChanger=None, RegulatingCondEq=None, **kw_args): - """Initializes a new 'RegulatingControl' instance. + def __init__(self, mode="fixed", targetRange=0.0, discrete=False, targetValue=0.0, RegulationSchedule=None, Terminal=None, TapChanger=None, RegulatingCondEq=None, *args, **kw_args): + """Initialises a new 'RegulatingControl' instance. @param mode: The regulating control mode presently available. This specifications allows for determining the kind of regualation without need for obtaining the units from a schedule. Values are: "fixed", "voltage", "timeScheduled", "currentFlow", "admittance", "powerFactor", "activePower", "reactivePower", "temperature" @param targetRange: This is the case input target range. This performs the same function as the value2 attribute on the regulation schedule in the case that schedules are not used. The units of those appropriate for the mode. @@ -32,7 +32,7 @@ class RegulatingControl(PowerSystemResource): @param TapChanger: copy from reg conduting eq @param RegulatingCondEq: The equipment that participates in this regulating control scheme. """ - #: The regulating control mode presently available. This specifications allows for determining the kind of regualation without need for obtaining the units from a schedule.Values are: "fixed", "voltage", "timeScheduled", "currentFlow", "admittance", "powerFactor", "activePower", "reactivePower", "temperature" + #: The regulating control mode presently available. This specifications allows for determining the kind of regualation without need for obtaining the units from a schedule. Values are: "fixed", "voltage", "timeScheduled", "currentFlow", "admittance", "powerFactor", "activePower", "reactivePower", "temperature" self.mode = mode #: This is the case input target range. This performs the same function as the value2 attribute on the regulation schedule in the case that schedules are not used. The units of those appropriate for the mode. @@ -56,7 +56,14 @@ class RegulatingControl(PowerSystemResource): self._RegulatingCondEq = [] self.RegulatingCondEq = [] if RegulatingCondEq is None else RegulatingCondEq - super(RegulatingControl, self).__init__(**kw_args) + super(RegulatingControl, self).__init__(*args, **kw_args) + + _attrs = ["mode", "targetRange", "discrete", "targetValue"] + _attr_types = {"mode": str, "targetRange": float, "discrete": bool, "targetValue": float} + _defaults = {"mode": "fixed", "targetRange": 0.0, "discrete": False, "targetValue": 0.0} + _enums = {"mode": "RegulatingControlModeKind"} + _refs = ["RegulationSchedule", "Terminal", "TapChanger", "RegulatingCondEq"] + _many_refs = ["RegulationSchedule", "TapChanger", "RegulatingCondEq"] def getRegulationSchedule(self): """Schedule for this Regulating regulating control. diff --git a/schemata/CIM14/IEC61970/Wires/RegulationSchedule.py b/schemata/CIM14/IEC61970/Wires/RegulationSchedule.py index cc415c4..99b65ad 100644 --- a/schemata/CIM14/IEC61970/Wires/RegulationSchedule.py +++ b/schemata/CIM14/IEC61970/Wires/RegulationSchedule.py @@ -20,8 +20,8 @@ class RegulationSchedule(SeasonDayTypeSchedule): """A pre-established pattern over time for a controlled variable, e.g., busbar voltage. """ - def __init__(self, lineDropX=0.0, lineDropR=0.0, lineDropCompensation=False, RegulatingControl=None, VoltageControlZones=None, **kw_args): - """Initializes a new 'RegulationSchedule' instance. + def __init__(self, lineDropX=0.0, lineDropR=0.0, lineDropCompensation=False, RegulatingControl=None, VoltageControlZones=None, *args, **kw_args): + """Initialises a new 'RegulationSchedule' instance. @param lineDropX: Line drop reactance. @param lineDropR: Line drop resistance. @@ -44,7 +44,14 @@ class RegulationSchedule(SeasonDayTypeSchedule): self._VoltageControlZones = [] self.VoltageControlZones = [] if VoltageControlZones is None else VoltageControlZones - super(RegulationSchedule, self).__init__(**kw_args) + super(RegulationSchedule, self).__init__(*args, **kw_args) + + _attrs = ["lineDropX", "lineDropR", "lineDropCompensation"] + _attr_types = {"lineDropX": float, "lineDropR": float, "lineDropCompensation": bool} + _defaults = {"lineDropX": 0.0, "lineDropR": 0.0, "lineDropCompensation": False} + _enums = {} + _refs = ["RegulatingControl", "VoltageControlZones"] + _many_refs = ["VoltageControlZones"] def getRegulatingControl(self): """Regulating controls that have this Schedule. diff --git a/schemata/CIM14/IEC61970/Wires/Resistor.py b/schemata/CIM14/IEC61970/Wires/Resistor.py index c9ffa4b..bd0e258 100644 --- a/schemata/CIM14/IEC61970/Wires/Resistor.py +++ b/schemata/CIM14/IEC61970/Wires/Resistor.py @@ -20,9 +20,16 @@ class Resistor(ConductingEquipment): """Resistor, typically used in filter configurations or as earthing resistor for transformers. Used for electrical model of distribution networks. """ - def __init__(self, **kw_args): - """Initializes a new 'Resistor' instance. + def __init__(self, *args, **kw_args): + """Initialises a new 'Resistor' instance. """ - super(Resistor, self).__init__(**kw_args) + super(Resistor, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/SeriesCompensator.py b/schemata/CIM14/IEC61970/Wires/SeriesCompensator.py index ec62994..d4ebbfa 100644 --- a/schemata/CIM14/IEC61970/Wires/SeriesCompensator.py +++ b/schemata/CIM14/IEC61970/Wires/SeriesCompensator.py @@ -20,8 +20,8 @@ class SeriesCompensator(ConductingEquipment): """A Series Compensator is a series capacitor or reactor or an AC transmission line without charging susceptance. It is a two terminal device. """ - def __init__(self, r=0.0, x=0.0, **kw_args): - """Initializes a new 'SeriesCompensator' instance. + def __init__(self, r=0.0, x=0.0, *args, **kw_args): + """Initialises a new 'SeriesCompensator' instance. @param r: Positive sequence resistance. @param x: Positive sequence reactance. @@ -32,5 +32,12 @@ class SeriesCompensator(ConductingEquipment): #: Positive sequence reactance. self.x = x - super(SeriesCompensator, self).__init__(**kw_args) + super(SeriesCompensator, self).__init__(*args, **kw_args) + + _attrs = ["r", "x"] + _attr_types = {"r": float, "x": float} + _defaults = {"r": 0.0, "x": 0.0} + _enums = {} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/ShuntCompensator.py b/schemata/CIM14/IEC61970/Wires/ShuntCompensator.py index 4ef908b..fa87ab1 100644 --- a/schemata/CIM14/IEC61970/Wires/ShuntCompensator.py +++ b/schemata/CIM14/IEC61970/Wires/ShuntCompensator.py @@ -20,8 +20,8 @@ class ShuntCompensator(RegulatingCondEq): """A shunt capacitor or reactor or switchable bank of shunt capacitors or reactors. A section of a shunt compensator is an individual capacitor or reactor. A negative value for reactivePerSection indicates that the compensator is a reactor. ShuntCompensator is a single terminal device. Ground is implied. """ - def __init__(self, maxU=0.0, reactivePerSection=0.0, aVRDelay=0.0, voltageSensitivity=0.0, normalSections=0, g0PerSection=0.0, maximumSections=0, bPerSection=0.0, nomQ=0.0, switchOnCount=0, minU=0.0, b0PerSection=0.0, switchOnDate='', nomU=0.0, gPerSection=0.0, SvShuntCompensatorSections=None, **kw_args): - """Initializes a new 'ShuntCompensator' instance. + def __init__(self, maxU=0.0, reactivePerSection=0.0, aVRDelay=0.0, voltageSensitivity=0.0, normalSections=0, g0PerSection=0.0, maximumSections=0, bPerSection=0.0, nomQ=0.0, switchOnCount=0, minU=0.0, b0PerSection=0.0, switchOnDate='', nomU=0.0, gPerSection=0.0, SvShuntCompensatorSections=None, *args, **kw_args): + """Initialises a new 'ShuntCompensator' instance. @param maxU: The maximum voltage at which the capacitor bank should operate. @param reactivePerSection: For a capacitor bank, the size in reactive power of each switchable section at the nominal voltage. @@ -88,7 +88,14 @@ class ShuntCompensator(RegulatingCondEq): self._SvShuntCompensatorSections = None self.SvShuntCompensatorSections = SvShuntCompensatorSections - super(ShuntCompensator, self).__init__(**kw_args) + super(ShuntCompensator, self).__init__(*args, **kw_args) + + _attrs = ["maxU", "reactivePerSection", "aVRDelay", "voltageSensitivity", "normalSections", "g0PerSection", "maximumSections", "bPerSection", "nomQ", "switchOnCount", "minU", "b0PerSection", "switchOnDate", "nomU", "gPerSection"] + _attr_types = {"maxU": float, "reactivePerSection": float, "aVRDelay": float, "voltageSensitivity": float, "normalSections": int, "g0PerSection": float, "maximumSections": int, "bPerSection": float, "nomQ": float, "switchOnCount": int, "minU": float, "b0PerSection": float, "switchOnDate": str, "nomU": float, "gPerSection": float} + _defaults = {"maxU": 0.0, "reactivePerSection": 0.0, "aVRDelay": 0.0, "voltageSensitivity": 0.0, "normalSections": 0, "g0PerSection": 0.0, "maximumSections": 0, "bPerSection": 0.0, "nomQ": 0.0, "switchOnCount": 0, "minU": 0.0, "b0PerSection": 0.0, "switchOnDate": '', "nomU": 0.0, "gPerSection": 0.0} + _enums = {} + _refs = ["SvShuntCompensatorSections"] + _many_refs = [] def getSvShuntCompensatorSections(self): """The state for the number of shunt compensator sections in service. diff --git a/schemata/CIM14/IEC61970/Wires/StaticVarCompensator.py b/schemata/CIM14/IEC61970/Wires/StaticVarCompensator.py index 8f36113..8b26cbb 100644 --- a/schemata/CIM14/IEC61970/Wires/StaticVarCompensator.py +++ b/schemata/CIM14/IEC61970/Wires/StaticVarCompensator.py @@ -20,8 +20,8 @@ class StaticVarCompensator(RegulatingCondEq): """A facility for providing variable and controllable shunt reactive power. The SVC typically consists of a stepdown transformer, filter, thyristor-controlled reactor, and thyristor-switched capacitor arms. The SVC may operate in fixed MVar output mode or in voltage control mode. When in voltage control mode, the output of the SVC will be proportional to the deviation of voltage at the controlled bus from the voltage setpoint. The SVC characteristic slope defines the proportion. If the voltage at the controlled bus is equal to the voltage setpoint, the SVC MVar output is zero. """ - def __init__(self, sVCControlMode='reactivePower', voltageSetPoint=0.0, capacitiveRating=0.0, inductiveRating=0.0, slope=0.0, **kw_args): - """Initializes a new 'StaticVarCompensator' instance. + def __init__(self, sVCControlMode="reactivePower", voltageSetPoint=0.0, capacitiveRating=0.0, inductiveRating=0.0, slope=0.0, *args, **kw_args): + """Initialises a new 'StaticVarCompensator' instance. @param sVCControlMode: SVC control mode. Values are: "reactivePower", "off", "voltage" @param voltageSetPoint: The reactive power output of the SVC is proportional to the difference between the voltage at the regulated bus and the voltage setpoint. When the regulated bus voltage is equal to the voltage setpoint, the reactive power output is zero. @@ -29,7 +29,7 @@ class StaticVarCompensator(RegulatingCondEq): @param inductiveRating: Maximum available inductive reactive power @param slope: The characteristics slope of an SVC defines how the reactive power output changes in proportion to the difference between the regulated bus voltage and the voltage setpoint. """ - #: SVC control mode.Values are: "reactivePower", "off", "voltage" + #: SVC control mode. Values are: "reactivePower", "off", "voltage" self.sVCControlMode = sVCControlMode #: The reactive power output of the SVC is proportional to the difference between the voltage at the regulated bus and the voltage setpoint. When the regulated bus voltage is equal to the voltage setpoint, the reactive power output is zero. @@ -44,5 +44,12 @@ class StaticVarCompensator(RegulatingCondEq): #: The characteristics slope of an SVC defines how the reactive power output changes in proportion to the difference between the regulated bus voltage and the voltage setpoint. self.slope = slope - super(StaticVarCompensator, self).__init__(**kw_args) + super(StaticVarCompensator, self).__init__(*args, **kw_args) + + _attrs = ["sVCControlMode", "voltageSetPoint", "capacitiveRating", "inductiveRating", "slope"] + _attr_types = {"sVCControlMode": str, "voltageSetPoint": float, "capacitiveRating": float, "inductiveRating": float, "slope": float} + _defaults = {"sVCControlMode": "reactivePower", "voltageSetPoint": 0.0, "capacitiveRating": 0.0, "inductiveRating": 0.0, "slope": 0.0} + _enums = {"sVCControlMode": "SVCControlMode"} + _refs = [] + _many_refs = [] diff --git a/schemata/CIM14/IEC61970/Wires/Switch.py b/schemata/CIM14/IEC61970/Wires/Switch.py index e46db52..a981bdb 100644 --- a/schemata/CIM14/IEC61970/Wires/Switch.py +++ b/schemata/CIM14/IEC61970/Wires/Switch.py @@ -20,8 +20,8 @@ class Switch(ConductingEquipment): """A generic device designed to close, or open, or both, one or more electric circuits. """ - def __init__(self, switchOnCount=0, switchOnDate='', retained=False, normalOpen=False, SwitchingOperations=None, CompositeSwitch=None, ConnectDisconnectFunctions=None, SwitchSchedules=None, **kw_args): - """Initializes a new 'Switch' instance. + def __init__(self, switchOnCount=0, switchOnDate='', retained=False, normalOpen=False, SwitchingOperations=None, CompositeSwitch=None, ConnectDisconnectFunctions=None, SwitchSchedules=None, *args, **kw_args): + """Initialises a new 'Switch' instance. @param switchOnCount: The switch on count since the switch was last reset or initialized. @param switchOnDate: The date and time when the switch was last switched on. @@ -56,7 +56,14 @@ class Switch(ConductingEquipment): self._SwitchSchedules = [] self.SwitchSchedules = [] if SwitchSchedules is None else SwitchSchedules - super(Switch, self).__init__(**kw_args) + super(Switch, self).__init__(*args, **kw_args) + + _attrs = ["switchOnCount", "switchOnDate", "retained", "normalOpen"] + _attr_types = {"switchOnCount": int, "switchOnDate": str, "retained": bool, "normalOpen": bool} + _defaults = {"switchOnCount": 0, "switchOnDate": '', "retained": False, "normalOpen": False} + _enums = {} + _refs = ["SwitchingOperations", "CompositeSwitch", "ConnectDisconnectFunctions", "SwitchSchedules"] + _many_refs = ["SwitchingOperations", "ConnectDisconnectFunctions", "SwitchSchedules"] def getSwitchingOperations(self): """A switch may be operated by many schedules. diff --git a/schemata/CIM14/IEC61970/Wires/SwitchSchedule.py b/schemata/CIM14/IEC61970/Wires/SwitchSchedule.py index 31131cc..8f36cc6 100644 --- a/schemata/CIM14/IEC61970/Wires/SwitchSchedule.py +++ b/schemata/CIM14/IEC61970/Wires/SwitchSchedule.py @@ -20,15 +20,22 @@ class SwitchSchedule(SeasonDayTypeSchedule): """A schedule of switch positions. If RegularTimePoint.value1 is 0, the switch is open. If 1, the switch is closed. """ - def __init__(self, Switch=None, **kw_args): - """Initializes a new 'SwitchSchedule' instance. + def __init__(self, Switch=None, *args, **kw_args): + """Initialises a new 'SwitchSchedule' instance. @param Switch: A SwitchSchedule is associated with a Switch. """ self._Switch = None self.Switch = Switch - super(SwitchSchedule, self).__init__(**kw_args) + super(SwitchSchedule, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["Switch"] + _many_refs = [] def getSwitch(self): """A SwitchSchedule is associated with a Switch. diff --git a/schemata/CIM14/IEC61970/Wires/SynchronousMachine.py b/schemata/CIM14/IEC61970/Wires/SynchronousMachine.py index 265bed0..fc37466 100644 --- a/schemata/CIM14/IEC61970/Wires/SynchronousMachine.py +++ b/schemata/CIM14/IEC61970/Wires/SynchronousMachine.py @@ -20,8 +20,8 @@ class SynchronousMachine(RotatingMachine): """An electromechanical device that operates synchronously with the network. It is a single machine operating either as a generator or synchronous condenser or pump. """ - def __init__(self, operatingMode='condenser', type='generator_or_condenser', coolantType='air', xQuadTrans=0.0, condenserP=0.0, referencePriority=0, damping=0.0, x0=0.0, r2=0.0, minQ=0.0, xDirectSync=0.0, maxQ=0.0, r0=0.0, aVRToManualLead=0.0, x=0.0, inertia=0.0, coolantCondition=0.0, manualToAVR=0.0, r=0.0, maxU=0.0, xQuadSync=0.0, qPercent=0.0, xQuadSubtrans=0.0, minU=0.0, aVRToManualLag=0.0, baseQ=0.0, xDirectTrans=0.0, x2=0.0, xDirectSubtrans=0.0, genLoad0=None, HydroPump=None, GeneratingUnit=None, govHydro10=None, PrimeMovers=None, InitialReactiveCapabilityCurve=None, genEquiv0=None, ReactiveCapabilityCurves=None, **kw_args): - """Initializes a new 'SynchronousMachine' instance. + def __init__(self, operatingMode="condenser", type="generator_or_condenser", coolantType="air", xQuadTrans=0.0, condenserP=0.0, referencePriority=0, damping=0.0, x0=0.0, r2=0.0, minQ=0.0, xDirectSync=0.0, maxQ=0.0, r0=0.0, aVRToManualLead=0.0, x=0.0, inertia=0.0, coolantCondition=0.0, manualToAVR=0.0, r=0.0, maxU=0.0, xQuadSync=0.0, qPercent=0.0, xQuadSubtrans=0.0, minU=0.0, aVRToManualLag=0.0, baseQ=0.0, xDirectTrans=0.0, x2=0.0, xDirectSubtrans=0.0, genLoad0=None, HydroPump=None, GeneratingUnit=None, govHydro10=None, PrimeMovers=None, InitialReactiveCapabilityCurve=None, genEquiv0=None, ReactiveCapabilityCurves=None, *args, **kw_args): + """Initialises a new 'SynchronousMachine' instance. @param operatingMode: Current mode of operation. Values are: "condenser", "generator" @param type: Modes that this synchronous machine can operate in. Values are: "generator_or_condenser", "generator", "condenser" @@ -61,13 +61,13 @@ class SynchronousMachine(RotatingMachine): @param genEquiv0: @param ReactiveCapabilityCurves: All available Reactive capability curves for this SynchronousMachine. """ - #: Current mode of operation.Values are: "condenser", "generator" + #: Current mode of operation. Values are: "condenser", "generator" self.operatingMode = operatingMode - #: Modes that this synchronous machine can operate in.Values are: "generator_or_condenser", "generator", "condenser" + #: Modes that this synchronous machine can operate in. Values are: "generator_or_condenser", "generator", "condenser" self.type = type - #: Method of cooling the machine.Values are: "air", "hydrogenGas", "water" + #: Method of cooling the machine. Values are: "air", "hydrogenGas", "water" self.coolantType = coolantType #: Quadrature-axis transient reactance, also known as X'q. @@ -172,7 +172,14 @@ class SynchronousMachine(RotatingMachine): self._ReactiveCapabilityCurves = [] self.ReactiveCapabilityCurves = [] if ReactiveCapabilityCurves is None else ReactiveCapabilityCurves - super(SynchronousMachine, self).__init__(**kw_args) + super(SynchronousMachine, self).__init__(*args, **kw_args) + + _attrs = ["operatingMode", "type", "coolantType", "xQuadTrans", "condenserP", "referencePriority", "damping", "x0", "r2", "minQ", "xDirectSync", "maxQ", "r0", "aVRToManualLead", "x", "inertia", "coolantCondition", "manualToAVR", "r", "maxU", "xQuadSync", "qPercent", "xQuadSubtrans", "minU", "aVRToManualLag", "baseQ", "xDirectTrans", "x2", "xDirectSubtrans"] + _attr_types = {"operatingMode": str, "type": str, "coolantType": str, "xQuadTrans": float, "condenserP": float, "referencePriority": int, "damping": float, "x0": float, "r2": float, "minQ": float, "xDirectSync": float, "maxQ": float, "r0": float, "aVRToManualLead": float, "x": float, "inertia": float, "coolantCondition": float, "manualToAVR": float, "r": float, "maxU": float, "xQuadSync": float, "qPercent": float, "xQuadSubtrans": float, "minU": float, "aVRToManualLag": float, "baseQ": float, "xDirectTrans": float, "x2": float, "xDirectSubtrans": float} + _defaults = {"operatingMode": "condenser", "type": "generator_or_condenser", "coolantType": "air", "xQuadTrans": 0.0, "condenserP": 0.0, "referencePriority": 0, "damping": 0.0, "x0": 0.0, "r2": 0.0, "minQ": 0.0, "xDirectSync": 0.0, "maxQ": 0.0, "r0": 0.0, "aVRToManualLead": 0.0, "x": 0.0, "inertia": 0.0, "coolantCondition": 0.0, "manualToAVR": 0.0, "r": 0.0, "maxU": 0.0, "xQuadSync": 0.0, "qPercent": 0.0, "xQuadSubtrans": 0.0, "minU": 0.0, "aVRToManualLag": 0.0, "baseQ": 0.0, "xDirectTrans": 0.0, "x2": 0.0, "xDirectSubtrans": 0.0} + _enums = {"operatingMode": "SynchronousMachineOperatingMode", "type": "SynchronousMachineType", "coolantType": "CoolantType"} + _refs = ["genLoad0", "HydroPump", "GeneratingUnit", "govHydro10", "PrimeMovers", "InitialReactiveCapabilityCurve", "genEquiv0", "ReactiveCapabilityCurves"] + _many_refs = ["genLoad0", "govHydro10", "PrimeMovers", "genEquiv0", "ReactiveCapabilityCurves"] def getgenLoad0(self): diff --git a/schemata/CIM14/IEC61970/Wires/TapChanger.py b/schemata/CIM14/IEC61970/Wires/TapChanger.py index 32c0f39..66f1172 100644 --- a/schemata/CIM14/IEC61970/Wires/TapChanger.py +++ b/schemata/CIM14/IEC61970/Wires/TapChanger.py @@ -20,8 +20,8 @@ class TapChanger(PowerSystemResource): """Mechanism for changing transformer winding tap positions. """ - def __init__(self, stepVoltageIncrement=0.0, normalStep=0, neutralStep=0, subsequentDelay=0.0, regulationStatus=False, ltcFlag=False, highStep=0, initialDelay=0.0, lowStep=0, neutralU=0.0, SvTapStep=None, ImpedanceVariationCurve=None, TapSchedules=None, RegulatingControl=None, **kw_args): - """Initializes a new 'TapChanger' instance. + def __init__(self, stepVoltageIncrement=0.0, normalStep=0, neutralStep=0, subsequentDelay=0.0, regulationStatus=False, ltcFlag=False, highStep=0, initialDelay=0.0, lowStep=0, neutralU=0.0, SvTapStep=None, ImpedanceVariationCurve=None, TapSchedules=None, RegulatingControl=None, *args, **kw_args): + """Initialises a new 'TapChanger' instance. @param stepVoltageIncrement: Tap step increment, in per cent of nominal voltage, per step position. For a symmetrical PhaseTapChanger, the stepVoltageIncrement is used in the formula for calculation of the phase angle. For a symmetrical PhaseTapChanger, the voltage magnitude does not change with tap step. @param normalStep: The tap step position used in 'normal' network operation for this winding. For a 'Fixed' tap changer indicates the current physical tap setting. @@ -80,7 +80,14 @@ class TapChanger(PowerSystemResource): self._RegulatingControl = None self.RegulatingControl = RegulatingControl - super(TapChanger, self).__init__(**kw_args) + super(TapChanger, self).__init__(*args, **kw_args) + + _attrs = ["stepVoltageIncrement", "normalStep", "neutralStep", "subsequentDelay", "regulationStatus", "ltcFlag", "highStep", "initialDelay", "lowStep", "neutralU"] + _attr_types = {"stepVoltageIncrement": float, "normalStep": int, "neutralStep": int, "subsequentDelay": float, "regulationStatus": bool, "ltcFlag": bool, "highStep": int, "initialDelay": float, "lowStep": int, "neutralU": float} + _defaults = {"stepVoltageIncrement": 0.0, "normalStep": 0, "neutralStep": 0, "subsequentDelay": 0.0, "regulationStatus": False, "ltcFlag": False, "highStep": 0, "initialDelay": 0.0, "lowStep": 0, "neutralU": 0.0} + _enums = {} + _refs = ["SvTapStep", "ImpedanceVariationCurve", "TapSchedules", "RegulatingControl"] + _many_refs = ["TapSchedules"] def getSvTapStep(self): """The tap step state associated with the tap changer. diff --git a/schemata/CIM14/IEC61970/Wires/TapSchedule.py b/schemata/CIM14/IEC61970/Wires/TapSchedule.py index 5446a17..09daa72 100644 --- a/schemata/CIM14/IEC61970/Wires/TapSchedule.py +++ b/schemata/CIM14/IEC61970/Wires/TapSchedule.py @@ -20,8 +20,8 @@ class TapSchedule(SeasonDayTypeSchedule): """A pre-established pattern over time for a tap step. """ - def __init__(self, lineDropCompensation=False, lineDropR=0.0, lineDropX=0.0, TapChanger=None, **kw_args): - """Initializes a new 'TapSchedule' instance. + def __init__(self, lineDropCompensation=False, lineDropR=0.0, lineDropX=0.0, TapChanger=None, *args, **kw_args): + """Initialises a new 'TapSchedule' instance. @param lineDropCompensation: Flag to indicate that line drop compensation is to be applied @param lineDropR: Line drop resistance. @@ -40,7 +40,14 @@ class TapSchedule(SeasonDayTypeSchedule): self._TapChanger = None self.TapChanger = TapChanger - super(TapSchedule, self).__init__(**kw_args) + super(TapSchedule, self).__init__(*args, **kw_args) + + _attrs = ["lineDropCompensation", "lineDropR", "lineDropX"] + _attr_types = {"lineDropCompensation": bool, "lineDropR": float, "lineDropX": float} + _defaults = {"lineDropCompensation": False, "lineDropR": 0.0, "lineDropX": 0.0} + _enums = {} + _refs = ["TapChanger"] + _many_refs = [] def getTapChanger(self): """A TapSchedule is associated with a TapChanger. diff --git a/schemata/CIM14/IEC61970/Wires/TransformerWinding.py b/schemata/CIM14/IEC61970/Wires/TransformerWinding.py index bcf10f0..7ef0ab2 100644 --- a/schemata/CIM14/IEC61970/Wires/TransformerWinding.py +++ b/schemata/CIM14/IEC61970/Wires/TransformerWinding.py @@ -20,8 +20,8 @@ class TransformerWinding(ConductingEquipment): """A winding is associated with each defined terminal of a transformer (or phase shifter). """ - def __init__(self, connectionType='Yn', windingType='primary', x=0.0, grounded=False, g=0.0, r=0.0, x0=0.0, ratedU=0.0, ratedS=0.0, emergencyS=0.0, rground=0.0, shortTermS=0.0, r0=0.0, g0=0.0, insulationU=0.0, b=0.0, b0=0.0, xground=0.0, From_WindingTest=None, To_WindingTest=None, RatioTapChanger=None, PowerTransformer=None, PhaseTapChanger=None, **kw_args): - """Initializes a new 'TransformerWinding' instance. + def __init__(self, connectionType="Yn", windingType="primary", x=0.0, grounded=False, g=0.0, r=0.0, x0=0.0, ratedU=0.0, ratedS=0.0, emergencyS=0.0, rground=0.0, shortTermS=0.0, r0=0.0, g0=0.0, insulationU=0.0, b=0.0, b0=0.0, xground=0.0, From_WindingTest=None, To_WindingTest=None, RatioTapChanger=None, PowerTransformer=None, PhaseTapChanger=None, *args, **kw_args): + """Initialises a new 'TransformerWinding' instance. @param connectionType: The type of connection of the winding. Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" @param windingType: The type of winding. Values are: "primary", "quaternary", "secondary", "tertiary" @@ -47,10 +47,10 @@ class TransformerWinding(ConductingEquipment): @param PowerTransformer: A transformer has windings @param PhaseTapChanger: The phase tap changer associated with the transformer winding. """ - #: The type of connection of the winding.Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" + #: The type of connection of the winding. Values are: "Yn", "Y", "D", "I", "Z", "A", "Zn" self.connectionType = connectionType - #: The type of winding.Values are: "primary", "quaternary", "secondary", "tertiary" + #: The type of winding. Values are: "primary", "quaternary", "secondary", "tertiary" self.windingType = windingType #: Positive sequence series reactance of the winding. For a two winding transformer, the full reactance of the transformer should be entered on the primary (high voltage) winding. @@ -116,7 +116,14 @@ class TransformerWinding(ConductingEquipment): self._PhaseTapChanger = None self.PhaseTapChanger = PhaseTapChanger - super(TransformerWinding, self).__init__(**kw_args) + super(TransformerWinding, self).__init__(*args, **kw_args) + + _attrs = ["connectionType", "windingType", "x", "grounded", "g", "r", "x0", "ratedU", "ratedS", "emergencyS", "rground", "shortTermS", "r0", "g0", "insulationU", "b", "b0", "xground"] + _attr_types = {"connectionType": str, "windingType": str, "x": float, "grounded": bool, "g": float, "r": float, "x0": float, "ratedU": float, "ratedS": float, "emergencyS": float, "rground": float, "shortTermS": float, "r0": float, "g0": float, "insulationU": float, "b": float, "b0": float, "xground": float} + _defaults = {"connectionType": "Yn", "windingType": "primary", "x": 0.0, "grounded": False, "g": 0.0, "r": 0.0, "x0": 0.0, "ratedU": 0.0, "ratedS": 0.0, "emergencyS": 0.0, "rground": 0.0, "shortTermS": 0.0, "r0": 0.0, "g0": 0.0, "insulationU": 0.0, "b": 0.0, "b0": 0.0, "xground": 0.0} + _enums = {"connectionType": "WindingConnection", "windingType": "WindingType"} + _refs = ["From_WindingTest", "To_WindingTest", "RatioTapChanger", "PowerTransformer", "PhaseTapChanger"] + _many_refs = ["From_WindingTest", "To_WindingTest"] def getFrom_WindingTest(self): """The transformer winding tests for which the transformer winding (terminal) participates as the 'from' part of the test. diff --git a/schemata/CIM14/IEC61970/Wires/VoltageControlZone.py b/schemata/CIM14/IEC61970/Wires/VoltageControlZone.py index e657bce..6483161 100644 --- a/schemata/CIM14/IEC61970/Wires/VoltageControlZone.py +++ b/schemata/CIM14/IEC61970/Wires/VoltageControlZone.py @@ -20,8 +20,8 @@ class VoltageControlZone(PowerSystemResource): """An area of the power system network which is defined for secondary voltage control purposes. A voltage control zone consists of a collection of substations with a designated bus bar section whose voltage will be controlled. """ - def __init__(self, RegulationSchedule=None, BusbarSection=None, **kw_args): - """Initializes a new 'VoltageControlZone' instance. + def __init__(self, RegulationSchedule=None, BusbarSection=None, *args, **kw_args): + """Initialises a new 'VoltageControlZone' instance. @param RegulationSchedule: A VoltageControlZone may have a voltage regulation schedule. @param BusbarSection: A VoltageControlZone is controlled by a designated BusbarSection. @@ -32,7 +32,14 @@ class VoltageControlZone(PowerSystemResource): self._BusbarSection = None self.BusbarSection = BusbarSection - super(VoltageControlZone, self).__init__(**kw_args) + super(VoltageControlZone, self).__init__(*args, **kw_args) + + _attrs = [] + _attr_types = {} + _defaults = {} + _enums = {} + _refs = ["RegulationSchedule", "BusbarSection"] + _many_refs = [] def getRegulationSchedule(self): """A VoltageControlZone may have a voltage regulation schedule. diff --git a/schemata/CIM14/IEC61970/Wires/WindingTest.py b/schemata/CIM14/IEC61970/Wires/WindingTest.py index aca188e..50c0ad3 100644 --- a/schemata/CIM14/IEC61970/Wires/WindingTest.py +++ b/schemata/CIM14/IEC61970/Wires/WindingTest.py @@ -20,8 +20,8 @@ class WindingTest(IdentifiedObject): """Physical winding test data for the winding/tap pairs of a transformer (or phase shifter). This test data can be used to derive other attributes of specific transformer or phase shifter models. """ - def __init__(self, fromTapStep=0, leakageImpedance=0.0, noLoadLoss=0.0, phaseShift=0.0, excitingCurrent=0.0, loadLoss=0.0, toTapStep=0, voltage=0.0, From_TransformerWinding=None, To_TransformerWinding=None, **kw_args): - """Initializes a new 'WindingTest' instance. + def __init__(self, fromTapStep=0, leakageImpedance=0.0, noLoadLoss=0.0, phaseShift=0.0, excitingCurrent=0.0, loadLoss=0.0, toTapStep=0, voltage=0.0, From_TransformerWinding=None, To_TransformerWinding=None, *args, **kw_args): + """Initialises a new 'WindingTest' instance. @param fromTapStep: The tap step number for the 'from' winding of the test pair. @param leakageImpedance: The leakage impedance measured at the 'from' winding with the 'to' winding short-circuited and all other windings open-circuited. Leakage impedance is expressed in units based on the apparent power and voltage ratings of the 'from' winding. @@ -64,7 +64,14 @@ class WindingTest(IdentifiedObject): self._To_TransformerWinding = None self.To_TransformerWinding = To_TransformerWinding - super(WindingTest, self).__init__(**kw_args) + super(WindingTest, self).__init__(*args, **kw_args) + + _attrs = ["fromTapStep", "leakageImpedance", "noLoadLoss", "phaseShift", "excitingCurrent", "loadLoss", "toTapStep", "voltage"] + _attr_types = {"fromTapStep": int, "leakageImpedance": float, "noLoadLoss": float, "phaseShift": float, "excitingCurrent": float, "loadLoss": float, "toTapStep": int, "voltage": float} + _defaults = {"fromTapStep": 0, "leakageImpedance": 0.0, "noLoadLoss": 0.0, "phaseShift": 0.0, "excitingCurrent": 0.0, "loadLoss": 0.0, "toTapStep": 0, "voltage": 0.0} + _enums = {} + _refs = ["From_TransformerWinding", "To_TransformerWinding"] + _many_refs = [] def getFrom_TransformerWinding(self): """The winding from which the test was conducted diff --git a/schemata/CIM14/__init__.py b/schemata/CIM14/__init__.py index 410c8be..e47fe81 100644 --- a/schemata/CIM14/__init__.py +++ b/schemata/CIM14/__init__.py @@ -14,12 +14,7 @@ # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA, USA -"""The IEC 61968 subpackages of the CIM are developed, standardized -and maintained by IEC TC57 Working Group 14: System Interfaces for -Distribution Management (WG14). Currently, normative parts of the model -support the needs of information exchange defined in IEC 61968-9: -'Interfaces for Meter Reading and Control' and in IEC 61968-13: -'CIM RDF Model exchange format for distribution.' +"""The IEC 61968 subpackages of the CIM are developed, standardized and maintained by IEC TC57 Working Group 14: System Interfaces for Distribution Management (WG14). Currently, normative parts of the model support the needs of information exchange defined in IEC 61968-9: 'Interfaces for Meter Reading and Control' and in IEC 61968-13: 'CIM RDF Model exchange format for distribution.' """ nsPrefix = "cim" -- 2.11.4.GIT