powerflow/load.cpp

Go to the documentation of this file.

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

#include "node.h"

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

load::load(MODULE *mod) : node(mod)
{
    if(oclass == NULL)
    {
        pclass = node::oclass;
        
        oclass = gl_register_class(mod,"load",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_complex, "phaseA_VA[VA]", PADDR(phaseA_VA),
            PT_complex, "phaseB_VA[VA]", PADDR(phaseB_VA),
            PT_complex, "phaseC_VA[VA]", PADDR(phaseC_VA),
            PT_complex, "phaseA_Z[ohm]", PADDR(phaseA_Z),
            PT_complex, "phaseB_Z[ohm]", PADDR(phaseB_Z),
            PT_complex, "phaseC_Z[ohm]", PADDR(phaseC_Z),
            PT_complex, "phaseA_I[A]", PADDR(phaseA_I),
            PT_complex, "phaseB_I[A]", PADDR(phaseB_I),
            PT_complex, "phaseC_I[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, "D",PHASE_D,
               PT_KEYWORD, "S",PHASE_S,
            PT_enumeration, "load_class", PADDR(load_class),
                PT_KEYWORD, "U", LC_UNKNOWN,
                PT_KEYWORD, "R", LC_RESIDENTIAL,
                PT_KEYWORD, "C", LC_COMMERCIAL,
                PT_KEYWORD, "I", LC_INDUSTRIAL,
                PT_KEYWORD, "A", LC_AGRICULTURAL,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        memset(this,0,sizeof(load));
        defaults = this;
        sync_V_limit = 0;
        phaseA_Z = phaseB_Z = phaseC_Z = INFINITY;
        load_class = LC_UNKNOWN;
    }
}

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

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


TIMESTAMP load::sync(TIMESTAMP t0)
{
    complex I;

    if (has_phase(PHASE_D)) {    // 'Delta' connected load
        complex I_A,I_B,I_C;

        if ((I = I_INJ(phaseA_V-phaseB_V, phaseA_VA, phaseA_Z, phaseA_I)).IsFinite())
            I_A = I;

        if ((I = I_INJ(phaseB_V-phaseC_V, phaseB_VA, phaseB_Z, phaseB_I)).IsFinite())
            I_B = I;

        if ((I = I_INJ(phaseC_V-phaseA_V, phaseC_VA, phaseC_Z, phaseC_I)).IsFinite())
            I_C = I;

        phaseA_I_in += I_A - I_C;
        phaseB_I_in += I_B - I_A;
        phaseC_I_in += I_C - I_B;

    } else {              // 'WYE' connected load
        if ((I = I_INJ(phaseA_V, phaseA_VA, phaseA_Z, phaseA_I)).IsFinite())
            phaseA_I_in += I;

        if ((I = I_INJ(phaseB_V, phaseB_VA, phaseB_Z, phaseB_I)).IsFinite())
            phaseB_I_in += I;

        if ((I = I_INJ(phaseC_V, phaseC_VA, phaseC_Z, phaseC_I)).IsFinite())
            phaseC_I_in += I;
    }

    return node::sync(t0);
}

TIMESTAMP load::postsync(TIMESTAMP t0)
{
    return node::postsync(t0);
}

// IMPLEMENTATION OF CORE LINKAGE: load

EXPORT int create_load(OBJECT **obj, OBJECT *parent)
{
    try
    {
        *obj = gl_create_object(load::oclass,sizeof(load));
        if (*obj!=NULL)
        {
            load *my = OBJECTDATA(*obj,load);
            gl_set_parent(*obj,parent);
            return my->create();
        }
    }
    catch (char *msg)
    {
        gl_error("create_load: %s", msg);
    }
    return 1;
}

EXPORT int init_load(OBJECT *obj)
{
    int result = 1;
    try {
        result = ((load*) (obj + 1))->init();
    } catch (const char *error) {
        GL_THROW("%s:%d: %s", obj->oclass->name, obj->id, error);
        return 0; 
    } catch (...) {
        GL_THROW("%s:%d: %s", obj->oclass->name, obj->id, "unknown exception");
        return 0;
    }
    return result;
}

EXPORT TIMESTAMP sync_load(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    load *pObj = OBJECTDATA(obj,load);
    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 (const char *error) {
        GL_THROW("%s (%s:%d): %s", pObj->get_name(), pObj->get_id(), error);
        return 0; 
    } catch (...) {
        GL_THROW("%s (%s:%d): %s", pObj->get_name(), pObj->get_id(), "unknown exception");
        return 0;
    }
}

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

---

GridLAB-D^TM Version 1.0

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