network/relay.cpp

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

/* Coefficient              U1          U2          U3          U4          U5      */
static const double Ap[] = {0.0226,     0.1800,     0.0963,     0.0352,     0.00262 };
static const double Bp[] = {0.0104,     5.9500,     3.8800,     5.6700,     0.00342 };
static const double Cp[] = {0.0200,     2.0000,     2.0000,     2.0000,     0.02000 };
static const double Br[] = {1.0800,     5.9500,     3.8800,     5.6700,     0.32300 };
static const double Cr[] = {2.0000,     2.0000,     2.0000,     2.0000,     2.00000 };


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

relay::relay(MODULE *mod) : link(mod)
{
    // first time init
    if (oclass==NULL)
    {
        // register the class definition
        relay_class = oclass = gl_register_class(mod,"relay",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_enumeration,"Curve",PADDR(Curve),
                PT_KEYWORD,"FC_U1",FC_U1,
                PT_KEYWORD,"FC_U2",FC_U2,
                PT_KEYWORD,"FC_U3",FC_U3,
                PT_KEYWORD,"FC_U4",FC_U4,
                PT_KEYWORD,"FC_U5",FC_U5,
            PT_double, "TimeDial", PADDR(TimeDial),
            PT_double, "SetCurrent", PADDR(SetCurrent),
            PT_enumeration,"State",PADDR(State),
                PT_KEYWORD,"FS_CLOSED",FS_CLOSED,
                PT_KEYWORD,"FS_TRIPPED",FS_TRIPPED,
                PT_KEYWORD,"FS_RECLOSED",FS_RECLOSED,
                PT_KEYWORD,"FS_LOCKOUT",FS_LOCKOUT,
                PT_KEYWORD,"FS_FAULT",FS_FAULT,
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);

        // setup the default values
        defaults = this;
    }
}

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

TIMESTAMP relay::sync(TIMESTAMP t0) 
{
    link::sync(t0);

    double M = I.Mag()/SetCurrent;
    switch (State) {
    case FS_CLOSED:
        if (M>1)
        {   // compute trip time
            Tp = TimeDial * (Ap[Curve]+Bp[Curve]/(pow(M,Cp[Curve])-1));
            TIMESTAMP t1 = Tstate + (TIMESTAMP)(Tp*TS_SECOND);
            if (t1<=t0)
            {
                State=FS_TRIPPED;
                Tstate = t0;
                t1 = TS_NEVER;
            }
            return t1;
        }
        else if (M<=1)
        {   // reset timer
            Tstate = 0;
            return TS_NEVER;
        }
        break;
    case FS_TRIPPED:
        if (M<1)
        {
            // compute reset time
            Tr = TimeDial *(Br[Curve]/(1-pow(M,Cr[Curve])));
            TIMESTAMP t1 = Tstate +(TIMESTAMP)(Tr*TS_SECOND);
            if (t1<=t0)
            {
                State = FS_RECLOSED;
                Tstate = t0;
                return TS_NEVER;
            }
            else
                return t1;
        }
        break;
    case FS_RECLOSED:
        // TODO:
        break;
    case FS_LOCKOUT:
        // TODO:
        break;
    case FS_FAULT:
        // TODO:
        break;
    default:
        break;
    }

    return TS_NEVER;
}
// IMPLEMENTATION OF CORE LINKAGE: relay

EXPORT int create_relay(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(relay_class,sizeof(relay));
    if (*obj!=NULL)
    {
        relay *my = OBJECTDATA(*obj,relay);
        gl_set_parent(*obj,parent);
        my->create();
        return 1;
    }
    return 0;
}

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

---

GridLAB-D^TM Version 1.0

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