network/link.cpp

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include "network.h"
#include "lock.h"

// link CLASS FUNCTIONS

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

link::link(MODULE *mod) 
{
    // first time init
    if (oclass==NULL)
    {
        // register the class definition
        link_class = oclass = gl_register_class(mod,"link",PC_BOTTOMUP);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);

        // publish the class properties
        if (gl_publish_variable(oclass,
            PT_complex, "Y", PADDR(Y),
            PT_complex, "I", PADDR(I),
            PT_double, "B", PADDR(B),
            PT_object, "from", PADDR(from),
            PT_object, "to", PADDR(to),
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);

        // setup the default values
        defaults = this;
        Y = complex(0,0);
        B = 0.0;
        I = complex(0,0);
        from = NULL;
        to = NULL;
        turns_ratio = 1.0;
    }
}

int link::create() 
{
    memcpy(this,defaults,sizeof(*this));
    return 1;
}

int link::init(node *parent)
{
    return 1;
}

TIMESTAMP link::sync(TIMESTAMP t0) 
{
    node *f = OBJECTDATA(from,node);
    node *t = OBJECTDATA(to,node);
    if (f==NULL || t==NULL)
        return TS_NEVER;

    // Note: n!=1 <=> B==0
    // compute effective impedance
    complex Yeff = Y + complex(0,B/2);

    // off-nominal ratio [Kundur 1993, p.236]
    double c = 1/turns_ratio; 

    // compute effective admittance
    complex Yc = Yeff*c;

    // compute line currents (note from/to switched)
    complex Ifrom = t->V * Y * c;
    complex Ito = f->V * Y * c;

    // add to self admittance (contribution diagonal terms)
    // add to current injections (contribution to off-diagonal terms)
    complex Ys = Yc + Yc*(c-1);
    LOCK_OBJECT(from);
    f->Ys += Ys;
    f->YVs -= Ifrom;
    UNLOCK_OBJECT(from);

    Ys = Yc + Yeff*(1-c);
    LOCK_OBJECT(to);
    t->YVs -= Ito;
    t->Ys += Ys;
    UNLOCK_OBJECT(to);

    // compute current over line (from->to)
    I = Ito - Ifrom;

#ifdef _DEBUG
    // link debugging
    if (debug_link==1)
    {
        OBJECT* obj = OBJECTHDR(this);
        static int first=-1;
        if (first==-1) first = obj->id;
        if (obj->id==first)
        {
            printf("\n");
            printf("Link  From -> To             R        X        B        Y                 Ifrom             Ito               I               \n");
            printf("===== ====================== ======== ======== ======== ================= ================= ================= =================\n");
        }
        printf("%2d-%2d %-9.9s -> %-9.9s %+8.4f %+8.4f %+8.4f %+8.4f%+8.4fj %+8.4f%+8.4fj %+8.4f%+8.4fj %+8.4f%+8.4fj\n", 
            from->id, to->id, 
            OBJECTDATA(from,node)->name,OBJECTDATA(to,node)->name,
            (complex(1,0)/Y).Re(),(complex(1,0)/Y).Im(), B,
            Y.Re(), Y.Im(),
            Ifrom.Re(), Ifrom.Im(), 
            Ito.Re(), Ito.Im(), 
            I.Re(), I.Im());
    }
#endif // _DEBUG

    return TS_NEVER;
}

// IMPLEMENTATION OF CORE LINKAGE: link

EXPORT int create_link(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(link_class,sizeof(link));
    if (*obj!=NULL)
    {
        last_link = *obj;
        link *my = OBJECTDATA(*obj,link);
        gl_set_parent(*obj,parent);
        my->create();
        return 1;
    }
    return 0;
}

EXPORT TIMESTAMP sync_link(OBJECT *obj, TIMESTAMP t0)
{
    TIMESTAMP t1 = OBJECTDATA(obj,link)->sync(t0);
    obj->clock = t0;
    return t1;
}

EXPORT int init_link(OBJECT *obj)
{

    return OBJECTDATA(obj,link)->init(OBJECTDATA(obj->parent,node));
}

---

GridLAB-D^TM Version 1.0

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