powerflow/meter.cpp

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

#include "meter.h"
#include "timestamp.h"

// specify the sync calls needed
#define SYNCS (PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN)

// useful macros
#define TO_HOURS(t) (((double)t) / (3600 * TS_SECOND))

// meter CLASS FUNCTIONS
// class management data
CLASS* meter::oclass = NULL;
CLASS* meter::pclass = NULL;
meter *meter::defaults = NULL;

// the constructor registers the class and properties and sets the defaults
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
        oclass = gl_register_class(mod,"meter",SYNCS);
        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,"UNKNOWN",UNKNOWN,
                PT_KEYWORD,"SINGLEPHASE",SINGLEPHASE,
                PT_KEYWORD,"POLYPHASE",POLYPHASE,
            PT_double, "energy[kWh]", PADDR(energy),
            PT_double, "power[kW]", PADDR(power),
            PT_double, "demand[kW]", PADDR(demand),
            PT_complex, "line12_voltage[V]", PADDR(phaseAtoB_V),
            PT_complex, "line23_voltage[V]", PADDR(phaseBtoC_V),
            PT_complex, "line31_voltage[V]", PADDR(phaseCtoA_V),
            PT_complex, "line1_voltage[V]", PADDR(phaseA_V),
            PT_complex, "line2_voltage[V]", PADDR(phaseB_V),
            PT_complex, "line3_voltage[V]", PADDR(phaseC_V),
            PT_complex, "line1_current[A]", PADDR(phaseA_I),
            PT_complex, "line2_current[A]", PADDR(phaseB_I),
            PT_complex, "line3_current[A]", PADDR(phaseC_I),
            PT_set, "phases", PADDR(phases),
                PT_KEYWORD, "A",PHASE_A,
                PT_KEYWORD, "B",PHASE_B,
                PT_KEYWORD, "C",PHASE_C,
                PT_KEYWORD, "N",PHASE_N,
                PT_KEYWORD, "S",PHASE_S,
            PT_enumeration, "status", PADDR(status),
                PT_KEYWORD, "NOMINAL", NOMINAL,
                PT_KEYWORD, "UNDERVOLT", UNDERVOLT,
                PT_KEYWORD, "OVERVOLT", OVERVOLT,
            PT_double, "nominal_voltage[V]", PADDR(nominal_voltage),
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);

        // setup the default values
        memset(this,0,sizeof(meter));
        defaults = this;
        nominal_voltage = 240;
    }
}

int meter::isa(char *classname)
{
    return strcmp(classname,"meter")==0 || node::isa(classname);
}

// Create a distribution meter from the defaults template, return 1 on success
int meter::create()
{
    int result = node::create();
    memcpy(this,defaults,sizeof(meter));
    return result;
}

// Initialize a distribution meter, return 1 on success
int meter::init(OBJECT *parent)
{
    if (type==UNKNOWN)
    {
        OBJECT *obj = OBJECTHDR(this);
        throw("meter type is not specified");
    }
    return node::init(parent);
}

// Synchronize a distribution meter
TIMESTAMP meter::presync(TIMESTAMP t0, TIMESTAMP t1)
{
    // compute demand peak
    if (power>demand) demand=power;
    if (t0>0)
        energy += power * TO_HOURS(t1 - t0);
    if (type==SINGLEPHASE)
    {
            phaseAtoB_V = phaseA_V - (-phaseB_V);
            phaseBtoC_V = -phaseB_V - (phaseC_V);
            phaseCtoA_V = phaseC_V - (phaseA_V);

    }

    return node::presync(t0);


    /*
    complex true_power;
    // compute energy consumption after clock starts
    if (t0>0)
        energy += power * TO_HOURS(t1 - t0);
        if (type==1){
            true_power = phaseA_V * phaseA_I -phaseB_V * phaseB_I +phaseC_V * phaseC_I;
            power = true_power.Re()/1000;
        }
        else if (type==2){
            true_power = phaseA_V * phaseA_I_in +phaseB_V * phaseB_I_in +phaseC_V * phaseC_I_in;
            power = true_power.Mag()/1000;
        }
        else{ //if (type ==0 )//if type not known, assume it measure nothing.
            //true_power = phaseA_V * phaseA_I -phaseB_V * phaseB_I +phaseC_V * phaseC_I;
            true_power = 0.0;
            power = true_power.Mag /1000;
        }

    return TS_NEVER;
    */
}

TIMESTAMP meter::sync(TIMESTAMP t0)
{
    complex true_power;
    /* add the load to the node injection */
    phaseA_I_in += phaseA_I;
    phaseB_I_in += phaseB_I;
    phaseC_I_in += phaseC_I;

    /* update the node */
    TIMESTAMP t1 = node::sync(t0);

    /* check the voltage status for loads */
    double VApu = phaseA_V.Mag()/nominal_voltage;
    double VBpu = phaseB_V.Mag()/nominal_voltage;
    double VCpu = phaseC_V.Mag()/nominal_voltage;
    if (type==SINGLEPHASE)
    {
            /* compute phase-to-phase voltages */
            phaseAtoB_V = phaseA_V - (-phaseB_V);
            phaseBtoC_V = -phaseB_V - (phaseC_V);
            phaseCtoA_V = phaseC_V - (phaseA_V);

        if (VApu<0.4 || VBpu<0.4 || VApu+VBpu<0.8)
            status=UNDERVOLT;
        else if (VApu>0.6 || VBpu>0.6 || VApu+VBpu>1.2)
            status=OVERVOLT;
        else
            status=NOMINAL;

    }
    else if (type==POLYPHASE)
    {

        /*      if (type==2){
            complex true_power = phaseA_V * phaseA_I_in +phaseB_V * phaseB_I_in +phaseC_V * phaseC_I_in;
            power = true_power.Mag()/1000;
        }
*/
        if (VApu<0.8 || VBpu<0.8 || VCpu<0.8)
            status=UNDERVOLT;
        else if (VApu>1.2 || VBpu>1.2 || VCpu>1.2)
            status=OVERVOLT;
        else
            status=NOMINAL;

    }
/*      if (type==1){
            true_power = phaseA_V * phaseA_I -phaseB_V * phaseB_I +phaseC_V * phaseC_I;
            power = true_power.Re()/1000;
        }
        else if (type==2){
            true_power = phaseA_V * phaseA_I_in +phaseB_V * phaseB_I_in +phaseC_V * phaseC_I_in;
            power = true_power.Mag()/1000;
        }
        else{ //if (type ==0 )//if type not known, assume it measure nothing.
            //true_power = phaseA_V * phaseA_I -phaseB_V * phaseB_I +phaseC_V * phaseC_I;
            true_power = 0.0;
            power = true_power.Mag /1000;
        }
*/
    return t1;
}

TIMESTAMP meter::postsync(TIMESTAMP t0)
{
/*  // compute demand peak
    if (power>demand) demand=power;

    return node::postsync(t0);
*/
    complex true_power;
    // compute energy consumption after clock starts
//  if (t0>0)
//      energy += power * TO_HOURS(t1 - t0);
        if (type==1){
            true_power = phaseA_V * phaseA_I_in -phaseB_V * phaseB_I_in +phaseC_V * phaseC_I_in;
            power = true_power.Re()/1000;
                if (type=SINGLEPHASE)
            {
            phaseAtoB_V = phaseA_V - (-phaseB_V);
            phaseBtoC_V = -phaseB_V - (phaseC_V);
            phaseCtoA_V = phaseC_V - (phaseA_V);
            }
        }
        else if (type==2){
            true_power = phaseA_V * phaseA_I_in +phaseB_V * phaseB_I_in +phaseC_V * phaseC_I_in;
            power = true_power.Mag()/1000;
        }
        else{ //if (type ==0 )//if type not known, assume it measure nothing.
            //true_power = phaseA_V * phaseA_I -phaseB_V * phaseB_I +phaseC_V * phaseC_I;
            true_power = 0.0;
            power = true_power.Mag()/1000;
        }

    return TS_NEVER;
    }

// IMPLEMENTATION OF CORE LINKAGE

EXPORT int isa_meter(OBJECT *obj, char *classname)
{
    return OBJECTDATA(obj,meter)->isa(classname);
}

EXPORT int create_meter(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(meter::oclass,sizeof(meter));
    if (*obj!=NULL)
    {
        meter *my = OBJECTDATA(*obj,meter);
        gl_set_parent(*obj,parent);
        my->create();
        return 1;
    }
    return 0;
}

EXPORT int init_meter(OBJECT *obj)
{
    meter *my = OBJECTDATA(obj,meter);
    try {
        return my->init(obj->parent);
    }
    catch (char *msg)
    {
        GL_THROW("%s (meter:%d): %s", my->get_name(), my->get_id(), msg);
        return 0; 
    }
}

EXPORT TIMESTAMP sync_meter(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    meter *pObj = OBJECTDATA(obj,meter);
    try {
        TIMESTAMP t1 = TS_NEVER;
        if (pass==PC_PRETOPDOWN)
        {
            t1 = pObj->presync(obj->clock,t0);
            obj->clock = t0;
            return t1;
        }
        else if (pass==PC_BOTTOMUP)
            return pObj->sync(t0);
        else if (pass=PC_POSTTOPDOWN)
            return pObj->postsync(t0);
        else
            throw "invalid pass request";
    } catch (const char *error) {
        GL_THROW("%s (meter:%d): %s", pObj->get_name(), pObj->get_id(), error);
        return 0; 
    } catch (...) {
        GL_THROW("%s (meter:%d): %s", pObj->get_name(), pObj->get_id(), "unknown exception");
        return 0;
    }
}

---

GridLAB-D^TM Version 1.0

An open-source project initiated by the US Department of Energy