powerflow/triplex_node.cpp

Go to the documentation of this file.

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

#include "node.h"

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

triplex_node::triplex_node(MODULE *mod):load(mod)
{
    if(oclass == NULL)
    {
        pclass = load::oclass;
        
        oclass = gl_register_class(mod,"triplex_node",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, "line1_voltage[V]", PADDR(phaseA_V),
            PT_complex, "line2_voltage[V]", PADDR(phaseB_V),
            PT_complex, "lineN_voltage[V]", PADDR(phaseC_V),
            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,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        memset(this,0,sizeof(triplex_node));
        defaults = this;
    }
}

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

int triplex_node::init(OBJECT *parent)
{
    return load::init(parent);
}

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

TIMESTAMP triplex_node::sync(TIMESTAMP t0)
{
    return load::sync(t0);
}

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

// IMPLEMENTATION OF CORE LINKAGE: triplex_node

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

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

EXPORT TIMESTAMP sync_triplex_node(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    triplex_node *pObj = OBJECTDATA(obj,triplex_node);
    try {
        if (pass==PC_BOTTOMUP)
            return pObj->sync(t0);
        else if (pass==PC_POSTTOPDOWN)
        {
            TIMESTAMP t1 = pObj->postsync(t0);
            obj->clock = t0;
            return t1;
        }
        else
            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_triplex_node(OBJECT *obj, char *classname)
{
    return OBJECTDATA(obj,triplex_node)->isa(classname);
}

---

GridLAB-D^TM Version 1.0

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