powerflow/link.cpp

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

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

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

link::link(MODULE *mod) : powerflow_object(mod){
    
    // first time init
    if (oclass==NULL)
    {
        pclass = powerflow_object::oclass;
        oclass = gl_register_class(mod,"link",PC_BOTTOMUP|PC_POSTTOPDOWN);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);
        
        defaults = this;
        memset(this,0,sizeof(link));
    }
}

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

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

int link::init(void)
{
    OBJECT *obj = GETOBJECT(this);

    powerflow_object::init();

    /* check link from node */
    if (from==NULL)
        throw "link from node is not specified";
    else if (obj->parent==NULL)
    {
        /* make 'from' object parent of this object */
        if (gl_object_isa(from,"node"))
            gl_set_parent(obj, from);
        else
            throw "link from reference not a node";
    }
    else

        /* promote 'from' object if necessary */
        gl_set_rank(from,obj->rank+1);
    
    /* check link to node */
    if (to==NULL)
        throw "link to node is not specified";
    else if (to->parent==NULL)
    {
        /* make this object parent to 'to' object */
        if (gl_object_isa(to,"node"))
            gl_set_parent(to, obj);
        else
            throw "link to reference not a node";
    }
    else
        /* promote this object if necessary */
        gl_set_rank(obj,to->rank+1);

    return 1;
}

TIMESTAMP link::sync(TIMESTAMP t0)
{
    node *f = OBJECTDATA(from, node);
    node *t = OBJECTDATA(to, node);
    set nodeconditions = f->condition | t->condition;

    /* if the line is not operating normally */
    if (!is_normal())
    {
        /* pass condition to nodes on either end only when link is connected */
        if (!is_open(PHASE_A))
            t->condition = f->condition |= OC_PHASE_A_CONTACT&(nodeconditions|condition);
        if (!is_open(PHASE_B))
            t->condition = f->condition |= OC_PHASE_B_CONTACT&(nodeconditions|condition);
        if (!is_open(PHASE_C))
            t->condition = f->condition |= OC_PHASE_C_CONTACT&(nodeconditions|condition);
    }

    /* update the voltages */
    f->phaseA_I_in += c_mat[0][0] * t->phaseA_V +
                      c_mat[0][1] * t->phaseB_V +
                      c_mat[0][2] * t->phaseC_V +
                      d_mat[0][0] * t->phaseA_I_in +
                      d_mat[0][1] * t->phaseB_I_in +
                      d_mat[0][2] * t->phaseC_I_in;
    f->phaseB_I_in += c_mat[1][0] * t->phaseA_V +
                      c_mat[1][1] * t->phaseB_V +
                      c_mat[1][2] * t->phaseC_V +
                      d_mat[1][0] * t->phaseA_I_in +
                      d_mat[1][1] * t->phaseB_I_in +
                      d_mat[1][2] * t->phaseC_I_in;
    f->phaseC_I_in += c_mat[2][0] * t->phaseA_V +
                      c_mat[2][1] * t->phaseB_V +
                      c_mat[2][2] * t->phaseC_V +
                      d_mat[2][0] * t->phaseA_I_in +
                      d_mat[2][1] * t->phaseB_I_in +
                      d_mat[2][2] * t->phaseC_I_in;

    return TS_NEVER;
}

TIMESTAMP link::postsync(TIMESTAMP t0)
{
    node *f = OBJECTDATA(from, node);
    node *t = OBJECTDATA(to, node);
    set nodeconditions = f->condition | t->condition;

    /* compute for normal operation */
    if (!(is_normal() && nodeconditions==OC_NORMAL))

        memset(d_mat,0,sizeof(d_mat));

    t->phaseA_V = A_mat[0][0] * f->phaseA_V +
                  A_mat[0][1] * f->phaseB_V +
                  A_mat[0][2] * f->phaseC_V -
                  B_mat[0][0] * t->phaseA_I_in -
                  B_mat[0][1] * t->phaseB_I_in -
                  B_mat[0][2] * t->phaseC_I_in;
    t->phaseB_V = A_mat[1][0] * f->phaseA_V +
                  A_mat[1][1] * f->phaseB_V +
                  A_mat[1][2] * f->phaseC_V -
                  B_mat[1][0] * t->phaseA_I_in -
                  B_mat[1][1] * t->phaseB_I_in -
                  B_mat[1][2] * t->phaseC_I_in;
    t->phaseC_V = A_mat[2][0] * f->phaseA_V +
                  A_mat[2][1] * f->phaseB_V +
                  A_mat[2][2] * f->phaseC_V -
                  B_mat[2][0] * t->phaseA_I_in -
                  B_mat[2][1] * t->phaseB_I_in -
                  B_mat[2][2] * t->phaseC_I_in;

    return TS_NEVER;
}



// IMPLEMENTATION OF CORE LINKAGE: link

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



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

EXPORT TIMESTAMP sync_link(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    link *pLink = OBJECTDATA(obj,link);
    try 
    {
        if (pass==PC_BOTTOMUP)
            return pLink->sync(t0);
        else if (pass==PC_POSTTOPDOWN) 
        {
            TIMESTAMP t1 = pLink->postsync(t0);
            obj->clock = t0;
            return t1;
        }
        else
            throw "invalid pass request";
    } 
    catch (const char *error) 
    {
        GL_THROW("%s (link:%d): %s", pLink->get_name(), pLink->get_id(), error);
        return TS_INVALID; 
    } 
    catch (...) 
    {
        GL_THROW("%s (link:%d): unknown exception", pLink->get_name(), pLink->get_id());
        return TS_INVALID;
    }
}

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

// MATRIX OPS FOR LINKS

void inverse(complex in[3][3], complex out[3][3])
{
    complex x = complex(1.0) / (in[0][0] * in[1][1] * in[2][2] -
                               in[0][0] * in[1][2] * in[2][1] -
                               in[0][1] * in[1][0] * in[2][2] +
                               in[0][1] * in[1][2] * in[2][0] +
                               in[0][2] * in[1][0] * in[2][1] -
                               in[0][2] * in[1][1] * in[2][0]);

    out[0][0] = x * (in[1][1] * in[2][2] - in[1][2] * in[2][1]);
    out[0][1] = x * (in[0][2] * in[2][1] - in[0][1] * in[2][2]);
    out[0][2] = x * (in[0][1] * in[1][2] - in[0][2] * in[1][1]);
    out[1][0] = x * (in[1][2] * in[2][0] - in[1][0] * in[2][2]);
    out[1][1] = x * (in[0][0] * in[2][2] - in[0][2] * in[2][0]);
    out[1][2] = x * (in[0][2] * in[1][0] - in[0][0] * in[1][2]);
    out[2][0] = x * (in[1][0] * in[2][1] - in[1][1] * in[2][0]);
    out[2][1] = x * (in[0][1] * in[2][0] - in[0][0] * in[2][1]);
    out[2][2] = x * (in[0][0] * in[1][1] - in[0][1] * in[1][0]);
}

void multiply(double a, complex b[3][3], complex c[3][3])
{
    #define MUL(i, j) c[i][j] = b[i][j] * a
    MUL(0, 0); MUL(0, 1); MUL(0, 2);
    MUL(1, 0); MUL(1, 1); MUL(1, 2);
    MUL(2, 0); MUL(2, 1); MUL(2, 2);
    #undef MUL
}

void multiply(complex a[3][3], complex b[3][3], complex c[3][3])
{
    #define MUL(i, j) c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j]
    MUL(0, 0); MUL(0, 1); MUL(0, 2);
    MUL(1, 0); MUL(1, 1); MUL(1, 2);
    MUL(2, 0); MUL(2, 1); MUL(2, 2);
    #undef MUL
}

void subtract(complex a[3][3], complex b[3][3], complex c[3][3])
{
    #define SUB(i, j) c[i][j] = a[i][j] - b[i][j]
    SUB(0, 0); SUB(0, 1); SUB(0, 2);
    SUB(1, 0); SUB(1, 1); SUB(1, 2);
    SUB(2, 0); SUB(2, 1); SUB(2, 2);
    #undef MUL
}

---

GridLAB-D^TM Version 1.0

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