stub_bidder::stub_bidder(MODULE *module)
{
if (oclass==NULL)
{
oclass = gl_register_class(module,"stub_bidder",sizeof(stub_bidder),PC_BOTTOMUP);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s", __FILE__);
if (gl_publish_variable(oclass,
PT_double, "bid_period[s]", PADDR(bid_period),
PT_int16, "count", PADDR(count),
PT_int16, "change", PADDR(change),PT_DESCRIPTION, "flag for town factory to bid in second level auction (value=1 or 2)",
PT_object, "market", PADDR(market),
// PT_object, "market_second", PADDR(market_second),
PT_enumeration, "role", PADDR(role),
PT_KEYWORD, "BUYER", BUYER,
PT_KEYWORD, "SELLER", SELLER,
PT_double, "price", PADDR(price),
PT_double, "quantity", PADDR(quantity),
PT_double, "cost", PADDR(cost),PT_DESCRIPTION, "the cost of factory if stub_didder is a town_factory",
NULL)<1)
GL_THROW("unable to publish properties in %s",__FILE__);
memset(this,0,sizeof(stub_bidder));
}
}
// the constructor registers the class and properties and sets the defaults
residential_enduse::residential_enduse(MODULE *mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(mod,"residential_enduse",sizeof(residential_enduse),PC_BOTTOMUP);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
/* TROUBLESHOOT
The registration for the residential_enduse class failed. This is usually caused
by a coding error in the core implementation of classes or the module implementation.
Please report this error to the developers.
*/
// publish the class properties
if (gl_publish_variable(oclass,
PT_loadshape,"shape",PADDR(shape),
PT_enduse,"",PADDR(load),
PT_enumeration,"override",PADDR(re_override),
PT_KEYWORD,"ON",OV_ON,
PT_KEYWORD,"NORMAL",OV_NORMAL,
PT_KEYWORD,"OFF",OV_OFF,
PT_enumeration, "power_state", PADDR(power_state),
PT_KEYWORD, "UNKNOWN", PS_UNKNOWN,
PT_KEYWORD, "OFF", PS_OFF,
PT_KEYWORD, "ON", PS_ON,
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
/* TROUBLESHOOT
The registration for the residential_enduse properties failed. This is usually caused
by a coding error in the core implementation of classes or the module implementation.
Please report this error to the developers.
*/
}
}
power_metrics::power_metrics(MODULE *mod) : powerflow_library(mod)
{
if(oclass == NULL)
{
oclass = gl_register_class(mod,"power_metrics",sizeof(power_metrics),0x00);
if(oclass == NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
if(gl_publish_variable(oclass,
PT_double, "SAIFI", PADDR(SAIFI),
PT_double, "SAIFI_int", PADDR(SAIFI_int),
PT_double, "SAIDI", PADDR(SAIDI),
PT_double, "SAIDI_int", PADDR(SAIDI_int),
PT_double, "CAIDI", PADDR(CAIDI),
PT_double, "CAIDI_int", PADDR(CAIDI_int),
PT_double, "ASAI", PADDR(ASAI),
PT_double, "ASAI_int", PADDR(ASAI_int),
PT_double, "MAIFI", PADDR(MAIFI),
PT_double, "MAIFI_int", PADDR(MAIFI_int),
PT_double, "base_time_value[s]", PADDR(stat_base_time_value),
NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
if (gl_publish_function(oclass, "calc_metrics", (FUNCTIONADDR)calc_pfmetrics)==NULL)
GL_THROW("Unable to publish metrics calculation function");
if (gl_publish_function(oclass, "reset_interval_metrics", (FUNCTIONADDR)reset_pfinterval_metrics)==NULL)
GL_THROW("Unable to publish interval metrics reset function");
if (gl_publish_function(oclass, "reset_annual_metrics", (FUNCTIONADDR)reset_pfannual_metrics)==NULL)
GL_THROW("Unable to publish annual metrics reset function");
if (gl_publish_function(oclass, "init_reliability", (FUNCTIONADDR)init_pf_reliability_extra)==NULL)
GL_THROW("Unable to publish powerflow reliability initialization function");
if (gl_publish_function(oclass, "logfile_extra", (FUNCTIONADDR)logfile_extra)==NULL)
GL_THROW("Unable to publish powerflow reliability metrics extra header function");
}
}
microwave::microwave(MODULE *module) : residential_enduse(module)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(module,"microwave",sizeof(microwave),PC_BOTTOMUP|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class microwave";
else
oclass->trl = TRL_DEMONSTRATED;
// publish the class properties
if (gl_publish_variable(oclass,
PT_INHERIT, "residential_enduse",
PT_double,"installed_power[kW]",PADDR(shape.params.analog.power),PT_DESCRIPTION,"rated microwave power level",
PT_double,"standby_power[kW]",PADDR(standby_power),PT_DESCRIPTION,"standby microwave power draw (unshaped only)",
PT_double,"circuit_split",PADDR(circuit_split),
PT_enumeration,"state",PADDR(state),PT_DESCRIPTION,"on/off state of the microwave",
PT_KEYWORD,"OFF",OFF,
PT_KEYWORD,"ON",ON,
PT_double,"cycle_length[s]",PADDR(cycle_time),PT_DESCRIPTION,"length of the combined on/off cycle between uses",
PT_double,"runtime[s]",PADDR(runtime),PT_DESCRIPTION,"",
PT_double,"state_time[s]",PADDR(state_time),PT_DESCRIPTION,"",
NULL)<1)
GL_THROW("unable to publish properties in %s",__FILE__);
}
}
capbank::capbank(MODULE *mod) : link(mod)
{
// TODO: set default values
// first time init
if (oclass==NULL)
{
// register the class definition
capbank_class = oclass = gl_register_class(mod,"capbank",sizeof(capbank),PC_BOTTOMUP);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
// publish the class properties
if (gl_publish_variable(oclass,
PT_double, "KVARrated", PADDR(KVARrated),
PT_double, "Vrated", PADDR(Vrated),
PT_enumeration,"state",PADDR(state),
PT_KEYWORD,"CAPS_IN",CAPS_IN,
PT_KEYWORD,"CAPS_OUT",CAPS_OUT,
PT_object, "CTlink", PADDR(CTlink),
PT_object, "PTnode", PADDR(PTnode),
PT_double, "VARopen", PADDR(VARopen),
PT_double, "VARclose", PADDR(VARclose),
PT_double, "Vopen", PADDR(Vopen),
PT_double, "Vclose", PADDR(Vclose),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
}
}
virtual_battery::virtual_battery(MODULE *module) {
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(module,"virtual_battery",sizeof(virtual_battery),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_AUTOLOCK);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
// publish the class properties
if (gl_publish_variable(oclass,
PT_double,"charge",PADDR(charge), PT_DESCRIPTION, "1 for charging the battery",
PT_double,"price",PADDR(price), PT_DESCRIPTION, "virtual's battery priceS",
PT_double,"capacity[W]",PADDR(capacity), PT_DESCRIPTION, "capacity ",
PT_double,"max_capacity[W]",PADDR(max_capacity), PT_DESCRIPTION, "max cpapcity",
PT_int16,"change_capacity",PADDR(change_capacity), PT_DESCRIPTION, "1 for change_capacity,0 for no change_capacity",
PT_int16,"drilling_systems",PADDR(drilling_systems), PT_DESCRIPTION, "fgh",
PT_int16,"ch",PADDR(ch), PT_DESCRIPTION, "fgh",
NULL)<1)
GL_THROW("unable to publish properties in %s",__FILE__);
}
}
voltdump::voltdump(MODULE *mod)
{
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(mod,"voltdump",sizeof(voltdump),PC_BOTTOMUP|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class voltdump";
else
oclass->trl = TRL_PROVEN;
// publish the class properties
if (gl_publish_variable(oclass,
PT_char32,"group",PADDR(group),PT_DESCRIPTION,"the group ID to output data for (all nodes if empty)",
PT_timestamp,"runtime",PADDR(runtime),PT_DESCRIPTION,"the time to check voltage data",
PT_char256,"filename",PADDR(filename),PT_DESCRIPTION,"the file to dump the voltage data into", // must keep this for compatibility
PT_char256,"file",PADDR(filename),PT_DESCRIPTION,"the file to dump the voltage data into", // added 2012-07-10, adds convenience
PT_int32,"runcount",PADDR(runcount),PT_ACCESS,PA_REFERENCE,PT_DESCRIPTION,"the number of times the file has been written to",
PT_enumeration, "mode", PADDR(mode),PT_DESCRIPTION,"dumps the voltages in either polar or rectangular notation",
PT_KEYWORD, "rect", (enumeration)VDM_RECT,
PT_KEYWORD, "polar", (enumeration)VDM_POLAR,
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
}
}
regulator::regulator(MODULE *mod) : link(mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
regulator_class = oclass = gl_register_class(mod,"regulator",sizeof(regulator),PC_BOTTOMUP);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
// publish the class properties
if (gl_publish_variable(oclass,
PT_enumeration,"Type",PADDR(Type),
PT_KEYWORD,"RT_LTC",RT_LTC,
PT_KEYWORD,"RT_VR",RT_VR,
PT_double, "Vmax", PADDR(Vmax),
PT_double, "Vmin", PADDR(Vmin),
PT_double, "Vstep", PADDR(Vstep),
PT_object, "CTlink", PADDR(CTlink),
PT_object, "PTbus", PADDR(PTbus),
PT_double, "TimeDelay", PADDR(TimeDelay),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
}
}
transformer::transformer(MODULE *mod) : link(mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
transformer_class = oclass = gl_register_class(mod,"transformer",sizeof(transformer),PC_BOTTOMUP);
if (oclass==NULL)
throw "unable to register class transformer";
else
oclass->trl = TRL_CONCEPT;
// publish the class properties
if (gl_publish_variable(oclass,
PT_enumeration,"Type",PADDR(Type),
PT_KEYWORD,"TT_YY",TT_YY,
PT_KEYWORD,"TT_YD",TT_YD,
PT_KEYWORD,"TT_DY",TT_DY,
PT_KEYWORD,"TT_DD",TT_DD,
PT_double, "Sbase", PADDR(Sbase),
PT_double, "Vbase", PADDR(Vbase),
PT_double, "Zpu", PADDR(Zpu),
PT_double, "Vprimary", PADDR(Vprimary),
PT_double, "Vsecondary", PADDR(Vsecondary),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
}
}
/** Register the new object class and construct the default object properties */
plc::plc(MODULE *mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(mod,"plc",sizeof(plc),PC_BOTTOMUP|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class plc";
else
oclass->trl = TRL_INTEGRATED;
// publish the class properties
if (gl_publish_variable(oclass,
PT_char1024,"source",PADDR(source),
PT_object,"network",PADDR(network),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// set defaults
memset(this,0,sizeof(plc));
strcpy(source,"");
controller = NULL;
network = NULL;
defaults = this;
}
}
recloser::recloser(MODULE *mod) : switch_object(mod)
{
if(oclass == NULL)
{
pclass = link_object::oclass;
oclass = gl_register_class(mod,"recloser",sizeof(recloser),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if(oclass == NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
if(gl_publish_variable(oclass,
PT_INHERIT, "switch",
PT_double, "retry_time[s]", PADDR(retry_time), PT_DESCRIPTION, "the amount of time in seconds to wait before the recloser attempts to close",
PT_double, "max_number_of_tries", PADDR(ntries), PT_DESCRIPTION, "the number of times the recloser will try to close before permanently opening",
PT_double, "number_of_tries", PADDR(curr_tries), PT_DESCRIPTION, "Current number of tries recloser has attempted",
NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
if (gl_publish_function(oclass,"change_recloser_state",(FUNCTIONADDR)change_recloser_state)==NULL)
GL_THROW("Unable to publish recloser state change function");
if (gl_publish_function(oclass,"recloser_reliability_operation",(FUNCTIONADDR)recloser_reliability_operation)==NULL)
GL_THROW("Unable to publish recloser reliability operation function");
if (gl_publish_function(oclass, "change_recloser_faults", (FUNCTIONADDR)recloser_fault_updates)==NULL)
GL_THROW("Unable to publish recloser fault correction function");
}
}
/* Class registration is only called once to register the class with the core */
rectifier::rectifier(MODULE *module)
{
if (oclass==NULL)
{
oclass = gl_register_class(module,"rectifier",sizeof(rectifier),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s", __FILE__);
if (gl_publish_variable(oclass,
PT_enumeration,"rectifier_type",PADDR(rectifier_type_v),
PT_KEYWORD,"ONE_PULSE",ONE_PULSE,
PT_KEYWORD,"TWO_PULSE",TWO_PULSE,
PT_KEYWORD,"THREE_PULSE",THREE_PULSE,
PT_KEYWORD,"SIX_PULSE",SIX_PULSE,
PT_KEYWORD,"TWELVE_PULSE",TWELVE_PULSE,
PT_enumeration,"generator_mode",PADDR(gen_mode_v),
PT_KEYWORD,"UNKNOWN",UNKNOWN,
PT_KEYWORD,"CONSTANT_V",CONSTANT_V,
PT_KEYWORD,"CONSTANT_PQ",CONSTANT_PQ,
PT_KEYWORD,"CONSTANT_PF",CONSTANT_PF,
PT_KEYWORD,"SUPPLY_DRIVEN",SUPPLY_DRIVEN,
PT_complex, "V_Out[V]",PADDR(V_Out),
PT_complex, "I_Out[A]",PADDR(I_Out),
PT_complex, "VA_Out[VA]", PADDR(VA_Out),
PT_double, "P_Out", PADDR(P_Out),
PT_double, "Q_Out", PADDR(Q_Out),
PT_complex, "Vdc[V]", PADDR(Vdc),
PT_complex, "phaseA_V_In[V]", PADDR(phaseA_V_In),
PT_complex, "phaseB_V_In[V]", PADDR(phaseB_V_In),
PT_complex, "phaseC_V_In[V]", PADDR(phaseC_V_In),
PT_complex, "phaseA_I_In[V]", PADDR(phaseA_I_In),
PT_complex, "phaseB_I_In[V]", PADDR(phaseB_I_In),
PT_complex, "phaseC_I_In[V]", PADDR(phaseC_I_In),
PT_complex, "power_A_In[VA]", PADDR(power_A_In),
PT_complex, "power_B_In[VA]", PADDR(power_B_In),
PT_complex, "power_C_In[VA]", PADDR(power_C_In),
//PT_int64, "generator_mode_choice", PADDR(generator_mode_choice),
PT_set, "phases", PADDR(phases),
PT_KEYWORD, "A",(set)PHASE_A,
PT_KEYWORD, "B",(set)PHASE_B,
PT_KEYWORD, "C",(set)PHASE_C,
PT_KEYWORD, "N",(set)PHASE_N,
PT_KEYWORD, "S",(set)PHASE_S,
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
defaults = this;
memset(this,0,sizeof(rectifier));
/* TODO: set the default values of all properties here */
}
}
link::link(MODULE *mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
link_class = oclass = gl_register_class(mod,"link",sizeof(link),PC_BOTTOMUP|PC_UNSAFE_OVERRIDE_OMIT);
if (oclass==NULL)
throw "unable to register class link";
else
oclass->trl = TRL_STANDALONE;
// publish the class properties
if (gl_publish_variable(oclass,
PT_complex, "Y", PADDR(Y),
PT_complex, "I", PADDR(I),
PT_double, "B", PADDR(B),
PT_object, "from", PADDR(from),
PT_object, "to", PADDR(to),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
Y = complex(0,0);
B = 0.0;
I = complex(0,0);
from = NULL;
to = NULL;
turns_ratio = 1.0;
}
}
schedule::schedule(MODULE *module)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(module,"schedule",sizeof(schedule),PC_PRETOPDOWN);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
// publish the class properties
if (gl_publish_variable(oclass,
PT_double, "value", PADDR(currval), PT_ACCESS, PA_REFERENCE,
PT_double, "default_value", PADDR(default_value),
PT_timestamp, "next_ts", PADDR(next_ts), PT_ACCESS, PA_REFERENCE,
PT_enumeration, "state", PADDR(state), PT_ACCESS, PA_REFERENCE,
PT_KEYWORD, "INIT", TS_INIT,
PT_KEYWORD, "OPEN", TS_OPEN,
PT_KEYWORD, "DONE", TS_DONE,
PT_KEYWORD, "ERROR", TS_ERROR,
PT_char256, "error_msg", PADDR(errmsg), PT_ACCESS, PA_REFERENCE,
PT_char256, "filename", PADDR(filename),
PT_char1024, "schedule", PADDR(sched),
NULL)<1)
GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
memset(this, 0, sizeof(schedule));
default_value = 1.0;
next_ts = TS_INIT;
}
}
load_tracker::load_tracker(MODULE *mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(mod,"load_tracker",sizeof(load_tracker),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
else
oclass->trl = TRL_PROVEN;
// publish the class properties
if (gl_publish_variable(oclass,
PT_object, "target",PADDR(target),PT_DESCRIPTION,"target object to track the load of",
PT_char256, "target_property", PADDR(target_prop),PT_DESCRIPTION,"property on the target object representing the load",
PT_enumeration, "operation", PADDR(operation),PT_DESCRIPTION,"operation to perform on complex property types",
PT_KEYWORD,"REAL",(enumeration)REAL,
PT_KEYWORD,"IMAGINARY",(enumeration)IMAGINARY,
PT_KEYWORD,"MAGNITUDE",(enumeration)MAGNITUDE,
PT_KEYWORD,"ANGLE",(enumeration)ANGLE, // If using, please specify in radians
PT_double, "full_scale", PADDR(full_scale),PT_DESCRIPTION,"magnitude of the load at full load, used for feed-forward control",
PT_double, "setpoint",PADDR(setpoint),PT_DESCRIPTION,"load setpoint to track to",
PT_double, "deadband",PADDR(deadband),PT_DESCRIPTION,"percentage deadband",
PT_double, "damping",PADDR(damping),PT_DESCRIPTION,"load setpoint to track to",
PT_double, "output", PADDR(output),PT_DESCRIPTION,"output scaling value",
PT_double, "feedback", PADDR(feedback),PT_DESCRIPTION,"the feedback signal, for reference purposes",
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
}
}
group_recorder::group_recorder(MODULE *mod){
if(oclass == NULL)
{
#ifdef _DEBUG
gl_debug("construction group_recorder class");
#endif
oclass = gl_register_class(mod,"group_recorder",sizeof(group_recorder), PC_POSTTOPDOWN);
if(oclass == NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
if(gl_publish_variable(oclass,
PT_char256, "file", PADDR(filename), PT_DESCRIPTION, "output file name",
PT_char1024, "group", PADDR(group_def), PT_DESCRIPTION, "group definition string",
PT_double, "interval[s]", PADDR(dInterval), PT_DESCRIPTION, "recordering interval (0 'every iteration', -1 'on change')",
PT_double, "flush_interval[s]", PADDR(dFlush_interval), PT_DESCRIPTION, "file flush interval (0 never, negative on samples)",
PT_bool, "strict", PADDR(strict), PT_DESCRIPTION, "causes the group_recorder to stop the simulation should there be a problem opening or writing with the group_recorder",
PT_bool, "print_units", PADDR(print_units), PT_DESCRIPTION, "flag to append units to each written value, if applicable",
PT_char256, "property", PADDR(property_name), PT_DESCRIPTION, "property to record",
PT_int32, "limit", PADDR(limit), PT_DESCRIPTION, "the maximum number of lines to write to the file",
PT_enumeration, "complex_part", PADDR(complex_part), PT_DESCRIPTION, "the complex part to record if complex properties are gathered",
PT_KEYWORD, "NONE", NONE,
PT_KEYWORD, "REAL", REAL,
PT_KEYWORD, "IMAG", IMAG,
PT_KEYWORD, "MAG", MAG,
PT_KEYWORD, "ANG_DEG", ANG,
PT_KEYWORD, "ANG_RAD", ANG_RAD,
NULL) < 1){
;//GL_THROW("unable to publish properties in %s",__FILE__);
}
defaults = this;
memset(this, 0, sizeof(group_recorder));
}
}
csv_reader::csv_reader(MODULE *module){
memset(this, 0, sizeof(csv_reader));
if (oclass==NULL)
{
oclass = gl_register_class(module,"csv_reader",sizeof(csv_reader),NULL);
if (gl_publish_variable(oclass,
PT_int32,"index",PADDR(index),PT_ACCESS,PA_REFERENCE,
PT_char32,"city_name",PADDR(city_name),
PT_char32,"state_name",PADDR(state_name),
PT_double,"lat_deg",PADDR(lat_deg),
PT_double,"lat_min",PADDR(lat_min),
PT_double,"long_deg", PADDR(long_deg),
PT_double,"long_min",PADDR(long_min),
PT_double,"low_temp",PADDR(low_temp),PT_ACCESS,PA_REFERENCE,
PT_double,"high_temp",PADDR(high_temp),PT_ACCESS,PA_REFERENCE,
PT_double,"peak_solar",PADDR(peak_solar),PT_ACCESS,PA_REFERENCE,
PT_enumeration,"status",PADDR(status),PT_ACCESS,PA_REFERENCE,
PT_KEYWORD,"INIT",CR_INIT,
PT_KEYWORD,"OPEN",CR_OPEN,
PT_KEYWORD,"ERROR",CR_ERROR,
PT_char32,"timefmt",PADDR(timefmt),
PT_char32,"timezone",PADDR(timezone),
PT_char256,"columns",PADDR(columns_str),
PT_char256,"filename",PADDR(filename),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
memset(this,0,sizeof(csv_reader));
}
}
series_reactor::series_reactor(MODULE *mod) : link_object(mod)
{
if(oclass == NULL)
{
pclass = link_object::oclass;
oclass = gl_register_class(mod,"series_reactor",sizeof(series_reactor),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class series_reactor";
else
oclass->trl = TRL_PROVEN;
if(gl_publish_variable(oclass,
PT_INHERIT, "link",
PT_complex, "phase_A_impedance[Ohm]",PADDR(phase_A_impedance),PT_DESCRIPTION,"Series impedance of reactor on phase A",
PT_double, "phase_A_resistance[Ohm]",PADDR(phase_A_impedance.Re()),PT_DESCRIPTION,"Resistive portion of phase A's impedance",
PT_double, "phase_A_reactance[Ohm]",PADDR(phase_A_impedance.Im()),PT_DESCRIPTION,"Reactive portion of phase A's impedance",
PT_complex, "phase_B_impedance[Ohm]",PADDR(phase_B_impedance),PT_DESCRIPTION,"Series impedance of reactor on phase B",
PT_double, "phase_B_resistance[Ohm]",PADDR(phase_B_impedance.Re()),PT_DESCRIPTION,"Resistive portion of phase B's impedance",
PT_double, "phase_B_reactance[Ohm]",PADDR(phase_B_impedance.Im()),PT_DESCRIPTION,"Reactive portion of phase B's impedance",
PT_complex, "phase_C_impedance[Ohm]",PADDR(phase_C_impedance),PT_DESCRIPTION,"Series impedance of reactor on phase C",
PT_double, "phase_C_resistance[Ohm]",PADDR(phase_C_impedance.Re()),PT_DESCRIPTION,"Resistive portion of phase C's impedance",
PT_double, "phase_C_reactance[Ohm]",PADDR(phase_C_impedance.Im()),PT_DESCRIPTION,"Reactive portion of phase C's impedance",
PT_double, "rated_current_limit[A]",PADDR(rated_current_limit),PT_DESCRIPTION,"Rated current limit for the reactor",
NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
}
}
/* Class registration is only called once to register the class with the core */
stubauction::stubauction(MODULE *module)
{
if (oclass==NULL)
{
oclass = gl_register_class(module,"stubauction",sizeof(stubauction),passconfig|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class stubauction";
else
oclass->trl = TRL_QUALIFIED;
if (gl_publish_variable(oclass,
PT_char32, "unit", PADDR(unit), PT_DESCRIPTION, "unit of quantity",
PT_double, "period[s]", PADDR(period), PT_DESCRIPTION, "interval of time between market clearings",
PT_double, "last.P", PADDR(last_price), PT_DESCRIPTION, "last cleared price",
PT_double, "current_market.clearing_price", PADDR(next_price), PT_DESCRIPTION, "next cleared price",
PT_double, "past_market.clearing_price", PADDR(last_price), PT_DESCRIPTION, "last cleared price",
PT_double, "next.P", PADDR(next_price), PT_DESCRIPTION, "next cleared price",
PT_double, "avg24", PADDR(avg24), PT_DESCRIPTION, "daily average of price",
PT_double, "std24", PADDR(std24), PT_DESCRIPTION, "daily stdev of price",
PT_double, "avg72", PADDR(avg72), PT_DESCRIPTION, "three day price average",
PT_double, "std72", PADDR(std72), PT_DESCRIPTION, "three day price stdev",
PT_double, "avg168", PADDR(avg168), PT_DESCRIPTION, "weekly average of price",
PT_double, "std168", PADDR(std168), PT_DESCRIPTION, "weekly stdev of price",
PT_int64, "market_id", PADDR(market_id), PT_ACCESS, PA_REFERENCE, PT_DESCRIPTION, "unique identifier of market clearing",
PT_bool, "verbose", PADDR(verbose), PT_DESCRIPTION, "enable verbose stubauction operations",
PT_enumeration,"control_mode",PADDR(control_mode),PT_DESCRIPTION,"the control mode to use for determining average and deviation calculations",
PT_KEYWORD,"NORMAL",(enumeration)CON_NORMAL,
PT_KEYWORD,"DISABLED",(enumeration)CON_DISABLED,
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
defaults = this;
memset(this,0,sizeof(stubauction));
}
}
/* Class registration is only called once to register the class with the core */
baseMVA::baseMVA(MODULE *module)
#ifdef OPTIONAL
/* TODO: include this if you are deriving this from a superclass */
: SUPERCLASS(module)
#endif
{
#ifdef OPTIONAL
/* TODO: include this if you are deriving this from a superclass */
pclass = SUPERCLASS::oclass;
#endif
if (oclass==NULL)
{
oclass = gl_register_class(module,"baseMVA",sizeof(baseMVA),passconfig);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s", __FILE__);
if (gl_publish_variable(oclass,
/* TODO: add your published properties here */
PT_int16, "BASEMVA", PADDR(BASEMVA), PT_DESCRIPTION,"base MVA",
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
defaults = this;
memset(this,0,sizeof(baseMVA));
/* TODO: set the default values of all properties here */
}
}
sectionalizer::sectionalizer(MODULE *mod) : switch_object(mod)
{
// first time init
if (oclass==NULL)
{
// link to parent class (used by isa)
pclass = link_object::oclass;
// register the class definition
oclass = gl_register_class(mod,"sectionalizer",sizeof(sectionalizer),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if(oclass == NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
// publish the class properties
if(gl_publish_variable(oclass,
PT_INHERIT, "switch",
NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
if (gl_publish_function(oclass,"change_sectionalizer_state",(FUNCTIONADDR)change_sectionalizer_state)==NULL)
GL_THROW("Unable to publish sectionalizer state change function");
if (gl_publish_function(oclass,"sectionalizer_reliability_operation",(FUNCTIONADDR)sectionalizer_reliability_operation)==NULL)
GL_THROW("Unable to publish sectionalizer reliability operation function");
if (gl_publish_function(oclass, "change_sectionalizer_faults", (FUNCTIONADDR)sectionalizer_fault_updates)==NULL)
GL_THROW("Unable to publish sectionalizer fault correction function");
//Publish deltamode functions
if (gl_publish_function(oclass, "interupdate_pwr_object", (FUNCTIONADDR)interupdate_switch)==NULL)
GL_THROW("Unable to publish sectionalizer deltamode function");
}
}
powerflow_library::powerflow_library(MODULE *mod)
{
if (oclass==NULL)
{
oclass = gl_register_class(mod,"powerflow_library",sizeof(powerflow_library),PC_NOSYNC);
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
}
}
powerflow_object::powerflow_object(MODULE *mod)
{
if (oclass==NULL)
{
#ifdef SUPPORT_OUTAGES
oclass = gl_register_class(mod,"powerflow_object",sizeof(powerflow_object),PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT);
#else
oclass = gl_register_class(mod,"powerflow_object",sizeof(powerflow_object),PC_NOSYNC);
#endif
if (oclass==NULL)
GL_THROW("unable to register object class implemented by %s",__FILE__);
if(gl_publish_variable(oclass,
PT_set, "phases", PADDR(phases),
PT_KEYWORD, "G", (set)GROUND,
PT_KEYWORD, "S", (set)PHASE_S,
PT_KEYWORD, "N", (set)PHASE_N,
PT_KEYWORD, "D", (set)PHASE_D,
PT_KEYWORD, "C", (set)PHASE_C,
PT_KEYWORD, "B", (set)PHASE_B,
PT_KEYWORD, "A", (set)PHASE_A,
PT_double,"nominal_voltage[V]",PADDR(nominal_voltage),
#ifdef SUPPORT_OUTAGES
PT_set, "condition", PADDR(condition),
PT_KEYWORD, "OPEN", (set)OC_OPEN,
PT_KEYWORD, "CONTACT", (set)OC_CONTACT,
PT_KEYWORD, "NORMAL", (set)OC_NORMAL,
PT_KEYWORD, "SN", (set)PHASE_SN,
PT_KEYWORD, "S2", (set)PHASE_S2,
PT_KEYWORD, "S1", (set)PHASE_S1,
PT_KEYWORD, "G", (set)GROUND,
PT_KEYWORD, "N", (set)PHASE_N,
PT_KEYWORD, "C", (set)PHASE_C,
PT_KEYWORD, "B", (set)PHASE_B,
PT_KEYWORD, "A", (set)PHASE_A,
PT_enumeration, "solution", PADDR(solution),
PT_KEYWORD, "NORMAL", PS_NORMAL,
PT_KEYWORD, "OUTAGE", PS_OUTAGE,
#endif
NULL) < 1) GL_THROW("unable to publish powerflow_object properties in %s",__FILE__);
// set defaults
}
}
/* Class registration is only called once to register the class with the core */
dc_dc_converter::dc_dc_converter(MODULE *module)
{
if (oclass==NULL)
{
oclass = gl_register_class(module,"dc_dc_converter",sizeof(dc_dc_converter),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN);
if (oclass==NULL)
throw "unable to register class dc_dc_converter";
else
oclass->trl = TRL_PROOF;
if (gl_publish_variable(oclass,
PT_enumeration,"dc_dc_converter_type",PADDR(dc_dc_converter_type_v),
PT_KEYWORD,"BUCK",BUCK,
PT_KEYWORD,"BOOST",BOOST,
PT_KEYWORD,"BUCK_BOOST",BUCK_BOOST,
PT_enumeration,"generator_mode",PADDR(gen_mode_v),
PT_KEYWORD,"UNKNOWN",UNKNOWN,
PT_KEYWORD,"CONSTANT_V",CONSTANT_V,
PT_KEYWORD,"CONSTANT_PQ",CONSTANT_PQ,
PT_KEYWORD,"CONSTANT_PF",CONSTANT_PF,
PT_KEYWORD,"SUPPLY_DRIVEN",SUPPLY_DRIVEN,
PT_complex, "V_Out[V]",PADDR(V_Out),
PT_complex, "I_Out[A]",PADDR(I_Out),
PT_complex, "Vdc[V]", PADDR(Vdc),
PT_complex, "VA_Out[VA]", PADDR(VA_Out),
PT_double, "P_Out", PADDR(P_Out),
PT_double, "Q_Out", PADDR(Q_Out),
PT_double, "service_ratio", PADDR(service_ratio),
PT_complex, "V_In[V]",PADDR(V_In),
PT_complex, "I_In[A]",PADDR(I_In),
PT_complex, "VA_In[VA]", PADDR(VA_In),
//PT_int64, "generator_mode_choice", PADDR(generator_mode_choice),
PT_set, "phases", PADDR(phases),
PT_KEYWORD, "A",(set)PHASE_A,
PT_KEYWORD, "B",(set)PHASE_B,
PT_KEYWORD, "C",(set)PHASE_C,
PT_KEYWORD, "N",(set)PHASE_N,
PT_KEYWORD, "S",(set)PHASE_S,
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
defaults = this;
memset(this,0,sizeof(dc_dc_converter));
/* TODO: set the default values of all properties here */
}
}
CLASS *new_holder(MODULE *module){
if(oclass == NULL){
oclass = gl_register_class(module, "holder", 0, 0);
if(oclass == NULL){
gl_error("unable to register class holder");
return 0;
}
// no need to publish variables...
}
return oclass;
}
powerflow_library::powerflow_library(MODULE *mod)
{
if (oclass==NULL)
{
oclass = gl_register_class(mod,"powerflow_library",sizeof(powerflow_library),PC_NOSYNC);
if (oclass==NULL)
throw "unable to register class powerflow_library";
else
oclass->trl = TRL_PROVEN;
}
}
/** House object constructor: Registers the class and publishes the variables that can be set by the user.
Sets default randomized values for published variables.
**/
house::house(MODULE *mod) : residential_enduse(mod)
{
// first time init
if (oclass==NULL)
{
// register the class definition
oclass = gl_register_class(mod,"house_a",sizeof(house),PC_PRETOPDOWN|PC_BOTTOMUP|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class house_a";
else
oclass->trl = TRL_DEMONSTRATED;
// publish the class properties
if (gl_publish_variable(oclass,
PT_INHERIT, "residential_enduse",
PT_double,"floor_area[sf]",PADDR(floor_area), PT_DESCRIPTION, "area of the house's ground floor",
PT_double,"gross_wall_area[sf]",PADDR(gross_wall_area), PT_DESCRIPTION, "total exterior wall area",
PT_double,"ceiling_height[ft]",PADDR(ceiling_height), PT_DESCRIPTION, "height of the house's ceiling, across all floors",
PT_double,"aspect_ratio",PADDR(aspect_ratio), PT_DESCRIPTION, "ratio of the length to the width of the house's ground footprint",
PT_double,"envelope_UA[Btu/degF*h]",PADDR(envelope_UA), PT_DESCRIPTION, "insulative UA value of the house, based on insulation thickness and surface area",
PT_double,"window_wall_ratio",PADDR(window_wall_ratio), PT_DESCRIPTION, "ratio of exterior window area to exterior wall area",
PT_double,"glazing_shgc",PADDR(glazing_shgc), PT_DESCRIPTION, "siding glazing solar heat gain coeffient",
PT_double,"airchange_per_hour",PADDR(airchange_per_hour), PT_DESCRIPTION, "volume of air exchanged between the house and exterior per hour",
PT_double,"solar_gain[Btu/h]",PADDR(solar_load), PT_DESCRIPTION, "thermal solar input",
PT_double,"heat_cool_gain[Btu/h]",PADDR(hvac_rated_capacity), PT_DESCRIPTION, "thermal gain rate of the installed HVAC",
PT_double,"thermostat_deadband[degF]",PADDR(thermostat_deadband), PT_DESCRIPTION, "",
PT_double,"heating_setpoint[degF]",PADDR(heating_setpoint), PT_DESCRIPTION, "",
PT_double,"cooling_setpoint[degF]",PADDR(cooling_setpoint), PT_DESCRIPTION, "",
PT_double, "design_heating_capacity[Btu.h]",PADDR(design_heating_capacity), PT_DESCRIPTION, "",
PT_double,"design_cooling_capacity[Btu.h]",PADDR(design_cooling_capacity), PT_DESCRIPTION, "",
PT_double,"heating_COP",PADDR(heating_COP), PT_DESCRIPTION, "",
PT_double,"cooling_COP",PADDR(cooling_COP), PT_DESCRIPTION, "",
PT_double,"COP_coeff",PADDR(COP_coeff), PT_DESCRIPTION, "",
PT_double,"air_temperature[degF]",PADDR(Tair), PT_DESCRIPTION, "",
PT_double,"outside_temp[degF]",PADDR(Tout), PT_DESCRIPTION, "",
PT_double,"mass_temperature[degF]",PADDR(Tmaterials), PT_DESCRIPTION, "",
PT_double,"mass_heat_coeff",PADDR(house_content_heat_transfer_coeff), PT_DESCRIPTION, "",
PT_double,"outdoor_temperature[degF]",PADDR(outside_temp), PT_DESCRIPTION, "",
PT_double,"house_thermal_mass[Btu/degF]",PADDR(house_content_thermal_mass), PT_DESCRIPTION, "thermal mass of the house's contained mass",
PT_enumeration,"heat_mode",PADDR(heat_mode), PT_DESCRIPTION, "",
PT_KEYWORD,"ELECTRIC",(enumeration)ELECTRIC,
PT_KEYWORD,"GASHEAT",(enumeration)GASHEAT,
PT_enumeration,"hc_mode",PADDR(heat_cool_mode), PT_DESCRIPTION, "",
PT_KEYWORD,"OFF",(enumeration)OFF,
PT_KEYWORD,"HEAT",(enumeration)HEAT,
PT_KEYWORD,"COOL",(enumeration)COOL,
PT_enduse,"houseload",PADDR(tload), PT_DESCRIPTION, "",
NULL)<1)
GL_THROW("unable to publish properties in %s",__FILE__);
gl_publish_function(oclass, "attach_enduse", (FUNCTIONADDR)&attach_enduse_house_a);
}
}
meter::meter(MODULE *mod) : node(mod)
{
// first time init
if (oclass==NULL)
{
// link to parent class (used by isa)
pclass = node::oclass;
// register the class definition
meter_class = oclass = gl_register_class(mod,"meter",sizeof(meter),PC_BOTTOMUP);
if (oclass==NULL)
throw "unable to register class meter";
else
oclass->trl = TRL_STANDALONE;
// publish the class properties
if (gl_publish_variable(oclass,
PT_enumeration,"type",PADDR(type),
PT_KEYWORD,"MT_ONEPHASE",MT_ONEPHASE,
PT_KEYWORD,"MT_THREEPHASE",MT_THREEPHASE,
PT_complex, "demand[kW]", PADDR(demand),
PT_complex, "meter[kWh]", PADDR(meterkWh),
PT_complex, "line1_current[A]", PADDR(line1_current),
PT_complex, "line2_current[A]", PADDR(line2_current),
PT_complex, "line3_current[A]", PADDR(line3_current),
PT_complex, "line1_admittance[1/Ohm]", PADDR(line1_admittance),
PT_complex, "line2_admittance[1/Ohm]", PADDR(line2_admittance),
PT_complex, "line3_admittance[1/Ohm]", PADDR(line3_admittance),
PT_complex, "line1_power[S]", PADDR(line1_power),
PT_complex, "line2_power[S]", PADDR(line2_power),
PT_complex, "line3_power[S]", PADDR(line3_power),
PT_complex, "line1_volts[V]", PADDR(V),
PT_complex, "line2_volts[V]", PADDR(V),
PT_complex, "line3_volts[V]", PADDR(V),
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
// setup the default values
defaults = this;
type = MT_ONEPHASE;
demand = complex(0,0);
meterkWh = complex(0,0);
line1_current = complex(0,0);
line2_current = complex(0,0);
line3_current = complex(0,0);
line1_admittance = complex(0,0);
line2_admittance = complex(0,0);
line3_admittance = complex(0,0);
line1_power = complex(0,0);
line2_power = complex(0,0);
line3_power = complex(0,0);
}
}
switch_object::switch_object(MODULE *mod) : link_object(mod)
{
if(oclass == NULL)
{
pclass = link_object::oclass;
oclass = gl_register_class(mod,"switch",sizeof(switch_object),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class switch_object";
else
oclass->trl = TRL_QUALIFIED;
if(gl_publish_variable(oclass,
PT_INHERIT, "link",
PT_enumeration, "phase_A_state", PADDR(phase_A_state),PT_DESCRIPTION,"Defines the current state of the phase A switch",
PT_KEYWORD, "OPEN", (enumeration)OPEN,
PT_KEYWORD, "CLOSED", (enumeration)CLOSED,
PT_enumeration, "phase_B_state", PADDR(phase_B_state),PT_DESCRIPTION,"Defines the current state of the phase B switch",
PT_KEYWORD, "OPEN", (enumeration)OPEN,
PT_KEYWORD, "CLOSED", (enumeration)CLOSED,
PT_enumeration, "phase_C_state", PADDR(phase_C_state),PT_DESCRIPTION,"Defines the current state of the phase C switch",
PT_KEYWORD, "OPEN", (enumeration)OPEN,
PT_KEYWORD, "CLOSED", (enumeration)CLOSED,
PT_enumeration, "operating_mode", PADDR(switch_banked_mode),PT_DESCRIPTION,"Defines whether the switch operates in a banked or per-phase control mode",
PT_KEYWORD, "INDIVIDUAL", (enumeration)INDIVIDUAL_SW,
PT_KEYWORD, "BANKED", (enumeration)BANKED_SW,
PT_double, "switch_resistance[Ohm]",PADDR(switch_resistance), PT_DESCRIPTION,"The resistance value of the switch when it is not blown.",
NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
if (gl_publish_function(oclass,"change_switch_state",(FUNCTIONADDR)change_switch_state)==NULL)
GL_THROW("Unable to publish switch state change function");
if (gl_publish_function(oclass,"reliability_operation",(FUNCTIONADDR)reliability_operation)==NULL)
GL_THROW("Unable to publish switch reliability operation function");
if (gl_publish_function(oclass, "create_fault", (FUNCTIONADDR)create_fault_switch)==NULL)
GL_THROW("Unable to publish fault creation function");
if (gl_publish_function(oclass, "fix_fault", (FUNCTIONADDR)fix_fault_switch)==NULL)
GL_THROW("Unable to publish fault restoration function");
if (gl_publish_function(oclass, "change_switch_faults", (FUNCTIONADDR)switch_fault_updates)==NULL)
GL_THROW("Unable to publish switch fault correction function");
//Publish deltamode functions
if (gl_publish_function(oclass, "interupdate_pwr_object", (FUNCTIONADDR)interupdate_switch)==NULL)
GL_THROW("Unable to publish switch deltamode function");
//Publish restoration-related function (current update)
if (gl_publish_function(oclass, "update_power_pwr_object", (FUNCTIONADDR)updatepowercalc_link)==NULL)
GL_THROW("Unable to publish switch external power calculation function");
if (gl_publish_function(oclass, "check_limits_pwr_object", (FUNCTIONADDR)calculate_overlimit_link)==NULL)
GL_THROW("Unable to publish switch external power limit calculation function");
}
}
// the constructor registers the class and properties and sets the defaults
substation::substation(MODULE *mod) : node(mod)
{
// first time init
if (oclass==NULL)
{
// link to parent class (used by isa)
pclass = node::oclass;
// register the class definition
oclass = gl_register_class(mod,"substation",sizeof(substation),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
if (oclass==NULL)
throw "unable to register class substation";
else
oclass->trl = TRL_PROTOTYPE;
// publish the class properties - based around meter object
if (gl_publish_variable(oclass,
PT_INHERIT, "node",
//inputs
PT_complex, "zero_sequence_voltage[V]", PADDR(seq_mat[0]), PT_DESCRIPTION, "The zero sequence representation of the voltage for the substation object.",
PT_complex, "positive_sequence_voltage[V]", PADDR(seq_mat[1]), PT_DESCRIPTION, "The positive sequence representation of the voltage for the substation object.",
PT_complex, "negative_sequence_voltage[V]", PADDR(seq_mat[2]), PT_DESCRIPTION, "The negative sequence representation of the voltage for the substation object.",
PT_double, "base_power[VA]", PADDR(base_power), PT_DESCRIPTION, "The 3 phase VA power rating of the substation.",
PT_double, "power_convergence_value[VA]", PADDR(power_convergence_value), PT_DESCRIPTION, "Default convergence criterion before power is posted to pw_load objects if connected, otherwise ignored",
PT_enumeration, "reference_phase", PADDR(reference_phase), PT_DESCRIPTION, "The reference phase for the positive sequence voltage.",
PT_KEYWORD, "PHASE_A", R_PHASE_A,
PT_KEYWORD, "PHASE_B", R_PHASE_B,
PT_KEYWORD, "PHASE_C", R_PHASE_C,
PT_complex, "transmission_level_constant_power_load[VA]", PADDR(average_transmission_power_load), PT_DESCRIPTION, "the average constant power load to be posted directly to the pw_load object.",
PT_complex, "transmission_level_constant_current_load[A]", PADDR(average_transmission_current_load), PT_DESCRIPTION, "the average constant current load at nominal voltage to be posted directly to the pw_load object.",
PT_complex, "transmission_level_constant_impedance_load[Ohm]", PADDR(average_transmission_impedance_load), PT_DESCRIPTION, "the average constant impedance load at nominal voltage to be posted directly to the pw_load object.",
PT_complex, "distribution_load[VA]", PADDR(distribution_load), PT_DESCRIPTION, "The total load of all three phases at the substation object.",
PT_complex, "distribution_power_A[VA]", PADDR(distribution_power_A),
PT_complex, "distribution_power_B[VA]", PADDR(distribution_power_B),
PT_complex, "distribution_power_C[VA]", PADDR(distribution_power_C),
PT_complex, "distribution_voltage_A[V]", PADDR(voltageA),
PT_complex, "distribution_voltage_B[V]", PADDR(voltageB),
PT_complex, "distribution_voltage_C[V]", PADDR(voltageC),
PT_complex, "distribution_voltage_AB[V]", PADDR(voltageAB),
PT_complex, "distribution_voltage_BC[V]", PADDR(voltageBC),
PT_complex, "distribution_voltage_CA[V]", PADDR(voltageCA),
PT_complex, "distribution_current_A[A]", PADDR(current_inj[0]),
PT_complex, "distribution_current_B[A]", PADDR(current_inj[1]),
PT_complex, "distribution_current_C[A]", PADDR(current_inj[2]),
PT_double, "distribution_real_energy[Wh]", PADDR(distribution_real_energy),
//PT_double, "measured_reactive[kVar]", PADDR(measured_reactive), has not implemented yet
NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
}
}
