powerflow/powerflow_object.cpp

Go to the documentation of this file.

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

#include "powerflow.h"
#include "node.h"
#include "link.h"

// powerflow_object CLASS FUNCTIONS
CLASS* powerflow_object::oclass = NULL;
CLASS* powerflow_object::pclass = NULL;
powerflow_object *powerflow_object::defaults = NULL;

powerflow_object::powerflow_object(MODULE *mod)
{
    if (oclass==NULL)
    {
        oclass = gl_register_class(mod,"powerflow_object",0x00);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);
    }
    
    memset(this,0,sizeof(powerflow_object));
    defaults = this;
    phases = NO_PHASE;
    condition = OC_NORMAL;
    solution = PS_NORMAL;
}

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

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

int powerflow_object::init(void)
{
    /* split connection must connect to a phase */
    if (has_phase(PHASE_S) && !(has_phase(PHASE_A) || has_phase(PHASE_B) || has_phase(PHASE_C)))
        throw "split connection is missing A,B, or C phase connection";

    /* split connection must connect to only one phase */
    if (has_phase(PHASE_S) && (
        (has_phase(PHASE_A) && has_phase(PHASE_B)) ||
        (has_phase(PHASE_B) && has_phase(PHASE_C)) ||
        (has_phase(PHASE_C) && has_phase(PHASE_A))))
        throw "split connection is connected to two phases simultaneously";

    /* split connection is not permitted with delta connection */
    if (has_phase(PHASE_S) && has_phase(PHASE_D))
        throw "split and delta connection cannot occur simultaneously";

    /* split connection is not permitted on neutral */
    if (has_phase(PHASE_N) && has_phase(PHASE_S)) 
    {
        gl_warning("neutral phase ignored on split connection.");
        phases ^= PHASE_N;
    }

    return 1;
}

TIMESTAMP powerflow_object::sync(TIMESTAMP t0)
{
    return TS_NEVER;
}

TIMESTAMP powerflow_object::postsync(TIMESTAMP t0)
{
    return TS_NEVER;
}

// IMPLEMENTATION OF CORE LINKAGE: powerflow_object

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

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

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

---

GridLAB-D^TM Version 1.0

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