Struct LoadMotor 

pub struct LoadMotor {

    pub base: IdentifiedObject,
    pub load_aggregate: Option<MridRef>,
    pub d: Option<f64>,
    pub h: Option<f64>,
    pub lfac: Option<f64>,
    pub lp: Option<f64>,
    pub lpp: Option<f64>,
    pub ls: Option<f64>,
    pub pfrac: Option<f64>,
    pub ra: Option<f64>,
    pub tbkr: Option<f64>,
    pub tpo: Option<f64>,
    pub tppo: Option<f64>,
    pub tv: Option<f64>,
    pub vt: Option<f64>,
}

Aggregate induction motor load. This model is used to represent a fraction of an ordinary load as ‘induction motor load’. It allows a load that is treated as an ordinary constant power in power flow analysis to be represented by an induction motor in dynamic simulation. 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. Either a ‘one-cage’ or ‘two-cage’ model of the induction machine can be modelled. Magnetic saturation is not modelled. This model treats a fraction of the constant power part of a load as a motor. During initialisation, the initial power drawn by the motor is set equal to Pfrac times the constant P part of the static load. The remainder of the load is left as a static load. The reactive power demand of the motor is calculated during initialisation as a function of voltage at the load bus. This reactive power demand can be less than or greater than the constant Q component of the load. If the motor’s reactive demand is greater than the constant Q component of the load, the model inserts a shunt capacitor at the terminal of the motor to bring its reactive demand down to equal the constant Q reactive load. If an induction motor load model and a static load model are both present for a load, the motor Pfrac is assumed to be subtracted from the power flow constant P load before the static load model is applied. The remainder of the load, if any, is then represented by the static load model.

Fields

base: IdentifiedObject

load_aggregate: Option<MridRef>

Aggregate load to which this aggregate motor (dynamic) load belongs.

d: Option<f64>

Damping factor (D). Unit = delta P/delta speed. Typical value = 2.

h: Option<f64>

Inertia constant (H) (>= 0). Typical value = 0,4.

lfac: Option<f64>

Loading factor (Lfac). The ratio of initial P to motor MVA base. Typical value = 0,8.

lp: Option<f64>

Transient reactance (Lp). Typical value = 0,15.

lpp: Option<f64>

Subtransient reactance (Lpp). Typical value = 0,15.

ls: Option<f64>

Synchronous reactance (Ls). Typical value = 3,2.

pfrac: Option<f64>

Fraction of constant-power load to be represented by this motor model (Pfrac) (>= 0,0 and <= 1,0). Typical value = 0,3.

ra: Option<f64>

Stator resistance (Ra). Typical value = 0.

tbkr: Option<f64>

Circuit breaker operating time (Tbkr) (>= 0). Typical value = 0,08.

tpo: Option<f64>

Transient rotor time constant (Tpo) (>= 0). Typical value = 1.

tppo: Option<f64>

Subtransient rotor time constant (Tppo) (>= 0). Typical value = 0,02.

tv: Option<f64>

Voltage trip pickup time (Tv) (>= 0). Typical value = 0,1.

vt: Option<f64>

Voltage threshold for tripping (Vt). Typical value = 0,7.

Implementations

impl LoadMotor

pub fn from_block(b: &RdfBlock) -> Self

Trait Implementations

impl CimElement for LoadMotor

fn mrid(&self) -> &str

fn type_name(&self) -> &'static str

fn as_any(&self) -> &dyn Any

fn to_json_value(&self) -> Value

fn to_block(&self) -> RdfBlock

impl Clone for LoadMotor

fn clone(&self) -> LoadMotor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LoadMotor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LoadMotor

fn default() -> LoadMotor

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LoadMotor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LoadMotor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.