powerflow.cpp

class billdump {
	char32 group; // the group ID to output data for (all nodes if empty)
	timestamp runtime; // the time to check voltage data
	char256 filename; // the file to dump the voltage data into
	int32 runcount; // the number of times the file has been written to
	enumeration {METER=1, TRIPLEX_METER=0} meter_type; // describes whether to collect from 3-phase or S-phase meters
}

class capacitor {
	parent node;
	class node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_A[V]; // bus voltage, Phase A to ground
		complex voltage_B[V]; // bus voltage, Phase B to ground
		complex voltage_C[V]; // bus voltage, Phase C to ground
		complex voltage_AB[V]; // line voltages, Phase AB
		complex voltage_BC[V]; // line voltages, Phase BC
		complex voltage_CA[V]; // line voltages, Phase CA
		complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
		object topological_parent; // topological parent as per GLM configuration
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	set {N=8, D=256, C=4, B=2, A=1} pt_phase; // Phase(s) that the PT is on, used as measurement points for control
	set {N=8, D=256, C=4, B=2, A=1} phases_connected; // phases capacitors connected to
	enumeration {CLOSED=1, OPEN=0} switchA; // capacitor A switch open or close
	enumeration {CLOSED=1, OPEN=0} switchB; // capacitor B switch open or close
	enumeration {CLOSED=1, OPEN=0} switchC; // capacitor C switch open or close
	enumeration {CURRENT=4, VARVOLT=3, VOLT=2, VAR=1, MANUAL=0} control; // control operation strategy
	double cap_A_switch_count; // number of switch operations on Phase A
	double cap_B_switch_count; // number of switch operations on Phase B
	double cap_C_switch_count; // number of switch operations on Phase C
	double voltage_set_high[V]; // Turn off if voltage is above this set point
	double voltage_set_low[V]; // Turns on if voltage is below this set point
	double VAr_set_high[VAr]; // high VAR set point for VAR control (turn off)
	double VAr_set_low[VAr]; // low VAR set point for VAR control (turn on)
	double current_set_low[A]; // high current set point for current control mode (turn on)
	double current_set_high[A]; // low current set point for current control mode (turn off)
	double capacitor_A[VAr]; // Capacitance value for phase A or phase AB
	double capacitor_B[VAr]; // Capacitance value for phase B or phase BC
	double capacitor_C[VAr]; // Capacitance value for phase C or phase CA
	double cap_nominal_voltage[V]; // Nominal voltage for the capacitor. Used for calculation of capacitance value
	double time_delay[s]; // control time delay
	double dwell_time[s]; // Time for system to remain constant before a state change will be passed
	double lockout_time[s]; // Time for capacitor to remain locked out from further switching operations (VARVOLT control)
	object remote_sense; // Remote object for sensing values used for control schemes
	object remote_sense_B; // Secondary Remote object for sensing values used for control schemes (VARVOLT uses two)
	enumeration {INDIVIDUAL=1, BANK=0} control_level; // define bank or individual control
}

class currdump {
	char32 group; // the group ID to output data for (all links if empty)
	timestamp runtime; // the time to check current data
	char256 filename; // the file to dump the current data into
	int32 runcount; // the number of times the file has been written to
	enumeration {polar=1, rect=0} mode;
}

class emissions {
	double Nuclear_Order;
	double Hydroelectric_Order;
	double Solarthermal_Order;
	double Biomass_Order;
	double Wind_Order;
	double Coal_Order;
	double Naturalgas_Order;
	double Geothermal_Order;
	double Petroleum_Order;
	double Naturalgas_Max_Out[kWh];
	double Coal_Max_Out[kWh];
	double Biomass_Max_Out[kWh];
	double Geothermal_Max_Out[kWh];
	double Hydroelectric_Max_Out[kWh];
	double Nuclear_Max_Out[kWh];
	double Wind_Max_Out[kWh];
	double Petroleum_Max_Out[kWh];
	double Solarthermal_Max_Out[kWh];
	double Naturalgas_Out[kWh];
	double Coal_Out[kWh];
	double Biomass_Out[kWh];
	double Geothermal_Out[kWh];
	double Hydroelectric_Out[kWh];
	double Nuclear_Out[kWh];
	double Wind_Out[kWh];
	double Petroleum_Out[kWh];
	double Solarthermal_Out[kWh];
	double Naturalgas_Conv_Eff[Btu/kWh];
	double Coal_Conv_Eff[Btu/kWh];
	double Biomass_Conv_Eff[Btu/kWh];
	double Geothermal_Conv_Eff[Btu/kWh];
	double Hydroelectric_Conv_Eff[Btu/kWh];
	double Nuclear_Conv_Eff[Btu/kWh];
	double Wind_Conv_Eff[Btu/kWh];
	double Petroleum_Conv_Eff[Btu/kWh];
	double Solarthermal_Conv_Eff[Btu/kWh];
	double Naturalgas_CO2[lb/Btu];
	double Coal_CO2[lb/Btu];
	double Biomass_CO2[lb/Btu];
	double Geothermal_CO2[lb/Btu];
	double Hydroelectric_CO2[lb/Btu];
	double Nuclear_CO2[lb/Btu];
	double Wind_CO2[lb/Btu];
	double Petroleum_CO2[lb/Btu];
	double Solarthermal_CO2[lb/Btu];
	double Naturalgas_SO2[lb/Btu];
	double Coal_SO2[lb/Btu];
	double Biomass_SO2[lb/Btu];
	double Geothermal_SO2[lb/Btu];
	double Hydroelectric_SO2[lb/Btu];
	double Nuclear_SO2[lb/Btu];
	double Wind_SO2[lb/Btu];
	double Petroleum_SO2[lb/Btu];
	double Solarthermal_SO2[lb/Btu];
	double Naturalgas_NOx[lb/Btu];
	double Coal_NOx[lb/Btu];
	double Biomass_NOx[lb/Btu];
	double Geothermal_NOx[lb/Btu];
	double Hydroelectric_NOx[lb/Btu];
	double Nuclear_NOx[lb/Btu];
	double Wind_NOx[lb/Btu];
	double Petroleum_NOx[lb/Btu];
	double Solarthermal_NOx[lb/Btu];
	double Naturalgas_emissions_CO2[lb];
	double Naturalgas_emissions_SO2[lb];
	double Naturalgas_emissions_NOx[lb];
	double Coal_emissions_CO2[lb];
	double Coal_emissions_SO2[lb];
	double Coal_emissions_NOx[lb];
	double Biomass_emissions_CO2[lb];
	double Biomass_emissions_SO2[lb];
	double Biomass_emissions_NOx[lb];
	double Geothermal_emissions_CO2[lb];
	double Geothermal_emissions_SO2[lb];
	double Geothermal_emissions_NOx[lb];
	double Hydroelectric_emissions_CO2[lb];
	double Hydroelectric_emissions_SO2[lb];
	double Hydroelectric_emissions_NOx[lb];
	double Nuclear_emissions_CO2[lb];
	double Nuclear_emissions_SO2[lb];
	double Nuclear_emissions_NOx[lb];
	double Wind_emissions_CO2[lb];
	double Wind_emissions_SO2[lb];
	double Wind_emissions_NOx[lb];
	double Petroleum_emissions_CO2[lb];
	double Petroleum_emissions_SO2[lb];
	double Petroleum_emissions_NOx[lb];
	double Solarthermal_emissions_CO2[lb];
	double Solarthermal_emissions_SO2[lb];
	double Solarthermal_emissions_NOx[lb];
	double Total_emissions_CO2[lb];
	double Total_emissions_SO2[lb];
	double Total_emissions_NOx[lb];
	double Total_energy_out[kWh];
	double Region;
	double cycle_interval[s];
}

class fault_check {
	function reliability_alterations();
	function handle_sectionalizer();
	enumeration {ALL=2, ONCHANGE=1, SINGLE=0} check_mode; // Frequency of fault checks
	char1024 output_filename; // Output filename for list of unsupported nodes
	bool reliability_mode; // General flag indicating if fault_check is operating under faulting or restoration mode -- reliability set this
	bool strictly_radial; // Flag to indicate if a system is known to be strictly radial -- uses radial assumptions for reliability alterations
	object eventgen_object; // Link to generic eventgen object to handle unexpected faults
}

class frequency_gen {
	enumeration {AUTO=1, OFF=0} Frequency_Mode; // Frequency object operations mode
	double Frequency[Hz]; // Instantaneous frequency value
	double FreqChange[Hz/s]; // Frequency change from last timestep
	double Deadband[Hz]; // Frequency deadband of the governor
	double Tolerance[%]; // % threshold a power difference must be before it is cared about
	double M[pu*s]; // Inertial constant of the system
	double D[%]; // Load-damping constant
	double Rated_power[W]; // Rated power of system (base power)
	double Gen_power[W]; // Mechanical power equivalent
	double Load_power[W]; // Last sensed load value
	double Gov_delay[s]; // Governor delay time
	double Ramp_rate[W/s]; // Ramp ideal ramp rate
	double Low_Freq_OI[Hz]; // Low frequency setpoint for GFA devices
	double High_Freq_OI[Hz]; // High frequency setpoint for GFA devices
	double avg24[Hz]; // Average of last 24 hourly instantaneous measurements
	double std24[Hz]; // Standard deviation of last 24 hourly instantaneous measurements
	double avg168[Hz]; // Average of last 168 hourly instantaneous measurements
	double std168[Hz]; // Standard deviation of last 168 hourly instantaneous measurements
	int32 Num_Resp_Eqs; // Total number of equations the response can contain
}

class fuse {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function change_fuse_state();
	function reliability_operation();
	function create_fault();
	function fix_fault();
	function change_fuse_faults();
	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	enumeration {GOOD=1, BLOWN=0} phase_A_status;
	enumeration {GOOD=1, BLOWN=0} phase_B_status;
	enumeration {GOOD=1, BLOWN=0} phase_C_status;
	enumeration {EXPONENTIAL=1, NONE=0} repair_dist_type;
	double current_limit[A];
	double mean_replacement_time[s];
	double fuse_resistance[Ohm]; // The resistance value of the fuse when it is not blown.
}

class line {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	object configuration;
	double length[ft];
}

class line_configuration {
	object conductor_A;
	object conductor_B;
	object conductor_C;
	object conductor_N;
	object spacing;
	complex z11[Ohm/mile];
	complex z12[Ohm/mile];
	complex z13[Ohm/mile];
	complex z21[Ohm/mile];
	complex z22[Ohm/mile];
	complex z23[Ohm/mile];
	complex z31[Ohm/mile];
	complex z32[Ohm/mile];
	complex z33[Ohm/mile];
	double c11[nF/mile];
	double c12[nF/mile];
	double c13[nF/mile];
	double c21[nF/mile];
	double c22[nF/mile];
	double c23[nF/mile];
	double c31[nF/mile];
	double c32[nF/mile];
	double c33[nF/mile];
}

class line_spacing {
	double distance_AB[ft];
	double distance_BC[ft];
	double distance_AC[ft];
	double distance_AN[ft];
	double distance_BN[ft];
	double distance_CN[ft];
	double distance_AE[ft]; // distance between phase A wire and earth
	double distance_BE[ft]; // distance between phase B wire and earth
	double distance_CE[ft]; // distance between phase C wire and earth
	double distance_NE[ft]; // distance between neutral wire and earth
}

class link {
	parent powerflow_object;
	class powerflow_object {
		set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
		double nominal_voltage[V];
	}

	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	enumeration {OPEN=0, CLOSED=1} status; // 
	object from; // from_node - source node
	object to; // to_node - load node
	complex power_in[VA]; // power flow in (w.r.t from node)
	complex power_out[VA]; // power flow out (w.r.t to node)
	double power_out_real[W]; // power flow out (w.r.t to node), real
	complex power_losses[VA]; // power losses
	complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
	complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
	complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
	complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
	complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
	complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
	complex power_losses_A[VA]; // power losses, phase A
	complex power_losses_B[VA]; // power losses, phase B
	complex power_losses_C[VA]; // power losses, phase C
	complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
	complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
	complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
	complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
	complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
	complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
	complex fault_current_in_A[A]; // fault current flowing in, phase A
	complex fault_current_in_B[A]; // fault current flowing in, phase B
	complex fault_current_in_C[A]; // fault current flowing in, phase C
	complex fault_current_out_A[A]; // fault current flowing out, phase A
	complex fault_current_out_B[A]; // fault current flowing out, phase B
	complex fault_current_out_C[A]; // fault current flowing out, phase C
	set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
	double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
	double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
	double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
}

class load {
	parent node;
	class node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_A[V]; // bus voltage, Phase A to ground
		complex voltage_B[V]; // bus voltage, Phase B to ground
		complex voltage_C[V]; // bus voltage, Phase C to ground
		complex voltage_AB[V]; // line voltages, Phase AB
		complex voltage_BC[V]; // line voltages, Phase BC
		complex voltage_CA[V]; // line voltages, Phase CA
		complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
		object topological_parent; // topological parent as per GLM configuration
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	enumeration {A=4, I=3, C=2, R=1, U=0} load_class; // Flag to track load type, not currently used for anything except sorting
	complex constant_power_A[VA]; // constant power load on phase A, specified as VA
	complex constant_power_B[VA]; // constant power load on phase B, specified as VA
	complex constant_power_C[VA]; // constant power load on phase C, specified as VA
	double constant_power_A_real[W]; // constant power load on phase A, real only, specified as W
	double constant_power_B_real[W]; // constant power load on phase B, real only, specified as W
	double constant_power_C_real[W]; // constant power load on phase C, real only, specified as W
	double constant_power_A_reac[VAr]; // constant power load on phase A, imaginary only, specified as VAr
	double constant_power_B_reac[VAr]; // constant power load on phase B, imaginary only, specified as VAr
	double constant_power_C_reac[VAr]; // constant power load on phase C, imaginary only, specified as VAr
	complex constant_current_A[A]; // constant current load on phase A, specified as Amps
	complex constant_current_B[A]; // constant current load on phase B, specified as Amps
	complex constant_current_C[A]; // constant current load on phase C, specified as Amps
	double constant_current_A_real[A]; // constant current load on phase A, real only, specified as Amps
	double constant_current_B_real[A]; // constant current load on phase B, real only, specified as Amps
	double constant_current_C_real[A]; // constant current load on phase C, real only, specified as Amps
	double constant_current_A_reac[A]; // constant current load on phase A, imaginary only, specified as Amps
	double constant_current_B_reac[A]; // constant current load on phase B, imaginary only, specified as Amps
	double constant_current_C_reac[A]; // constant current load on phase C, imaginary only, specified as Amps
	complex constant_impedance_A[Ohm]; // constant impedance load on phase A, specified as Ohms
	complex constant_impedance_B[Ohm]; // constant impedance load on phase B, specified as Ohms
	complex constant_impedance_C[Ohm]; // constant impedance load on phase C, specified as Ohms
	double constant_impedance_A_real[Ohm]; // constant impedance load on phase A, real only, specified as Ohms
	double constant_impedance_B_real[Ohm]; // constant impedance load on phase B, real only, specified as Ohms
	double constant_impedance_C_real[Ohm]; // constant impedance load on phase C, real only, specified as Ohms
	double constant_impedance_A_reac[Ohm]; // constant impedance load on phase A, imaginary only, specified as Ohms
	double constant_impedance_B_reac[Ohm]; // constant impedance load on phase B, imaginary only, specified as Ohms
	double constant_impedance_C_reac[Ohm]; // constant impedance load on phase C, imaginary only, specified as Ohms
	complex constant_power_AN[VA]; // constant power wye-connected load on phase A, specified as VA
	complex constant_power_BN[VA]; // constant power wye-connected load on phase B, specified as VA
	complex constant_power_CN[VA]; // constant power wye-connected load on phase C, specified as VA
	double constant_power_AN_real[W]; // constant power wye-connected load on phase A, real only, specified as W
	double constant_power_BN_real[W]; // constant power wye-connected load on phase B, real only, specified as W
	double constant_power_CN_real[W]; // constant power wye-connected load on phase C, real only, specified as W
	double constant_power_AN_reac[VAr]; // constant power wye-connected load on phase A, imaginary only, specified as VAr
	double constant_power_BN_reac[VAr]; // constant power wye-connected load on phase B, imaginary only, specified as VAr
	double constant_power_CN_reac[VAr]; // constant power wye-connected load on phase C, imaginary only, specified as VAr
	complex constant_current_AN[A]; // constant current wye-connected load on phase A, specified as Amps
	complex constant_current_BN[A]; // constant current wye-connected load on phase B, specified as Amps
	complex constant_current_CN[A]; // constant current wye-connected load on phase C, specified as Amps
	double constant_current_AN_real[A]; // constant current wye-connected load on phase A, real only, specified as Amps
	double constant_current_BN_real[A]; // constant current wye-connected load on phase B, real only, specified as Amps
	double constant_current_CN_real[A]; // constant current wye-connected load on phase C, real only, specified as Amps
	double constant_current_AN_reac[A]; // constant current wye-connected load on phase A, imaginary only, specified as Amps
	double constant_current_BN_reac[A]; // constant current wye-connected load on phase B, imaginary only, specified as Amps
	double constant_current_CN_reac[A]; // constant current wye-connected load on phase C, imaginary only, specified as Amps
	complex constant_impedance_AN[Ohm]; // constant impedance wye-connected load on phase A, specified as Ohms
	complex constant_impedance_BN[Ohm]; // constant impedance wye-connected load on phase B, specified as Ohms
	complex constant_impedance_CN[Ohm]; // constant impedance wye-connected load on phase C, specified as Ohms
	double constant_impedance_AN_real[Ohm]; // constant impedance wye-connected load on phase A, real only, specified as Ohms
	double constant_impedance_BN_real[Ohm]; // constant impedance wye-connected load on phase B, real only, specified as Ohms
	double constant_impedance_CN_real[Ohm]; // constant impedance wye-connected load on phase C, real only, specified as Ohms
	double constant_impedance_AN_reac[Ohm]; // constant impedance wye-connected load on phase A, imaginary only, specified as Ohms
	double constant_impedance_BN_reac[Ohm]; // constant impedance wye-connected load on phase B, imaginary only, specified as Ohms
	double constant_impedance_CN_reac[Ohm]; // constant impedance wye-connected load on phase C, imaginary only, specified as Ohms
	complex constant_power_AB[VA]; // constant power delta-connected load on phase A, specified as VA
	complex constant_power_BC[VA]; // constant power delta-connected load on phase B, specified as VA
	complex constant_power_CA[VA]; // constant power delta-connected load on phase C, specified as VA
	double constant_power_AB_real[W]; // constant power delta-connected load on phase A, real only, specified as W
	double constant_power_BC_real[W]; // constant power delta-connected load on phase B, real only, specified as W
	double constant_power_CA_real[W]; // constant power delta-connected load on phase C, real only, specified as W
	double constant_power_AB_reac[VAr]; // constant power delta-connected load on phase A, imaginary only, specified as VAr
	double constant_power_BC_reac[VAr]; // constant power delta-connected load on phase B, imaginary only, specified as VAr
	double constant_power_CA_reac[VAr]; // constant power delta-connected load on phase C, imaginary only, specified as VAr
	complex constant_current_AB[A]; // constant current delta-connected load on phase A, specified as Amps
	complex constant_current_BC[A]; // constant current delta-connected load on phase B, specified as Amps
	complex constant_current_CA[A]; // constant current delta-connected load on phase C, specified as Amps
	double constant_current_AB_real[A]; // constant current delta-connected load on phase A, real only, specified as Amps
	double constant_current_BC_real[A]; // constant current delta-connected load on phase B, real only, specified as Amps
	double constant_current_CA_real[A]; // constant current delta-connected load on phase C, real only, specified as Amps
	double constant_current_AB_reac[A]; // constant current delta-connected load on phase A, imaginary only, specified as Amps
	double constant_current_BC_reac[A]; // constant current delta-connected load on phase B, imaginary only, specified as Amps
	double constant_current_CA_reac[A]; // constant current delta-connected load on phase C, imaginary only, specified as Amps
	complex constant_impedance_AB[Ohm]; // constant impedance delta-connected load on phase A, specified as Ohms
	complex constant_impedance_BC[Ohm]; // constant impedance delta-connected load on phase B, specified as Ohms
	complex constant_impedance_CA[Ohm]; // constant impedance delta-connected load on phase C, specified as Ohms
	double constant_impedance_AB_real[Ohm]; // constant impedance delta-connected load on phase A, real only, specified as Ohms
	double constant_impedance_BC_real[Ohm]; // constant impedance delta-connected load on phase B, real only, specified as Ohms
	double constant_impedance_CA_real[Ohm]; // constant impedance delta-connected load on phase C, real only, specified as Ohms
	double constant_impedance_AB_reac[Ohm]; // constant impedance delta-connected load on phase A, imaginary only, specified as Ohms
	double constant_impedance_BC_reac[Ohm]; // constant impedance delta-connected load on phase B, imaginary only, specified as Ohms
	double constant_impedance_CA_reac[Ohm]; // constant impedance delta-connected load on phase C, imaginary only, specified as Ohms
	complex measured_voltage_A; // current measured voltage on phase A
	complex measured_voltage_B; // current measured voltage on phase B
	complex measured_voltage_C; // current measured voltage on phase C
	complex measured_voltage_AB; // current measured voltage on phases AB
	complex measured_voltage_BC; // current measured voltage on phases BC
	complex measured_voltage_CA; // current measured voltage on phases CA
	bool phase_loss_protection; // Trip all three phases of the load if a fault occurs
	double base_power_A[VA]; // in similar format as ZIPload, this represents the nominal power on phase A before applying ZIP fractions
	double base_power_B[VA]; // in similar format as ZIPload, this represents the nominal power on phase B before applying ZIP fractions
	double base_power_C[VA]; // in similar format as ZIPload, this represents the nominal power on phase C before applying ZIP fractions
	double power_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant power portion of load
	double current_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant current portion of load
	double impedance_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant impedance portion of load
	double power_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant power portion of load
	double current_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant current portion of load
	double impedance_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant impedance portion of load
	double power_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant power portion of load
	double current_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant current portion of load
	double impedance_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant impedance portion of load
	double power_fraction_A[pu]; // this is the constant power fraction of base power on phase A
	double current_fraction_A[pu]; // this is the constant current fraction of base power on phase A
	double impedance_fraction_A[pu]; // this is the constant impedance fraction of base power on phase A
	double power_fraction_B[pu]; // this is the constant power fraction of base power on phase B
	double current_fraction_B[pu]; // this is the constant current fraction of base power on phase B
	double impedance_fraction_B[pu]; // this is the constant impedance fraction of base power on phase B
	double power_fraction_C[pu]; // this is the constant power fraction of base power on phase C
	double current_fraction_C[pu]; // this is the constant current fraction of base power on phase C
	double impedance_fraction_C[pu]; // this is the constant impedance fraction of base power on phase C
}

class load_tracker {
	object target; // target object to track the load of
	char256 target_property; // property on the target object representing the load
	enumeration {ANGLE=3, MAGNITUDE=2, IMAGINARY=1, REAL=0} operation; // operation to perform on complex property types
	double full_scale; // magnitude of the load at full load, used for feed-forward control
	double setpoint; // load setpoint to track to
	double deadband; // percentage deadband
	double damping; // load setpoint to track to
	double output; // output scaling value
	double feedback; // the feedback signal, for reference purposes
}

class meter {
	parent node;
	class node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_A[V]; // bus voltage, Phase A to ground
		complex voltage_B[V]; // bus voltage, Phase B to ground
		complex voltage_C[V]; // bus voltage, Phase C to ground
		complex voltage_AB[V]; // line voltages, Phase AB
		complex voltage_BC[V]; // line voltages, Phase BC
		complex voltage_CA[V]; // line voltages, Phase CA
		complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
		object topological_parent; // topological parent as per GLM configuration
	}

	function reset();
	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	double measured_real_energy[Wh]; // metered real energy consumption, cummalitive
	double measured_reactive_energy[VAh]; // metered reactive energy consumption, cummalitive
	complex measured_power[VA]; // metered real power
	complex measured_power_A[VA]; // metered complex power on phase A
	complex measured_power_B[VA]; // metered complex power on phase B
	complex measured_power_C[VA]; // metered complex power on phase C
	double measured_demand[W]; // greatest metered real power during simulation
	double measured_real_power[W]; // metered real power
	double measured_reactive_power[VAr]; // metered reactive power
	complex meter_power_consumption[VA]; // metered power used for operating the meter; standby and communication losses
	complex measured_voltage_A[V]; // measured line-to-neutral voltage on phase A
	complex measured_voltage_B[V]; // measured line-to-neutral voltage on phase B
	complex measured_voltage_C[V]; // measured line-to-neutral voltage on phase C
	complex measured_voltage_AB[V]; // measured line-to-line voltage on phase AB
	complex measured_voltage_BC[V]; // measured line-to-line voltage on phase BC
	complex measured_voltage_CA[V]; // measured line-to-line voltage on phase CA
	complex measured_current_A[A]; // measured current on phase A
	complex measured_current_B[A]; // measured current on phase B
	complex measured_current_C[A]; // measured current on phase C
	bool customer_interrupted; // Reliability flag - goes active if the customer is in an 'interrupted' state
	bool customer_interrupted_secondary; // Reliability flag - goes active if the customer is in an 'secondary interrupted' state - i.e., momentary
	double monthly_bill[$]; // Accumulator for the current month's bill
	double previous_monthly_bill[$]; // Total monthly bill for the previous month
	double previous_monthly_energy[kWh]; // Total monthly energy for the previous month
	double monthly_fee[$]; // Once a month flat fee for customer hook-up
	double monthly_energy[kWh]; // Accumulator for the current month's energy consumption
	enumeration {TIERED_RTP=4, HOURLY=3, TIERED=2, UNIFORM=1, NONE=0} bill_mode; // Billing structure desired
	object power_market; // Market (auction object) where the price is being received from
	int32 bill_day; // day of month bill is to be processed (currently limited to days 1-28)
	double price[$/kWh]; // current price of electricity
	double price_base[$/kWh]; // Used only in TIERED_RTP mode to describe the price before the first tier
	double first_tier_price[$/kWh]; // price of electricity between first tier and second tier energy usage
	double first_tier_energy[kWh]; // switching point between base price and first tier price
	double second_tier_price[$/kWh]; // price of electricity between second tier and third tier energy usage
	double second_tier_energy[kWh]; // switching point between first tier price and second tier price
	double third_tier_price[$/kWh]; // price of electricity when energy usage exceeds third tier energy usage
	double third_tier_energy[kWh]; // switching point between second tier price and third tier price
}

class motor {
	parent node;
	class node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_A[V]; // bus voltage, Phase A to ground
		complex voltage_B[V]; // bus voltage, Phase B to ground
		complex voltage_C[V]; // bus voltage, Phase C to ground
		complex voltage_AB[V]; // line voltages, Phase AB
		complex voltage_BC[V]; // line voltages, Phase BC
		complex voltage_CA[V]; // line voltages, Phase CA
		complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
		object topological_parent; // topological parent as per GLM configuration
	}

}

class node {
	parent powerflow_object;
	class powerflow_object {
		set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
		double nominal_voltage[V];
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
	set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
	object reference_bus; // reference bus from which frequency is defined
	double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
	complex voltage_A[V]; // bus voltage, Phase A to ground
	complex voltage_B[V]; // bus voltage, Phase B to ground
	complex voltage_C[V]; // bus voltage, Phase C to ground
	complex voltage_AB[V]; // line voltages, Phase AB
	complex voltage_BC[V]; // line voltages, Phase BC
	complex voltage_CA[V]; // line voltages, Phase CA
	complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
	complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
	complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
	complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
	complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
	complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
	complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
	complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
	complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
	complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
	complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
	complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
	complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
	complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
	complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
	complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
	double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
	enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
	double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
	double previous_uptime[min]; // Previous time between disconnects of node in minutes
	double current_uptime[min]; // Current time since last disconnect of node in minutes
	bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
	object topological_parent; // topological parent as per GLM configuration
}

class overhead_line {
	parent line;
	class line {
		parent link;
		class link {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function interupdate_pwr_object();
			function update_power_pwr_object();
			function check_limits_pwr_object();
			enumeration {OPEN=0, CLOSED=1} status; // 
			object from; // from_node - source node
			object to; // to_node - load node
			complex power_in[VA]; // power flow in (w.r.t from node)
			complex power_out[VA]; // power flow out (w.r.t to node)
			double power_out_real[W]; // power flow out (w.r.t to node), real
			complex power_losses[VA]; // power losses
			complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
			complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
			complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
			complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
			complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
			complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
			complex power_losses_A[VA]; // power losses, phase A
			complex power_losses_B[VA]; // power losses, phase B
			complex power_losses_C[VA]; // power losses, phase C
			complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
			complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
			complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
			complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
			complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
			complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
			complex fault_current_in_A[A]; // fault current flowing in, phase A
			complex fault_current_in_B[A]; // fault current flowing in, phase B
			complex fault_current_in_C[A]; // fault current flowing in, phase C
			complex fault_current_out_A[A]; // fault current flowing out, phase A
			complex fault_current_out_B[A]; // fault current flowing out, phase B
			complex fault_current_out_C[A]; // fault current flowing out, phase C
			set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
			double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		object configuration;
		double length[ft];
	}

	function create_fault();
	function fix_fault();
	function interupdate_pwr_object();
	function recalc_distribution_line();
	function update_power_pwr_object();
	function check_limits_pwr_object();
}

class overhead_line_conductor {
	double geometric_mean_radius[ft]; // radius of the conductor
	double resistance[Ohm/mile]; // resistance in Ohms/mile of the conductor
	double diameter[in]; // Diameter of line for capacitance calculations
	double rating.summer.continuous[A]; // Continuous summer amp rating
	double rating.summer.emergency[A]; // Emergency summer amp rating
	double rating.winter.continuous[A]; // Continuous winter amp rating
	double rating.winter.emergency[A]; // Emergency winter amp rating
}

class power_metrics {
	function calc_metrics();
	function reset_interval_metrics();
	function reset_annual_metrics();
	function init_reliability();
	function logfile_extra();
	double SAIFI; // Displays annual SAIFI values as per IEEE 1366-2003
	double SAIFI_int; // Displays SAIFI values over the period specified by base_time_value as per IEEE 1366-2003
	double SAIDI; // Displays annual SAIDI values as per IEEE 1366-2003
	double SAIDI_int; // Displays SAIDI values over the period specified by base_time_value as per IEEE 1366-2003
	double CAIDI; // Displays annual CAIDI values as per IEEE 1366-2003
	double CAIDI_int; // Displays SAIDI values over the period specified by base_time_value as per IEEE 1366-2003
	double ASAI; // Displays annual AISI values as per IEEE 1366-2003
	double ASAI_int; // Displays AISI values over the period specified by base_time_value as per IEEE 1366-2003
	double MAIFI; // Displays annual MAIFI values as per IEEE 1366-2003
	double MAIFI_int; // Displays MAIFI values over the period specified by base_time_value as per IEEE 1366-2003
	double base_time_value[s]; // time period over which _int values are claculated
}

class powerflow_library {
}

class powerflow_object {
	set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
	double nominal_voltage[V];
}

class powerflow_object {
	set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
	double nominal_voltage[V];
}

class pqload {
	parent load;
	class load {
		parent node;
		class node {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function delta_linkage_node();
			function interupdate_pwr_object();
			function delta_freq_pwr_object();
			enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
			set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
			object reference_bus; // reference bus from which frequency is defined
			double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
			complex voltage_A[V]; // bus voltage, Phase A to ground
			complex voltage_B[V]; // bus voltage, Phase B to ground
			complex voltage_C[V]; // bus voltage, Phase C to ground
			complex voltage_AB[V]; // line voltages, Phase AB
			complex voltage_BC[V]; // line voltages, Phase BC
			complex voltage_CA[V]; // line voltages, Phase CA
			complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
			complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
			complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
			complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
			complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
			complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
			complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
			complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
			complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
			complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
			complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
			complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
			complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
			complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
			complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
			complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
			double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
			double previous_uptime[min]; // Previous time between disconnects of node in minutes
			double current_uptime[min]; // Current time since last disconnect of node in minutes
			bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
			object topological_parent; // topological parent as per GLM configuration
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {A=4, I=3, C=2, R=1, U=0} load_class; // Flag to track load type, not currently used for anything except sorting
		complex constant_power_A[VA]; // constant power load on phase A, specified as VA
		complex constant_power_B[VA]; // constant power load on phase B, specified as VA
		complex constant_power_C[VA]; // constant power load on phase C, specified as VA
		double constant_power_A_real[W]; // constant power load on phase A, real only, specified as W
		double constant_power_B_real[W]; // constant power load on phase B, real only, specified as W
		double constant_power_C_real[W]; // constant power load on phase C, real only, specified as W
		double constant_power_A_reac[VAr]; // constant power load on phase A, imaginary only, specified as VAr
		double constant_power_B_reac[VAr]; // constant power load on phase B, imaginary only, specified as VAr
		double constant_power_C_reac[VAr]; // constant power load on phase C, imaginary only, specified as VAr
		complex constant_current_A[A]; // constant current load on phase A, specified as Amps
		complex constant_current_B[A]; // constant current load on phase B, specified as Amps
		complex constant_current_C[A]; // constant current load on phase C, specified as Amps
		double constant_current_A_real[A]; // constant current load on phase A, real only, specified as Amps
		double constant_current_B_real[A]; // constant current load on phase B, real only, specified as Amps
		double constant_current_C_real[A]; // constant current load on phase C, real only, specified as Amps
		double constant_current_A_reac[A]; // constant current load on phase A, imaginary only, specified as Amps
		double constant_current_B_reac[A]; // constant current load on phase B, imaginary only, specified as Amps
		double constant_current_C_reac[A]; // constant current load on phase C, imaginary only, specified as Amps
		complex constant_impedance_A[Ohm]; // constant impedance load on phase A, specified as Ohms
		complex constant_impedance_B[Ohm]; // constant impedance load on phase B, specified as Ohms
		complex constant_impedance_C[Ohm]; // constant impedance load on phase C, specified as Ohms
		double constant_impedance_A_real[Ohm]; // constant impedance load on phase A, real only, specified as Ohms
		double constant_impedance_B_real[Ohm]; // constant impedance load on phase B, real only, specified as Ohms
		double constant_impedance_C_real[Ohm]; // constant impedance load on phase C, real only, specified as Ohms
		double constant_impedance_A_reac[Ohm]; // constant impedance load on phase A, imaginary only, specified as Ohms
		double constant_impedance_B_reac[Ohm]; // constant impedance load on phase B, imaginary only, specified as Ohms
		double constant_impedance_C_reac[Ohm]; // constant impedance load on phase C, imaginary only, specified as Ohms
		complex constant_power_AN[VA]; // constant power wye-connected load on phase A, specified as VA
		complex constant_power_BN[VA]; // constant power wye-connected load on phase B, specified as VA
		complex constant_power_CN[VA]; // constant power wye-connected load on phase C, specified as VA
		double constant_power_AN_real[W]; // constant power wye-connected load on phase A, real only, specified as W
		double constant_power_BN_real[W]; // constant power wye-connected load on phase B, real only, specified as W
		double constant_power_CN_real[W]; // constant power wye-connected load on phase C, real only, specified as W
		double constant_power_AN_reac[VAr]; // constant power wye-connected load on phase A, imaginary only, specified as VAr
		double constant_power_BN_reac[VAr]; // constant power wye-connected load on phase B, imaginary only, specified as VAr
		double constant_power_CN_reac[VAr]; // constant power wye-connected load on phase C, imaginary only, specified as VAr
		complex constant_current_AN[A]; // constant current wye-connected load on phase A, specified as Amps
		complex constant_current_BN[A]; // constant current wye-connected load on phase B, specified as Amps
		complex constant_current_CN[A]; // constant current wye-connected load on phase C, specified as Amps
		double constant_current_AN_real[A]; // constant current wye-connected load on phase A, real only, specified as Amps
		double constant_current_BN_real[A]; // constant current wye-connected load on phase B, real only, specified as Amps
		double constant_current_CN_real[A]; // constant current wye-connected load on phase C, real only, specified as Amps
		double constant_current_AN_reac[A]; // constant current wye-connected load on phase A, imaginary only, specified as Amps
		double constant_current_BN_reac[A]; // constant current wye-connected load on phase B, imaginary only, specified as Amps
		double constant_current_CN_reac[A]; // constant current wye-connected load on phase C, imaginary only, specified as Amps
		complex constant_impedance_AN[Ohm]; // constant impedance wye-connected load on phase A, specified as Ohms
		complex constant_impedance_BN[Ohm]; // constant impedance wye-connected load on phase B, specified as Ohms
		complex constant_impedance_CN[Ohm]; // constant impedance wye-connected load on phase C, specified as Ohms
		double constant_impedance_AN_real[Ohm]; // constant impedance wye-connected load on phase A, real only, specified as Ohms
		double constant_impedance_BN_real[Ohm]; // constant impedance wye-connected load on phase B, real only, specified as Ohms
		double constant_impedance_CN_real[Ohm]; // constant impedance wye-connected load on phase C, real only, specified as Ohms
		double constant_impedance_AN_reac[Ohm]; // constant impedance wye-connected load on phase A, imaginary only, specified as Ohms
		double constant_impedance_BN_reac[Ohm]; // constant impedance wye-connected load on phase B, imaginary only, specified as Ohms
		double constant_impedance_CN_reac[Ohm]; // constant impedance wye-connected load on phase C, imaginary only, specified as Ohms
		complex constant_power_AB[VA]; // constant power delta-connected load on phase A, specified as VA
		complex constant_power_BC[VA]; // constant power delta-connected load on phase B, specified as VA
		complex constant_power_CA[VA]; // constant power delta-connected load on phase C, specified as VA
		double constant_power_AB_real[W]; // constant power delta-connected load on phase A, real only, specified as W
		double constant_power_BC_real[W]; // constant power delta-connected load on phase B, real only, specified as W
		double constant_power_CA_real[W]; // constant power delta-connected load on phase C, real only, specified as W
		double constant_power_AB_reac[VAr]; // constant power delta-connected load on phase A, imaginary only, specified as VAr
		double constant_power_BC_reac[VAr]; // constant power delta-connected load on phase B, imaginary only, specified as VAr
		double constant_power_CA_reac[VAr]; // constant power delta-connected load on phase C, imaginary only, specified as VAr
		complex constant_current_AB[A]; // constant current delta-connected load on phase A, specified as Amps
		complex constant_current_BC[A]; // constant current delta-connected load on phase B, specified as Amps
		complex constant_current_CA[A]; // constant current delta-connected load on phase C, specified as Amps
		double constant_current_AB_real[A]; // constant current delta-connected load on phase A, real only, specified as Amps
		double constant_current_BC_real[A]; // constant current delta-connected load on phase B, real only, specified as Amps
		double constant_current_CA_real[A]; // constant current delta-connected load on phase C, real only, specified as Amps
		double constant_current_AB_reac[A]; // constant current delta-connected load on phase A, imaginary only, specified as Amps
		double constant_current_BC_reac[A]; // constant current delta-connected load on phase B, imaginary only, specified as Amps
		double constant_current_CA_reac[A]; // constant current delta-connected load on phase C, imaginary only, specified as Amps
		complex constant_impedance_AB[Ohm]; // constant impedance delta-connected load on phase A, specified as Ohms
		complex constant_impedance_BC[Ohm]; // constant impedance delta-connected load on phase B, specified as Ohms
		complex constant_impedance_CA[Ohm]; // constant impedance delta-connected load on phase C, specified as Ohms
		double constant_impedance_AB_real[Ohm]; // constant impedance delta-connected load on phase A, real only, specified as Ohms
		double constant_impedance_BC_real[Ohm]; // constant impedance delta-connected load on phase B, real only, specified as Ohms
		double constant_impedance_CA_real[Ohm]; // constant impedance delta-connected load on phase C, real only, specified as Ohms
		double constant_impedance_AB_reac[Ohm]; // constant impedance delta-connected load on phase A, imaginary only, specified as Ohms
		double constant_impedance_BC_reac[Ohm]; // constant impedance delta-connected load on phase B, imaginary only, specified as Ohms
		double constant_impedance_CA_reac[Ohm]; // constant impedance delta-connected load on phase C, imaginary only, specified as Ohms
		complex measured_voltage_A; // current measured voltage on phase A
		complex measured_voltage_B; // current measured voltage on phase B
		complex measured_voltage_C; // current measured voltage on phase C
		complex measured_voltage_AB; // current measured voltage on phases AB
		complex measured_voltage_BC; // current measured voltage on phases BC
		complex measured_voltage_CA; // current measured voltage on phases CA
		bool phase_loss_protection; // Trip all three phases of the load if a fault occurs
		double base_power_A[VA]; // in similar format as ZIPload, this represents the nominal power on phase A before applying ZIP fractions
		double base_power_B[VA]; // in similar format as ZIPload, this represents the nominal power on phase B before applying ZIP fractions
		double base_power_C[VA]; // in similar format as ZIPload, this represents the nominal power on phase C before applying ZIP fractions
		double power_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant power portion of load
		double current_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant current portion of load
		double impedance_pf_A[pu]; // in similar format as ZIPload, this is the power factor of the phase A constant impedance portion of load
		double power_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant power portion of load
		double current_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant current portion of load
		double impedance_pf_B[pu]; // in similar format as ZIPload, this is the power factor of the phase B constant impedance portion of load
		double power_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant power portion of load
		double current_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant current portion of load
		double impedance_pf_C[pu]; // in similar format as ZIPload, this is the power factor of the phase C constant impedance portion of load
		double power_fraction_A[pu]; // this is the constant power fraction of base power on phase A
		double current_fraction_A[pu]; // this is the constant current fraction of base power on phase A
		double impedance_fraction_A[pu]; // this is the constant impedance fraction of base power on phase A
		double power_fraction_B[pu]; // this is the constant power fraction of base power on phase B
		double current_fraction_B[pu]; // this is the constant current fraction of base power on phase B
		double impedance_fraction_B[pu]; // this is the constant impedance fraction of base power on phase B
		double power_fraction_C[pu]; // this is the constant power fraction of base power on phase C
		double current_fraction_C[pu]; // this is the constant current fraction of base power on phase C
		double impedance_fraction_C[pu]; // this is the constant impedance fraction of base power on phase C
	}

	object weather;
	double T_nominal[degF];
	double Zp_T[ohm/degF];
	double Zp_H[ohm/%];
	double Zp_S[ohm*h/Btu];
	double Zp_W[ohm/mph];
	double Zp_R[ohm*h/in];
	double Zp[ohm];
	double Zq_T[F/degF];
	double Zq_H[F/%];
	double Zq_S[F*h/Btu];
	double Zq_W[F/mph];
	double Zq_R[F*h/in];
	double Zq[F];
	double Im_T[A/degF];
	double Im_H[A/%];
	double Im_S[A*h/Btu];
	double Im_W[A/mph];
	double Im_R[A*h/in];
	double Im[A];
	double Ia_T[deg/degF];
	double Ia_H[deg/%];
	double Ia_S[deg*h/Btu];
	double Ia_W[deg/mph];
	double Ia_R[deg*h/in];
	double Ia[deg];
	double Pp_T[W/degF];
	double Pp_H[W/%];
	double Pp_S[W*h/Btu];
	double Pp_W[W/mph];
	double Pp_R[W*h/in];
	double Pp[W];
	double Pq_T[VAr/degF];
	double Pq_H[VAr/%];
	double Pq_S[VAr*h/Btu];
	double Pq_W[VAr/mph];
	double Pq_R[VAr*h/in];
	double Pq[VAr];
	double input_temp[degF];
	double input_humid[%];
	double input_solar[Btu/h];
	double input_wind[mph];
	double input_rain[in/h];
	double output_imped_p[Ohm];
	double output_imped_q[Ohm];
	double output_current_m[A];
	double output_current_a[deg];
	double output_power_p[W];
	double output_power_q[VAr];
	complex output_impedance[ohm];
	complex output_current[A];
	complex output_power[VA];
}

class recloser {
	parent switch;
	class switch {
		parent link;
		class link {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function interupdate_pwr_object();
			function update_power_pwr_object();
			function check_limits_pwr_object();
			enumeration {OPEN=0, CLOSED=1} status; // 
			object from; // from_node - source node
			object to; // to_node - load node
			complex power_in[VA]; // power flow in (w.r.t from node)
			complex power_out[VA]; // power flow out (w.r.t to node)
			double power_out_real[W]; // power flow out (w.r.t to node), real
			complex power_losses[VA]; // power losses
			complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
			complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
			complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
			complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
			complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
			complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
			complex power_losses_A[VA]; // power losses, phase A
			complex power_losses_B[VA]; // power losses, phase B
			complex power_losses_C[VA]; // power losses, phase C
			complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
			complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
			complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
			complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
			complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
			complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
			complex fault_current_in_A[A]; // fault current flowing in, phase A
			complex fault_current_in_B[A]; // fault current flowing in, phase B
			complex fault_current_in_C[A]; // fault current flowing in, phase C
			complex fault_current_out_A[A]; // fault current flowing out, phase A
			complex fault_current_out_B[A]; // fault current flowing out, phase B
			complex fault_current_out_C[A]; // fault current flowing out, phase C
			set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
			double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
		}

		function change_switch_state();
		function reliability_operation();
		function create_fault();
		function fix_fault();
		function change_switch_faults();
		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {CLOSED=1, OPEN=0} phase_A_state; // Defines the current state of the phase A switch
		enumeration {CLOSED=1, OPEN=0} phase_B_state; // Defines the current state of the phase B switch
		enumeration {CLOSED=1, OPEN=0} phase_C_state; // Defines the current state of the phase C switch
		enumeration {BANKED=1, INDIVIDUAL=0} operating_mode; // Defines whether the switch operates in a banked or per-phase control mode
		double switch_resistance[Ohm]; // The resistance value of the switch when it is not blown.
	}

	function change_recloser_state();
	function recloser_reliability_operation();
	function change_recloser_faults();
	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	double retry_time[s]; // the amount of time in seconds to wait before the recloser attempts to close
	double max_number_of_tries; // the number of times the recloser will try to close before permanently opening
	double number_of_tries; // Current number of tries recloser has attempted
}

class regulator {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	object configuration; // reference to the regulator_configuration object used to determine regulator properties
	int16 tap_A; // current tap position of tap A
	int16 tap_B; // current tap position of tap B
	int16 tap_C; // current tap position of tap C
	double tap_A_change_count; // count of all physical tap changes on phase A since beginning of simulation (plus initial value)
	double tap_B_change_count; // count of all physical tap changes on phase B since beginning of simulation (plus initial value)
	double tap_C_change_count; // count of all physical tap changes on phase C since beginning of simulation (plus initial value)
	object sense_node; // Node to be monitored for voltage control in remote sense mode
	double regulator_resistance[Ohm]; // The resistance value of the regulator when it is not blown.
}

class regulator_configuration {
	enumeration {CLOSED_DELTA=5, OPEN_DELTA_CABA=4, OPEN_DELTA_BCAC=3, OPEN_DELTA_ABBC=2, WYE_WYE=1, UNKNOWN=0} connect_type; // Designation of connection style
	double band_center[V]; // band center setting of regulator control
	double band_width[V]; // band width setting of regulator control
	double time_delay[s]; // mechanical time delay between tap changes
	double dwell_time[s]; // time delay before a control action of regulator control
	int16 raise_taps; // number of regulator raise taps, or the maximum raise voltage tap position
	int16 lower_taps; // number of regulator lower taps, or the minimum lower voltage tap position
	double current_transducer_ratio[pu]; // primary rating of current transformer
	double power_transducer_ratio[pu]; // potential transformer rating
	double compensator_r_setting_A[V]; // Line Drop Compensation R setting of regulator control (in volts) on Phase A
	double compensator_r_setting_B[V]; // Line Drop Compensation R setting of regulator control (in volts) on Phase B
	double compensator_r_setting_C[V]; // Line Drop Compensation R setting of regulator control (in volts) on Phase C
	double compensator_x_setting_A[V]; // Line Drop Compensation X setting of regulator control (in volts) on Phase A
	double compensator_x_setting_B[V]; // Line Drop Compensation X setting of regulator control (in volts) on Phase B
	double compensator_x_setting_C[V]; // Line Drop Compensation X setting of regulator control (in volts) on Phase C
	set {C=4, B=2, A=1} CT_phase; // phase(s) monitored by CT
	set {C=4, B=2, A=1} PT_phase; // phase(s) monitored by PT
	double regulation; // regulation of voltage regulator in %
	enumeration {BANK=2, INDIVIDUAL=1} control_level; // Designates whether control is on per-phase or banked level
	enumeration {REMOTE_NODE=3, LINE_DROP_COMP=4, OUTPUT_VOLTAGE=2, MANUAL=1} Control; // Type of control used for regulating voltage
	enumeration {B=2, A=1} Type; // Defines regulator type
	int16 tap_pos_A; // initial tap position of phase A
	int16 tap_pos_B; // initial tap position of phase B
	int16 tap_pos_C; // initial tap position of phase C
}

class restoration {
	function perform_restoration();
	int32 reconfig_attempts; // Number of reconfigurations/timestep to try before giving up
	int32 reconfig_iteration_limit; // Number of iterations to let PF go before flagging this as a bad reconfiguration
	object source_vertex; // Source vertex object for reconfiguration
	object faulted_section; // Faulted section for reconfiguration
	char1024 feeder_power_limit; // Comma-separated power limit (VA) for feeders during reconfiguration
	char1024 feeder_power_links; // Comma-separated list of link-based objects for monitoring power through
	char1024 feeder_vertex_list; // Comma-separated object list that defines the feeder vertices
	char1024 microgrid_power_limit; // Comma-separated power limit (complex VA) for microgrids during reconfiguration
	char1024 microgrid_power_links; // Comma-separated list of link-based objects for monitoring power through
	char1024 microgrid_vertex_list; // Comma-separated object list that defines the microgrid vertices
	double lower_voltage_limit[pu]; // Lower voltage limit for the reconfiguration validity checks - per unit
	double upper_voltage_limit[pu]; // Upper voltage limit for the reconfiguration validity checks - per unit
	char1024 output_filename; // Output text file name to describe final or attempted switching operations
}

class sectionalizer {
	parent switch;
	class switch {
		parent link;
		class link {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function interupdate_pwr_object();
			function update_power_pwr_object();
			function check_limits_pwr_object();
			enumeration {OPEN=0, CLOSED=1} status; // 
			object from; // from_node - source node
			object to; // to_node - load node
			complex power_in[VA]; // power flow in (w.r.t from node)
			complex power_out[VA]; // power flow out (w.r.t to node)
			double power_out_real[W]; // power flow out (w.r.t to node), real
			complex power_losses[VA]; // power losses
			complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
			complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
			complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
			complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
			complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
			complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
			complex power_losses_A[VA]; // power losses, phase A
			complex power_losses_B[VA]; // power losses, phase B
			complex power_losses_C[VA]; // power losses, phase C
			complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
			complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
			complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
			complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
			complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
			complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
			complex fault_current_in_A[A]; // fault current flowing in, phase A
			complex fault_current_in_B[A]; // fault current flowing in, phase B
			complex fault_current_in_C[A]; // fault current flowing in, phase C
			complex fault_current_out_A[A]; // fault current flowing out, phase A
			complex fault_current_out_B[A]; // fault current flowing out, phase B
			complex fault_current_out_C[A]; // fault current flowing out, phase C
			set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
			double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
		}

		function change_switch_state();
		function reliability_operation();
		function create_fault();
		function fix_fault();
		function change_switch_faults();
		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {CLOSED=1, OPEN=0} phase_A_state; // Defines the current state of the phase A switch
		enumeration {CLOSED=1, OPEN=0} phase_B_state; // Defines the current state of the phase B switch
		enumeration {CLOSED=1, OPEN=0} phase_C_state; // Defines the current state of the phase C switch
		enumeration {BANKED=1, INDIVIDUAL=0} operating_mode; // Defines whether the switch operates in a banked or per-phase control mode
		double switch_resistance[Ohm]; // The resistance value of the switch when it is not blown.
	}

	function change_sectionalizer_state();
	function sectionalizer_reliability_operation();
	function change_sectionalizer_faults();
	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
}

class series_reactor {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	complex phase_A_impedance[Ohm]; // Series impedance of reactor on phase A
	double phase_A_resistance[Ohm]; // Resistive portion of phase A's impedance
	double phase_A_reactance[Ohm]; // Reactive portion of phase A's impedance
	complex phase_B_impedance[Ohm]; // Series impedance of reactor on phase B
	double phase_B_resistance[Ohm]; // Resistive portion of phase B's impedance
	double phase_B_reactance[Ohm]; // Reactive portion of phase B's impedance
	complex phase_C_impedance[Ohm]; // Series impedance of reactor on phase C
	double phase_C_resistance[Ohm]; // Resistive portion of phase C's impedance
	double phase_C_reactance[Ohm]; // Reactive portion of phase C's impedance
	double rated_current_limit[A]; // Rated current limit for the reactor
}

class substation {
	parent node;
	class node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_A[V]; // bus voltage, Phase A to ground
		complex voltage_B[V]; // bus voltage, Phase B to ground
		complex voltage_C[V]; // bus voltage, Phase C to ground
		complex voltage_AB[V]; // line voltages, Phase AB
		complex voltage_BC[V]; // line voltages, Phase BC
		complex voltage_CA[V]; // line voltages, Phase CA
		complex current_A[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_B[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex current_C[A]; // bus current injection (in = positive), this an accumulator only, not a output or input variable
		complex power_A[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_B[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex power_C[VA]; // bus power injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_A[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_B[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex shunt_C[S]; // bus shunt admittance, this an accumulator only, not a output or input variable
		complex current_AB[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BC[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CA[A]; // bus current delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_AN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_BN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex current_CN[A]; // bus current wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AB[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BC[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CA[VA]; // bus power delta-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_AN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_BN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex power_CN[VA]; // bus power wye-connected injection (in = positive), this an accumulator only, not a output or input variable
		complex shunt_AB[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BC[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CA[S]; // bus shunt delta-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_AN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_BN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		complex shunt_CN[S]; // bus shunt wye-connected admittance, this an accumulator only, not a output or input variable
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		bool Norton_dynamic; // Flag to indicate a Norton-equivalent connection -- used for generators and deltamode
		object topological_parent; // topological parent as per GLM configuration
	}

	complex zero_sequence_voltage[V]; // The zero sequence representation of the voltage for the substation object.
	complex positive_sequence_voltage[V]; // The positive sequence representation of the voltage for the substation object.
	complex negative_sequence_voltage[V]; // The negative sequence representation of the voltage for the substation object.
	double base_power[VA]; // The 3 phase VA power rating of the substation.
	double power_convergence_value[VA]; // Default convergence criterion before power is posted to pw_load objects if connected, otherwise ignored
	enumeration {PHASE_C=2, PHASE_B=1, PHASE_A=0} reference_phase; // The reference phase for the positive sequence voltage.
	complex transmission_level_constant_power_load[VA]; // the average constant power load to be posted directly to the pw_load object.
	complex transmission_level_constant_current_load[A]; // the average constant current load at nominal voltage to be posted directly to the pw_load object.
	complex transmission_level_constant_impedance_load[Ohm]; // the average constant impedance load at nominal voltage to be posted directly to the pw_load object.
	complex average_distribution_load[VA]; // The average of the loads on all three phases at the substation object.
	complex distribution_power_A[VA];
	complex distribution_power_B[VA];
	complex distribution_power_C[VA];
	complex distribution_voltage_A[V];
	complex distribution_voltage_B[V];
	complex distribution_voltage_C[V];
	complex distribution_voltage_AB[V];
	complex distribution_voltage_BC[V];
	complex distribution_voltage_CA[V];
	complex distribution_current_A[A];
	complex distribution_current_B[A];
	complex distribution_current_C[A];
	double distribution_real_energy[Wh];
}

class switch {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function change_switch_state();
	function reliability_operation();
	function create_fault();
	function fix_fault();
	function change_switch_faults();
	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	enumeration {CLOSED=1, OPEN=0} phase_A_state; // Defines the current state of the phase A switch
	enumeration {CLOSED=1, OPEN=0} phase_B_state; // Defines the current state of the phase B switch
	enumeration {CLOSED=1, OPEN=0} phase_C_state; // Defines the current state of the phase C switch
	enumeration {BANKED=1, INDIVIDUAL=0} operating_mode; // Defines whether the switch operates in a banked or per-phase control mode
	double switch_resistance[Ohm]; // The resistance value of the switch when it is not blown.
}

class transformer {
	parent link;
	class link {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		enumeration {OPEN=0, CLOSED=1} status; // 
		object from; // from_node - source node
		object to; // to_node - load node
		complex power_in[VA]; // power flow in (w.r.t from node)
		complex power_out[VA]; // power flow out (w.r.t to node)
		double power_out_real[W]; // power flow out (w.r.t to node), real
		complex power_losses[VA]; // power losses
		complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
		complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
		complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
		complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
		complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
		complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
		complex power_losses_A[VA]; // power losses, phase A
		complex power_losses_B[VA]; // power losses, phase B
		complex power_losses_C[VA]; // power losses, phase C
		complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
		complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
		complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
		complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
		complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
		complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
		complex fault_current_in_A[A]; // fault current flowing in, phase A
		complex fault_current_in_B[A]; // fault current flowing in, phase B
		complex fault_current_in_C[A]; // fault current flowing in, phase C
		complex fault_current_out_A[A]; // fault current flowing out, phase A
		complex fault_current_out_B[A]; // fault current flowing out, phase B
		complex fault_current_out_C[A]; // fault current flowing out, phase C
		set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
		double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
		double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
		double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
	}

	function power_calculation();
	function interupdate_pwr_object();
	function update_power_pwr_object();
	function check_limits_pwr_object();
	object configuration; // Configuration library used for transformer setup
	object climate; // climate object used to describe thermal model ambient temperature
	double ambient_temperature[degC]; // ambient temperature in degrees C
	double top_oil_hot_spot_temperature[degC]; // top-oil hottest-spot temperature, degrees C
	double winding_hot_spot_temperature[degC]; // winding hottest-spot temperature, degrees C
	double percent_loss_of_life; // the percent loss of life
	double aging_constant; // the aging rate slope for the transformer insulation
	bool use_thermal_model; // boolean to enable use of thermal model
	double transformer_replacement_count; // counter of the number times the transformer has been replaced due to lifetime failure
	double aging_granularity[s]; // maximum timestep before updating thermal and aging model in seconds
}

class transformer_configuration {
	enumeration {SINGLE_PHASE_CENTER_TAPPED=5, SINGLE_PHASE=4, DELTA_GWYE=3, DELTA_DELTA=2, WYE_WYE=1, UNKNOWN=0} connect_type; // connect type enum: Wye-Wye, single-phase, etc.
	enumeration {VAULT=3, PADMOUNT=2, POLETOP=1, UNKNOWN=0} install_type; // Defines location of the transformer installation
	enumeration {DRY=2, MINERAL_OIL=1, UNKNOWN=0} coolant_type; // coolant type, used in life time model
	enumeration {DFOW=6, DFOA=5, NDFOW=4, NDFOA=3, FA=2, OA=1, UNKNOWN=0} cooling_type; // type of coolant fluid used in life time model
	double primary_voltage[V]; // primary voltage level in L-L value kV
	double secondary_voltage[V]; // secondary voltage level kV
	double power_rating[kVA]; // kVA rating of transformer, total
	double powerA_rating[kVA]; // kVA rating of transformer, phase A
	double powerB_rating[kVA]; // kVA rating of transformer, phase B
	double powerC_rating[kVA]; // kVA rating of transformer, phase C
	double resistance[pu*Ohm]; // Series impedance, pu, real
	double reactance[pu*Ohm]; // Series impedance, pu, imag
	complex impedance[pu*Ohm]; // Series impedance, pu
	double resistance1[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu, real
	double reactance1[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu, imag
	complex impedance1[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu
	double resistance2[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu, real
	double reactance2[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu, imag
	complex impedance2[pu*Ohm]; // Secondary series impedance (only used when you want to define each individual winding seperately, pu
	double shunt_resistance[pu*Ohm]; // Shunt impedance on primary side, pu, real
	double shunt_reactance[pu*Ohm]; // Shunt impedance on primary side, pu, imag
	complex shunt_impedance[pu*Ohm]; // Shunt impedance on primary side, pu
	double core_coil_weight[lb]; // The weight of the core and coil assembly in pounds
	double tank_fittings_weight[lb]; // The weight of the tank and fittings in pounds
	double oil_volume[gal]; // The number of gallons of oil in the transformer
	double rated_winding_time_constant[h]; // The rated winding time constant in hours
	double rated_winding_hot_spot_rise[degC]; // winding hottest-spot rise over ambient temperature at rated load, degrees C
	double rated_top_oil_rise[degC]; // top-oil hottest-spot rise over ambient temperature at rated load, degrees C
	double no_load_loss[pu]; // Another method of specifying transformer impedances, defined as per unit power values (shunt)
	double full_load_loss[pu]; // Another method of specifying transformer impedances, defined as per unit power values (shunt and series)
	double reactance_resistance_ratio; // the reactance to resistance ratio (X/R)
	double installed_insulation_life[h]; // the normal lifetime of the transformer insulation at rated load, hours
}

class triplex_line {
	parent line;
	class line {
		parent link;
		class link {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function interupdate_pwr_object();
			function update_power_pwr_object();
			function check_limits_pwr_object();
			enumeration {OPEN=0, CLOSED=1} status; // 
			object from; // from_node - source node
			object to; // to_node - load node
			complex power_in[VA]; // power flow in (w.r.t from node)
			complex power_out[VA]; // power flow out (w.r.t to node)
			double power_out_real[W]; // power flow out (w.r.t to node), real
			complex power_losses[VA]; // power losses
			complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
			complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
			complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
			complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
			complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
			complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
			complex power_losses_A[VA]; // power losses, phase A
			complex power_losses_B[VA]; // power losses, phase B
			complex power_losses_C[VA]; // power losses, phase C
			complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
			complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
			complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
			complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
			complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
			complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
			complex fault_current_in_A[A]; // fault current flowing in, phase A
			complex fault_current_in_B[A]; // fault current flowing in, phase B
			complex fault_current_in_C[A]; // fault current flowing in, phase C
			complex fault_current_out_A[A]; // fault current flowing out, phase A
			complex fault_current_out_B[A]; // fault current flowing out, phase B
			complex fault_current_out_C[A]; // fault current flowing out, phase C
			set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
			double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		object configuration;
		double length[ft];
	}

	function interupdate_pwr_object();
	function recalc_distribution_line();
	function update_power_pwr_object();
	function check_limits_pwr_object();
}

class triplex_line_conductor {
	double resistance[Ohm/mile]; // resistance of cable in ohm/mile
	double geometric_mean_radius[ft]; // geometric mean radius of the cable
	double rating.summer.continuous[A]; // amp ratings for the cable during continuous operation in summer
	double rating.summer.emergency[A]; // amp ratings for the cable during short term operation in summer
	double rating.winter.continuous[A]; // amp ratings for the cable during continuous operation in winter
	double rating.winter.emergency[A]; // amp ratings for the cable during short term operation in winter
}

class triplex_line_configuration {
	object conductor_1; // conductor type for phase 1
	object conductor_2; // conductor type for phase 2
	object conductor_N; // conductor type for phase N
	double insulation_thickness[in]; // thickness of insulation around cabling
	double diameter[in]; // total diameter of cable
	object spacing; // defines the line spacing configuration
	complex z11[Ohm/mile]; // phase 1 self-impedance, used for direct entry of impedance values
	complex z12[Ohm/mile]; // phase 1-2 induced impedance, used for direct entry of impedance values
	complex z21[Ohm/mile]; // phase 2-1 induced impedance, used for direct entry of impedance values
	complex z22[Ohm/mile]; // phase 2 self-impedance, used for direct entry of impedance values
}

class triplex_load {
	parent triplex_node;
	class triplex_node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_1[V]; // bus voltage, phase 1 to ground
		complex voltage_2[V]; // bus voltage, phase 2 to ground
		complex voltage_N[V]; // bus voltage, phase N to ground
		complex voltage_12[V]; // bus voltage, phase 1 to 2
		complex voltage_1N[V]; // bus voltage, phase 1 to N
		complex voltage_2N[V]; // bus voltage, phase 2 to N
		complex current_1[A]; // constant current load on phase 1, also acts as accumulator
		complex current_2[A]; // constant current load on phase 2, also acts as accumulator
		complex current_N[A]; // constant current load on phase N, also acts as accumulator
		double current_1_real[A]; // constant current load on phase 1, real
		double current_2_real[A]; // constant current load on phase 2, real
		double current_N_real[A]; // constant current load on phase N, real
		double current_1_reac[A]; // constant current load on phase 1, imag
		double current_2_reac[A]; // constant current load on phase 2, imag
		double current_N_reac[A]; // constant current load on phase N, imag
		complex current_12[A]; // constant current load on phase 1 to 2
		double current_12_real[A]; // constant current load on phase 1 to 2, real
		double current_12_reac[A]; // constant current load on phase 1 to 2, imag
		complex residential_nominal_current_1[A]; // posted current on phase 1 from a residential object, if attached
		complex residential_nominal_current_2[A]; // posted current on phase 2 from a residential object, if attached
		complex residential_nominal_current_12[A]; // posted current on phase 1 to 2 from a residential object, if attached
		double residential_nominal_current_1_real[A]; // posted current on phase 1, real, from a residential object, if attached
		double residential_nominal_current_1_imag[A]; // posted current on phase 1, imag, from a residential object, if attached
		double residential_nominal_current_2_real[A]; // posted current on phase 2, real, from a residential object, if attached
		double residential_nominal_current_2_imag[A]; // posted current on phase 2, imag, from a residential object, if attached
		double residential_nominal_current_12_real[A]; // posted current on phase 1 to 2, real, from a residential object, if attached
		double residential_nominal_current_12_imag[A]; // posted current on phase 1 to 2, imag, from a residential object, if attached
		complex power_1[VA]; // constant power on phase 1 (120V)
		complex power_2[VA]; // constant power on phase 2 (120V)
		complex power_12[VA]; // constant power on phase 1 to 2 (240V)
		double power_1_real[W]; // constant power on phase 1, real
		double power_2_real[W]; // constant power on phase 2, real
		double power_12_real[W]; // constant power on phase 1 to 2, real
		double power_1_reac[VAr]; // constant power on phase 1, imag
		double power_2_reac[VAr]; // constant power on phase 2, imag
		double power_12_reac[VAr]; // constant power on phase 1 to 2, imag
		complex shunt_1[S]; // constant shunt impedance on phase 1
		complex shunt_2[S]; // constant shunt impedance on phase 2
		complex shunt_12[S]; // constant shunt impedance on phase 1 to 2
		complex impedance_1[Ohm]; // constant series impedance on phase 1
		complex impedance_2[Ohm]; // constant series impedance on phase 2
		complex impedance_12[Ohm]; // constant series impedance on phase 1 to 2
		double impedance_1_real[Ohm]; // constant series impedance on phase 1, real
		double impedance_2_real[Ohm]; // constant series impedance on phase 2, real
		double impedance_12_real[Ohm]; // constant series impedance on phase 1 to 2, real
		double impedance_1_reac[Ohm]; // constant series impedance on phase 1, imag
		double impedance_2_reac[Ohm]; // constant series impedance on phase 2, imag
		double impedance_12_reac[Ohm]; // constant series impedance on phase 1 to 2, imag
		bool house_present; // boolean for detecting whether a house is attached, not an input
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		object topological_parent; // topological parent as per GLM configuration
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	enumeration {A=4, I=3, C=2, R=1, U=0} load_class; // Flag to track load type, not currently used for anything except sorting
	complex constant_power_1[VA]; // constant power load on split phase 1, specified as VA
	complex constant_power_2[VA]; // constant power load on split phase 2, specified as VA
	complex constant_power_12[VA]; // constant power load on split phase 12, specified as VA
	double constant_power_1_real[W]; // constant power load on spit phase 1, real only, specified as W
	double constant_power_2_real[W]; // constant power load on phase 2, real only, specified as W
	double constant_power_12_real[W]; // constant power load on phase 12, real only, specified as W
	double constant_power_1_reac[VAr]; // constant power load on phase 1, imaginary only, specified as VAr
	double constant_power_2_reac[VAr]; // constant power load on phase 2, imaginary only, specified as VAr
	double constant_power_12_reac[VAr]; // constant power load on phase 12, imaginary only, specified as VAr
	complex constant_current_1[A]; // constant current load on phase 1, specified as Amps
	complex constant_current_2[A]; // constant current load on phase 2, specified as Amps
	complex constant_current_12[A]; // constant current load on phase 12, specified as Amps
	double constant_current_1_real[A]; // constant current load on phase 1, real only, specified as Amps
	double constant_current_2_real[A]; // constant current load on phase 2, real only, specified as Amps
	double constant_current_12_real[A]; // constant current load on phase 12, real only, specified as Amps
	double constant_current_1_reac[A]; // constant current load on phase 1, imaginary only, specified as Amps
	double constant_current_2_reac[A]; // constant current load on phase 2, imaginary only, specified as Amps
	double constant_current_12_reac[A]; // constant current load on phase 12, imaginary only, specified as Amps
	complex constant_impedance_1[Ohm]; // constant impedance load on phase 1, specified as Ohms
	complex constant_impedance_2[Ohm]; // constant impedance load on phase 2, specified as Ohms
	complex constant_impedance_12[Ohm]; // constant impedance load on phase 12, specified as Ohms
	double constant_impedance_1_real[Ohm]; // constant impedance load on phase 1, real only, specified as Ohms
	double constant_impedance_2_real[Ohm]; // constant impedance load on phase 2, real only, specified as Ohms
	double constant_impedance_12_real[Ohm]; // constant impedance load on phase 12, real only, specified as Ohms
	double constant_impedance_1_reac[Ohm]; // constant impedance load on phase 1, imaginary only, specified as Ohms
	double constant_impedance_2_reac[Ohm]; // constant impedance load on phase 2, imaginary only, specified as Ohms
	double constant_impedance_12_reac[Ohm]; // constant impedance load on phase 12, imaginary only, specified as Ohms
	complex measured_voltage_1; // current measured voltage on phase 1
	complex measured_voltage_2; // current measured voltage on phase 2
	complex measured_voltage_12; // current measured voltage on phase 12
	double base_power_1[VA]; // in similar format as ZIPload, this represents the nominal power on phase 1 before applying ZIP fractions
	double base_power_2[VA]; // in similar format as ZIPload, this represents the nominal power on phase 2 before applying ZIP fractions
	double base_power_12[VA]; // in similar format as ZIPload, this represents the nominal power on phase 12 before applying ZIP fractions
	double power_pf_1[pu]; // in similar format as ZIPload, this is the power factor of the phase 1 constant power portion of load
	double current_pf_1[pu]; // in similar format as ZIPload, this is the power factor of the phase 1 constant current portion of load
	double impedance_pf_1[pu]; // in similar format as ZIPload, this is the power factor of the phase 1 constant impedance portion of load
	double power_pf_2[pu]; // in similar format as ZIPload, this is the power factor of the phase 2 constant power portion of load
	double current_pf_2[pu]; // in similar format as ZIPload, this is the power factor of the phase 2 constant current portion of load
	double impedance_pf_2[pu]; // in similar format as ZIPload, this is the power factor of the phase 2 constant impedance portion of load
	double power_pf_12[pu]; // in similar format as ZIPload, this is the power factor of the phase 12 constant power portion of load
	double current_pf_12[pu]; // in similar format as ZIPload, this is the power factor of the phase 12 constant current portion of load
	double impedance_pf_12[pu]; // in similar format as ZIPload, this is the power factor of the phase 12 constant impedance portion of load
	double power_fraction_1[pu]; // this is the constant power fraction of base power on phase 1
	double current_fraction_1[pu]; // this is the constant current fraction of base power on phase 1
	double impedance_fraction_1[pu]; // this is the constant impedance fraction of base power on phase 1
	double power_fraction_2[pu]; // this is the constant power fraction of base power on phase 2
	double current_fraction_2[pu]; // this is the constant current fraction of base power on phase 2
	double impedance_fraction_2[pu]; // this is the constant impedance fraction of base power on phase 2
	double power_fraction_12[pu]; // this is the constant power fraction of base power on phase 12
	double current_fraction_12[pu]; // this is the constant current fraction of base power on phase 12
	double impedance_fraction_12[pu]; // this is the constant impedance fraction of base power on phase 12
}

class triplex_meter {
	parent triplex_node;
	class triplex_node {
		parent powerflow_object;
		class powerflow_object {
			set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
			double nominal_voltage[V];
		}

		function delta_linkage_node();
		function interupdate_pwr_object();
		function delta_freq_pwr_object();
		enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
		set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
		object reference_bus; // reference bus from which frequency is defined
		double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
		complex voltage_1[V]; // bus voltage, phase 1 to ground
		complex voltage_2[V]; // bus voltage, phase 2 to ground
		complex voltage_N[V]; // bus voltage, phase N to ground
		complex voltage_12[V]; // bus voltage, phase 1 to 2
		complex voltage_1N[V]; // bus voltage, phase 1 to N
		complex voltage_2N[V]; // bus voltage, phase 2 to N
		complex current_1[A]; // constant current load on phase 1, also acts as accumulator
		complex current_2[A]; // constant current load on phase 2, also acts as accumulator
		complex current_N[A]; // constant current load on phase N, also acts as accumulator
		double current_1_real[A]; // constant current load on phase 1, real
		double current_2_real[A]; // constant current load on phase 2, real
		double current_N_real[A]; // constant current load on phase N, real
		double current_1_reac[A]; // constant current load on phase 1, imag
		double current_2_reac[A]; // constant current load on phase 2, imag
		double current_N_reac[A]; // constant current load on phase N, imag
		complex current_12[A]; // constant current load on phase 1 to 2
		double current_12_real[A]; // constant current load on phase 1 to 2, real
		double current_12_reac[A]; // constant current load on phase 1 to 2, imag
		complex residential_nominal_current_1[A]; // posted current on phase 1 from a residential object, if attached
		complex residential_nominal_current_2[A]; // posted current on phase 2 from a residential object, if attached
		complex residential_nominal_current_12[A]; // posted current on phase 1 to 2 from a residential object, if attached
		double residential_nominal_current_1_real[A]; // posted current on phase 1, real, from a residential object, if attached
		double residential_nominal_current_1_imag[A]; // posted current on phase 1, imag, from a residential object, if attached
		double residential_nominal_current_2_real[A]; // posted current on phase 2, real, from a residential object, if attached
		double residential_nominal_current_2_imag[A]; // posted current on phase 2, imag, from a residential object, if attached
		double residential_nominal_current_12_real[A]; // posted current on phase 1 to 2, real, from a residential object, if attached
		double residential_nominal_current_12_imag[A]; // posted current on phase 1 to 2, imag, from a residential object, if attached
		complex power_1[VA]; // constant power on phase 1 (120V)
		complex power_2[VA]; // constant power on phase 2 (120V)
		complex power_12[VA]; // constant power on phase 1 to 2 (240V)
		double power_1_real[W]; // constant power on phase 1, real
		double power_2_real[W]; // constant power on phase 2, real
		double power_12_real[W]; // constant power on phase 1 to 2, real
		double power_1_reac[VAr]; // constant power on phase 1, imag
		double power_2_reac[VAr]; // constant power on phase 2, imag
		double power_12_reac[VAr]; // constant power on phase 1 to 2, imag
		complex shunt_1[S]; // constant shunt impedance on phase 1
		complex shunt_2[S]; // constant shunt impedance on phase 2
		complex shunt_12[S]; // constant shunt impedance on phase 1 to 2
		complex impedance_1[Ohm]; // constant series impedance on phase 1
		complex impedance_2[Ohm]; // constant series impedance on phase 2
		complex impedance_12[Ohm]; // constant series impedance on phase 1 to 2
		double impedance_1_real[Ohm]; // constant series impedance on phase 1, real
		double impedance_2_real[Ohm]; // constant series impedance on phase 2, real
		double impedance_12_real[Ohm]; // constant series impedance on phase 1 to 2, real
		double impedance_1_reac[Ohm]; // constant series impedance on phase 1, imag
		double impedance_2_reac[Ohm]; // constant series impedance on phase 2, imag
		double impedance_12_reac[Ohm]; // constant series impedance on phase 1 to 2, imag
		bool house_present; // boolean for detecting whether a house is attached, not an input
		enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
		double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
		double previous_uptime[min]; // Previous time between disconnects of node in minutes
		double current_uptime[min]; // Current time since last disconnect of node in minutes
		object topological_parent; // topological parent as per GLM configuration
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	double measured_real_energy[Wh]; // metered real energy consumption
	double measured_reactive_energy[VAh]; // metered reactive energy consumption
	complex measured_power[VA]; // metered power
	complex indiv_measured_power_1[VA]; // metered power, phase 1
	complex indiv_measured_power_2[VA]; // metered power, phase 2
	complex indiv_measured_power_N[VA]; // metered power, phase N
	double measured_demand[W]; // metered demand (peak of power)
	double measured_real_power[W]; // metered real power
	double measured_reactive_power[VAr]; // metered reactive power
	complex meter_power_consumption[VA]; // power consumed by meter operation
	complex measured_voltage_1[V]; // measured voltage, phase 1 to ground
	complex measured_voltage_2[V]; // measured voltage, phase 2 to ground
	complex measured_voltage_N[V]; // measured voltage, phase N to ground
	complex measured_current_1[A]; // measured current, phase 1
	complex measured_current_2[A]; // measured current, phase 2
	complex measured_current_N[A]; // measured current, phase N
	bool customer_interrupted; // Reliability flag - goes active if the customer is in an interrupted state
	bool customer_interrupted_secondary; // Reliability flag - goes active if the customer is in a secondary interrupted state - i.e., momentary
	double monthly_bill[$]; // Accumulator for the current month's bill
	double previous_monthly_bill[$]; // Total monthly bill for the previous month
	double previous_monthly_energy[kWh]; // 
	double monthly_fee[$]; // Total monthly energy for the previous month
	double monthly_energy[kWh]; // Accumulator for the current month's energy
	enumeration {TIERED_RTP=4, HOURLY=3, TIERED=2, UNIFORM=1, NONE=0} bill_mode; // Designates the bill mode to be used
	object power_market; // Designates the auction object where prices are read from for bill mode
	int32 bill_day; // Day bill is to be processed (assumed to occur at midnight of that day)
	double price[$/kWh]; // Standard uniform pricing
	double price_base[$/kWh]; // Used only in TIERED_RTP mode to describe the price before the first tier
	double first_tier_price[$/kWh]; // first tier price of energy between first and second tier energy
	double first_tier_energy[kWh]; // price of energy on tier above price or price base
	double second_tier_price[$/kWh]; // first tier price of energy between second and third tier energy
	double second_tier_energy[kWh]; // price of energy on tier above first tier
	double third_tier_price[$/kWh]; // first tier price of energy greater than third tier energy
	double third_tier_energy[kWh]; // price of energy on tier above second tier
}

class triplex_node {
	parent powerflow_object;
	class powerflow_object {
		set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
		double nominal_voltage[V];
	}

	function delta_linkage_node();
	function interupdate_pwr_object();
	function delta_freq_pwr_object();
	enumeration {SWING=2, PV=1, PQ=0} bustype; // defines whether the node is a PQ, PV, or SWING node
	set {HASSOURCE=1} busflags; // flag indicates node has a source for voltage, i.e. connects to the swing node
	object reference_bus; // reference bus from which frequency is defined
	double maximum_voltage_error[V]; // convergence voltage limit or convergence criteria
	complex voltage_1[V]; // bus voltage, phase 1 to ground
	complex voltage_2[V]; // bus voltage, phase 2 to ground
	complex voltage_N[V]; // bus voltage, phase N to ground
	complex voltage_12[V]; // bus voltage, phase 1 to 2
	complex voltage_1N[V]; // bus voltage, phase 1 to N
	complex voltage_2N[V]; // bus voltage, phase 2 to N
	complex current_1[A]; // constant current load on phase 1, also acts as accumulator
	complex current_2[A]; // constant current load on phase 2, also acts as accumulator
	complex current_N[A]; // constant current load on phase N, also acts as accumulator
	double current_1_real[A]; // constant current load on phase 1, real
	double current_2_real[A]; // constant current load on phase 2, real
	double current_N_real[A]; // constant current load on phase N, real
	double current_1_reac[A]; // constant current load on phase 1, imag
	double current_2_reac[A]; // constant current load on phase 2, imag
	double current_N_reac[A]; // constant current load on phase N, imag
	complex current_12[A]; // constant current load on phase 1 to 2
	double current_12_real[A]; // constant current load on phase 1 to 2, real
	double current_12_reac[A]; // constant current load on phase 1 to 2, imag
	complex residential_nominal_current_1[A]; // posted current on phase 1 from a residential object, if attached
	complex residential_nominal_current_2[A]; // posted current on phase 2 from a residential object, if attached
	complex residential_nominal_current_12[A]; // posted current on phase 1 to 2 from a residential object, if attached
	double residential_nominal_current_1_real[A]; // posted current on phase 1, real, from a residential object, if attached
	double residential_nominal_current_1_imag[A]; // posted current on phase 1, imag, from a residential object, if attached
	double residential_nominal_current_2_real[A]; // posted current on phase 2, real, from a residential object, if attached
	double residential_nominal_current_2_imag[A]; // posted current on phase 2, imag, from a residential object, if attached
	double residential_nominal_current_12_real[A]; // posted current on phase 1 to 2, real, from a residential object, if attached
	double residential_nominal_current_12_imag[A]; // posted current on phase 1 to 2, imag, from a residential object, if attached
	complex power_1[VA]; // constant power on phase 1 (120V)
	complex power_2[VA]; // constant power on phase 2 (120V)
	complex power_12[VA]; // constant power on phase 1 to 2 (240V)
	double power_1_real[W]; // constant power on phase 1, real
	double power_2_real[W]; // constant power on phase 2, real
	double power_12_real[W]; // constant power on phase 1 to 2, real
	double power_1_reac[VAr]; // constant power on phase 1, imag
	double power_2_reac[VAr]; // constant power on phase 2, imag
	double power_12_reac[VAr]; // constant power on phase 1 to 2, imag
	complex shunt_1[S]; // constant shunt impedance on phase 1
	complex shunt_2[S]; // constant shunt impedance on phase 2
	complex shunt_12[S]; // constant shunt impedance on phase 1 to 2
	complex impedance_1[Ohm]; // constant series impedance on phase 1
	complex impedance_2[Ohm]; // constant series impedance on phase 2
	complex impedance_12[Ohm]; // constant series impedance on phase 1 to 2
	double impedance_1_real[Ohm]; // constant series impedance on phase 1, real
	double impedance_2_real[Ohm]; // constant series impedance on phase 2, real
	double impedance_12_real[Ohm]; // constant series impedance on phase 1 to 2, real
	double impedance_1_reac[Ohm]; // constant series impedance on phase 1, imag
	double impedance_2_reac[Ohm]; // constant series impedance on phase 2, imag
	double impedance_12_reac[Ohm]; // constant series impedance on phase 1 to 2, imag
	bool house_present; // boolean for detecting whether a house is attached, not an input
	enumeration {OUT_OF_SERVICE=0, IN_SERVICE=1} service_status; // In and out of service flag
	double service_status_double; // In and out of service flag - type double - will indiscriminately override service_status - useful for schedules
	double previous_uptime[min]; // Previous time between disconnects of node in minutes
	double current_uptime[min]; // Current time since last disconnect of node in minutes
	object topological_parent; // topological parent as per GLM configuration
}

class underground_line {
	parent line;
	class line {
		parent link;
		class link {
			parent powerflow_object;
			class powerflow_object {
				set {A=1, B=2, C=4, D=256, N=8, S=112, G=128} phases;
				double nominal_voltage[V];
			}

			function interupdate_pwr_object();
			function update_power_pwr_object();
			function check_limits_pwr_object();
			enumeration {OPEN=0, CLOSED=1} status; // 
			object from; // from_node - source node
			object to; // to_node - load node
			complex power_in[VA]; // power flow in (w.r.t from node)
			complex power_out[VA]; // power flow out (w.r.t to node)
			double power_out_real[W]; // power flow out (w.r.t to node), real
			complex power_losses[VA]; // power losses
			complex power_in_A[VA]; // power flow in (w.r.t from node), phase A
			complex power_in_B[VA]; // power flow in (w.r.t from node), phase B
			complex power_in_C[VA]; // power flow in (w.r.t from node), phase C
			complex power_out_A[VA]; // power flow out (w.r.t to node), phase A
			complex power_out_B[VA]; // power flow out (w.r.t to node), phase B
			complex power_out_C[VA]; // power flow out (w.r.t to node), phase C
			complex power_losses_A[VA]; // power losses, phase A
			complex power_losses_B[VA]; // power losses, phase B
			complex power_losses_C[VA]; // power losses, phase C
			complex current_out_A[A]; // current flow out of link (w.r.t. to node), phase A
			complex current_out_B[A]; // current flow out of link (w.r.t. to node), phase B
			complex current_out_C[A]; // current flow out of link (w.r.t. to node), phase C
			complex current_in_A[A]; // current flow to link (w.r.t from node), phase A
			complex current_in_B[A]; // current flow to link (w.r.t from node), phase B
			complex current_in_C[A]; // current flow to link (w.r.t from node), phase C
			complex fault_current_in_A[A]; // fault current flowing in, phase A
			complex fault_current_in_B[A]; // fault current flowing in, phase B
			complex fault_current_in_C[A]; // fault current flowing in, phase C
			complex fault_current_out_A[A]; // fault current flowing out, phase A
			complex fault_current_out_B[A]; // fault current flowing out, phase B
			complex fault_current_out_C[A]; // fault current flowing out, phase C
			set {CN=768, CR=512, CF=256, BN=48, BR=32, BF=16, AN=3, AR=2, AF=1, UNKNOWN=0} flow_direction; // flag used for describing direction of the flow of power
			double mean_repair_time[s]; // Time after a fault clears for the object to be back in service
			double continuous_rating[A]; // Continuous rating for this link object (set individual line segments
			double emergency_rating[A]; // Emergency rating for this link object (set individual line segments
		}

		function interupdate_pwr_object();
		function update_power_pwr_object();
		function check_limits_pwr_object();
		object configuration;
		double length[ft];
	}

	function create_fault();
	function fix_fault();
	function interupdate_pwr_object();
	function recalc_distribution_line();
	function update_power_pwr_object();
	function check_limits_pwr_object();
}

class underground_line_conductor {
	double outer_diameter[in]; // Outer diameter of conductor and sheath
	double conductor_gmr[ft]; // Geometric mean radius of the conductor
	double conductor_diameter[in]; // Diameter of conductor
	double conductor_resistance[Ohm/mile]; // Resistance of conductor in ohm/mile
	double neutral_gmr[ft]; // Geometric mean radius of an individual neutral conductor/strand
	double neutral_diameter[in]; // Diameter of individual neutral conductor/strand of concentric neutral
	double neutral_resistance[Ohm/mile]; // Resistance of an individual neutral conductor/strand in ohm/mile
	int16 neutral_strands; // Number of cable strands in neutral conductor
	double insulation_relative_permitivitty[unit]; // Permitivitty of insulation, relative to air
	double shield_gmr[ft]; // Geometric mean radius of shielding sheath
	double shield_resistance[Ohm/mile]; // Resistance of shielding sheath in ohms/mile
	double rating.summer.continuous[A]; // amp rating in summer, continuous
	double rating.summer.emergency[A]; // amp rating in summer, short term
	double rating.winter.continuous[A]; // amp rating in winter, continuous
	double rating.winter.emergency[A]; // amp rating in winter, short term
}

class volt_var_control {
	enumeration {STANDBY=0, ACTIVE=1} control_method; // IVVC activated or in standby
	double capacitor_delay[s]; // Default capacitor time delay - overridden by local defintions
	double regulator_delay[s]; // Default regulator time delay - overriden by local definitions
	double desired_pf; // Desired power-factor magnitude at the substation transformer or regulator
	double d_max; // Scaling constant for capacitor switching on - typically 0.3 - 0.6
	double d_min; // Scaling constant for capacitor switching off - typically 0.1 - 0.4
	object substation_link; // Substation link, transformer, or regulator to measure power factor
	set {C=4, B=2, A=1} pf_phase; // Phase to include in power factor monitoring
	char1024 regulator_list; // List of voltage regulators for the system, separated by commas
	char1024 capacitor_list; // List of controllable capacitors on the system separated by commas
	char1024 voltage_measurements; // List of voltage measurement devices, separated by commas
	char1024 minimum_voltages; // Minimum voltages allowed for feeder, separated by commas
	char1024 maximum_voltages; // Maximum voltages allowed for feeder, separated by commas
	char1024 desired_voltages; // Desired operating voltages for the regulators, separated by commas
	char1024 max_vdrop; // Maximum voltage drop between feeder and end measurements for each regulator, separated by commas
	char1024 high_load_deadband; // High loading case voltage deadband for each regulator, separated by commas
	char1024 low_load_deadband; // Low loading case voltage deadband for each regulator, separated by commas
	bool pf_signed; // Set to true to consider the sign on the power factor.  Otherwise, it just maintains the deadband of +/-desired_pf
}

class voltdump {
	char32 group; // the group ID to output data for (all nodes if empty)
	timestamp runtime; // the time to check voltage data
	char256 filename; // the file to dump the voltage data into
	char256 file; // the file to dump the voltage data into
	int32 runcount; // the number of times the file has been written to
	enumeration {polar=1, rect=0} mode; // dumps the voltages in either polar or rectangular notation
}