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(MODULE *mod)
{   
    if (oclass==NULL)
    {
#ifdef SUPPORT_OUTAGES
        oclass = gl_register_class(mod,"powerflow_object",sizeof(powerflow_object),PC_ABSTRACTONLY|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT|PC_AUTOLOCK);
#else
        oclass = gl_register_class(mod,"powerflow_object",sizeof(powerflow_object),PC_ABSTRACTONLY|PC_NOSYNC|PC_AUTOLOCK);
#endif
        if (oclass==NULL)
            throw "unable to register class powerflow_object";
        else
            oclass->trl = TRL_PROVEN;

        if(gl_publish_variable(oclass,
            PT_set, "phases", PADDR(phases),
                PT_KEYWORD, "G", (set)GROUND,
                PT_KEYWORD, "S", (set)PHASE_S,
                PT_KEYWORD, "N", (set)PHASE_N,
                PT_KEYWORD, "D", (set)PHASE_D,
                PT_KEYWORD, "C", (set)PHASE_C,
                PT_KEYWORD, "B", (set)PHASE_B,
                PT_KEYWORD, "A", (set)PHASE_A,
            PT_double,"nominal_voltage[V]",PADDR(nominal_voltage),
            PT_enumeration, "inrush_integration_method",PADDR(inrush_integration_method),PT_DESCRIPTION,"Integration method for in-rush",
                PT_KEYWORD,"NONE",(enumeration)IRM_NONE,
                PT_KEYWORD,"TRAPEZOIDAL",(enumeration)IRM_TRAPEZOIDAL,
                PT_KEYWORD,"BACKWARD_EULER",(enumeration)IRM_BACKEULER,
#ifdef SUPPORT_OUTAGES
            PT_set, "condition", PADDR(condition),
                PT_KEYWORD, "OPEN", (set)OC_OPEN,
                PT_KEYWORD, "CONTACT", (set)OC_CONTACT,
                PT_KEYWORD, "NORMAL", (set)OC_NORMAL,
                PT_KEYWORD, "SN", (set)PHASE_SN,
                PT_KEYWORD, "S2", (set)PHASE_S2,
                PT_KEYWORD, "S1", (set)PHASE_S1,
                PT_KEYWORD, "G", (set)GROUND,
                PT_KEYWORD, "N", (set)PHASE_N,
                PT_KEYWORD, "C", (set)PHASE_C,
                PT_KEYWORD, "B", (set)PHASE_B,
                PT_KEYWORD, "A", (set)PHASE_A,
            PT_enumeration, "solution", PADDR(solution),
                PT_KEYWORD, "NORMAL", PS_NORMAL,
                PT_KEYWORD, "OUTAGE", PS_OUTAGE,
#endif
            NULL) < 1) GL_THROW("unable to publish powerflow_object properties in %s",__FILE__);

        // set defaults
    }
}

powerflow_object::powerflow_object(CLASS *oclass)
{
    gl_create_foreign((OBJECT*)this);
}

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

int powerflow_object::create(void)
{
    OBJECT *obj = OBJECTHDR(this);
    phases = NO_PHASE;
    nominal_voltage = 0.0;

    //Deltamode override flag
    if (all_powerflow_delta == true)
        obj->flags |= OF_DELTAMODE;
    
    //Set a default for inrush integration - overarching (can be overridden)
    inrush_integration_method = default_inrush_integration_method;

#ifdef SUPPORT_OUTAGES
    condition = OC_NORMAL;
    solution = PS_NORMAL;
#endif
    return 1;
}

int powerflow_object::init(OBJECT *parent)
{
    /* unspecified phase inherits from parent, if any */
    if (parent && gl_object_isa(parent,"powerflow_object"))
    {
        powerflow_object *pParent = OBJECTDATA(parent,powerflow_object);
        if (phases==NO_PHASE)
            phases = pParent->phases;
    }

    /* no phase info */
    if (phases==0)
        throw "phases not specified";

    /* 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::presync(TIMESTAMP t0)
{
    /* nothing to do */
    return TS_NEVER;
}

TIMESTAMP powerflow_object::sync(TIMESTAMP t0)
{
    /* nothing to do */
    return TS_NEVER;
}

TIMESTAMP powerflow_object::postsync(TIMESTAMP t0)
{
#ifdef SUPPORT_OUTAGES
    OBJECT *obj = OBJECTHDR(this);
    if (condition!=OC_NORMAL && solution==PS_NORMAL)
    {
        char buffer[1024]="???";
        gl_get_value_by_name(obj,"condition",buffer,sizeof(buffer));
        gl_debug("powerflow_object %s (%s:%d): abnormal condition detected (condition=%s), switching solver to OUTAGE method", obj->name, obj->oclass->name, obj->id, buffer);
        solution = PS_OUTAGE;
        return t0;
    }
    else if (condition==OC_NORMAL && solution==PS_OUTAGE)
    {
        gl_debug("powerflow_object %s (%s:%d): normal condition restored, switching solver to NORMAL method", obj->name, obj->oclass->name, obj->id);
        solution = PS_NORMAL;
        return t0;
    }
#endif
    return TS_NEVER;
}

int powerflow_object::kmldump(FILE *fp)
{
    return 1; /* 1 means output default if it wasn't handled */
}
// IMPLEMENTATION OF CORE LINKAGE: powerflow_object

EXPORT int create_powerflow_object(OBJECT **obj, OBJECT *parent)
{
    try
    {
        *obj = gl_create_object(powerflow_object::oclass);
        if (*obj!=NULL)
        {
            powerflow_object *my = OBJECTDATA(*obj,powerflow_object);
            gl_set_parent(*obj,parent);
            return my->create();
        }
        else
            return 0;
    }
    CREATE_CATCHALL(powerflow_object);
}

EXPORT int init_powerflow_object(OBJECT *obj)
{
    try {
        powerflow_object *my = OBJECTDATA(obj,powerflow_object);
        return my->init(obj->parent);
    }
    INIT_CATCHALL(powerflow_object);
}

EXPORT TIMESTAMP sync_powerflow_object(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    powerflow_object *pObj = OBJECTDATA(obj,powerflow_object);
    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";
        }
    } 
    SYNC_CATCHALL(powerflow_object);
}

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

---

GridLAB-D™ Version 4.1

An open-source smart grid simulator created by PNNL for the US Department of Energy Office of Electricity