powerflow/node.cpp

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

#include "node.h"

CLASS *node::oclass = NULL;
CLASS *node::pclass = NULL;
node *node::defaults = NULL;

node::node(MODULE *mod) : powerflow_object(mod)
{
    if(oclass == NULL)
    {
        pclass = powerflow_object::oclass;
        oclass = gl_register_class(mod,"node",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_double,"sync_V_limit[V]",PADDR(sync_V_limit),
            PT_complex, "phaseA_V[V]", PADDR(phaseA_V),
            PT_complex, "phaseB_V[V]", PADDR(phaseB_V),
            PT_complex, "phaseC_V[V]", PADDR(phaseC_V),
            PT_set, "phases", PADDR(phases),
                PT_KEYWORD, "D", PHASE_D,
                PT_KEYWORD, "S", PHASE_S,
                PT_KEYWORD, "A", PHASE_A,
                PT_KEYWORD, "B", PHASE_B,
                PT_KEYWORD, "C", PHASE_C,
                PT_KEYWORD, "N", PHASE_N,
                PT_KEYWORD, "G", GROUND,
            PT_set, "condition", PADDR(condition),
                PT_KEYWORD, "NORMAL", OC_NORMAL,
                PT_KEYWORD, "CONTACT", OC_CONTACT,
                PT_KEYWORD, "OPEN", OC_OPEN,
                PT_KEYWORD, "A", PHASE_A,
                PT_KEYWORD, "B", PHASE_B,
                PT_KEYWORD, "C", PHASE_C,
                PT_KEYWORD, "N", PHASE_N,
                PT_KEYWORD, "G", GROUND,
                PT_KEYWORD, "S1", PHASE_S1,
                PT_KEYWORD, "S2", PHASE_S2,
                PT_KEYWORD, "SN", PHASE_SN,
            PT_enumeration, "solution", PADDR(solution),
                PT_KEYWORD, "NORMAL", PS_NORMAL,
                PT_KEYWORD, "OUTAGE", PS_OUTAGE,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        memset(this,0,sizeof(node));
        defaults = this;
    }
}

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

int node::create(void)
{
    memcpy(this,defaults,sizeof(node));
    int result = powerflow_object::create();
    return result;
}

int node::init(OBJECT *parent)
{
    /* initialize the powerflow base object */
    int result = powerflow_object::init();

    /* make sure the sync voltage limit is positive */
    if (sync_V_limit<0)
    {
        gl_warning("node %s (node:%d): negative sync_V_limit is changed to positive value", get_name(), get_id());
        sync_V_limit = -sync_V_limit;
    }

    return result;
}

TIMESTAMP node::presync(TIMESTAMP t0)
{
    /* reset the current injections for the coming pass (this is better done here, even though it's faster in postbottomup) */
    phaseA_I_in = phaseB_I_in = phaseC_I_in = 0.0;

    return TS_NEVER; /* request another pass */
}

TIMESTAMP node::sync(TIMESTAMP t0)
{
    /* if condition is normal */
    if (is_normal())
    {
        /* record the last sync voltage */
        lastA_V = phaseA_V;
        lastB_V = phaseB_V;
        lastC_V = phaseC_V;

        return TS_NEVER;
    }

    /* condition is not normal (treat all as outage) */
    lastA_V = lastB_V = lastC_V = complex(0,0);
    return TS_NEVER; /* request another pass */
}

TIMESTAMP node::postsync(TIMESTAMP t0)
{
    /* node is operation ok */
    if (is_normal())
    {
        /* solution is normal */
        solution = PS_NORMAL;

        /* compute the sync voltage change */
        double sync_V = (lastA_V - phaseA_V).Mag() + (lastB_V-phaseB_V).Mag() + (lastC_V-phaseC_V).Mag();

        /* if the sync voltage limit is defined and the sync voltage is larger */
        if (sync_V_limit != 0.0 && sync_V > sync_V_limit)

            /* request another pass */
            return t0;
    }

    /* solution is abnormal */
    else
        solution = PS_OUTAGE;

    /* the solution is satisfactory */
    return TS_NEVER;
}

// IMPLEMENTATION OF CORE LINKAGE: node

EXPORT int create_node(OBJECT **obj, OBJECT *parent)
{
    try
    {
        *obj = gl_create_object(node::oclass,sizeof(node));
        if (*obj==NULL)
            throw "unable to create node";
        gl_set_parent(*obj,parent);
        return OBJECTDATA(*obj,node)->create();
    }
    catch (char *msg)
    {
        gl_error("create_node: %s", msg);
        return 0;
    }
}



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

EXPORT TIMESTAMP sync_node(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    node *pObj = OBJECTDATA(obj,node);
    try {
        TIMESTAMP t1 = TS_NEVER;
        switch (pass) {
        case PC_PRETOPDOWN:
            return pObj->presync(t0);
        case PC_BOTTOMUP:
            return pObj->sync(t0);
        case PC_POSTTOPDOWN:
            t1 = pObj->postsync(t0);
            obj->clock = t0;
            return t1;
        default:
            throw "invalid pass request";
        }
    }
    catch (char *msg)
    {
        gl_error("node %s (node:%d): %s", pObj->get_name(), pObj->get_id(), msg);
    }
    catch (...)
    {
        gl_error("node %s (node:%d): unknown exception", pObj->get_name(), pObj->get_id());
    }
    return TS_INVALID; /* stop the clock */
}

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

---

GridLAB-D^TM Version 1.0

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