powerflow/relay.cpp

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

#include "relay.h"
#include "node.h"

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

relay::relay(MODULE *mod) : link(mod)
{
    if(oclass == NULL)
    {
        pclass = link::oclass;
        
        oclass = gl_register_class(mod,"relay",PC_BOTTOMUP|PC_POSTTOPDOWN);
        if(oclass == NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);
        
        if(gl_publish_variable(oclass,
            PT_double, "time_to_change", PADDR(time_to_change),
            PT_enumeration, "status", PADDR(status),
                PT_KEYWORD, "OPEN", RS_OPEN,
                PT_KEYWORD, "CLOSED", RS_CLOSED,
            PT_double, "recloser_delay[s]", PADDR(recloser_delay),
            PT_int16, "recloser_tries", PADDR(recloser_tries),
            PT_object, "from",PADDR(from),
            PT_object, "to", PADDR(to),
            PT_set, "phases", PADDR(phases),
               PT_KEYWORD, "A",PHASE_A,
               PT_KEYWORD, "B",PHASE_B,
               PT_KEYWORD, "C",PHASE_C,
               PT_KEYWORD, "N",PHASE_N,
               PT_KEYWORD, "S",PHASE_S,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        memset(this,0,sizeof(relay));
        defaults = this;
    }
}

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

int relay::create()
{
    int result = link::create();
    memcpy(this,defaults,sizeof(relay));
    status = RS_CLOSED;
    recloser_delay = 5;
    recloser_tries = 3;
    return result;
}

int relay::init()
{
    int result = link::init();

    if (recloser_delay<=1.0)
        throw "recloser delay must be at least 1 second";
    
    a_mat[0][0] = d_mat[0][0] = A_mat[0][0] = (status==RS_CLOSED && has_phase(PHASE_A) ? 1.0 : 0.0);
    a_mat[1][1] = d_mat[1][1] = A_mat[1][1] = (status==RS_CLOSED && has_phase(PHASE_B) ? 1.0 : 0.0);
    a_mat[2][2] = d_mat[2][2] = A_mat[2][2] = (status==RS_CLOSED && has_phase(PHASE_C) ? 1.0 : 0.0);

    b_mat[0][0] = c_mat[0][0] = B_mat[0][0] = 0.0;
    b_mat[1][1] = c_mat[1][1] = B_mat[1][1] = 0.0;
    b_mat[2][2] = c_mat[2][2] = B_mat[2][2] = 0.0;

    for (int i = 0; i < 3; i++)
        i_abc_in[i] = i_n_in[i] = i_abc_out[i] = i_n_out[i] = 1.0;

#ifdef _TESTING
    extern bool show_matrix_values;
    if (show_matrix_values)
    {
        gl_testmsg("Relay: a matrix");
        print_matrix(a_mat);

        gl_testmsg("Relay: A matrix");
        print_matrix(A_mat);

        gl_testmsg("Relay: b matrix");
        print_matrix(b_mat);

        gl_testmsg("Relay: B matrix");
        print_matrix(B_mat);

        gl_testmsg("Relay: c matrix");
        print_matrix(c_mat);

        gl_testmsg("Relay: d matrix");
        print_matrix(d_mat);
    }
#endif
    return result;
}

TIMESTAMP relay::sync(TIMESTAMP t0)
{
    TIMESTAMP t1 = TS_NEVER;
    node *f = OBJECTDATA(from, node);
    node *t = OBJECTDATA(to, node);
    set trip = (f->is_contact_any() || t->is_contact_any());

    /* perform relay operation if any line contact has occurred */
    if (status==RS_CLOSED && trip)
    {
        status = RS_OPEN;

        /* schedule recloser operation */
        t1 = t0+(TIMESTAMP)(recloser_delay*TS_SECOND);
    }

    /* recloser time has arrived */
    else if (status==RS_OPEN && t0>=reclose_time)
    {
        /* still have contact */
        if (trip)
        {
            /* reschedule automatic recloser if retries permits */ 
            if (recloser_tries>0)
            {
                recloser_tries--;
                t1 = t0+(TIMESTAMP)(recloser_delay*TS_SECOND);
            }

            /* automatic retries exhausted, manual takes an average of an hour */
            else
            {
                t1 = t0+(TIMESTAMP)(gl_random_exponential(3600)*TS_SECOND);
            }
        }
        else
            status = RS_CLOSED;
    }

    /* compute matrix values */
    a_mat[0][0] = d_mat[0][0] = A_mat[0][0] = (status==RS_CLOSED && has_phase(PHASE_A) ? 1.0 : 0.0);
    a_mat[1][1] = d_mat[1][1] = A_mat[1][1] = (status==RS_CLOSED && has_phase(PHASE_B) ? 1.0 : 0.0);
    a_mat[2][2] = d_mat[2][2] = A_mat[2][2] = (status==RS_CLOSED && has_phase(PHASE_C) ? 1.0 : 0.0);
    
    /* adjust operating condition */
    if (status==RS_CLOSED)
        condition = OC_NORMAL;
    else
        condition = OC_OPEN_ALL;
    
    TIMESTAMP t2=link::sync(t0);

    return t1<t2?t1:t2;
}

TIMESTAMP relay::postsync(TIMESTAMP t0)
{
    return link::postsync(t0);
}

// IMPLEMENTATION OF CORE LINKAGE: relay

EXPORT int create_relay(OBJECT **obj, OBJECT *parent)
{
    try
    {
        *obj = gl_create_object(relay::oclass,sizeof(relay));
        if (*obj!=NULL)
        {
            relay *my = OBJECTDATA(*obj,relay);
            gl_set_parent(*obj,parent);
            return my->create();
        }
    }
    catch (char *msg)
    {
        gl_error("create_relay: %s", msg);
    }
    return 1;
}

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

EXPORT TIMESTAMP sync_relay(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    relay *pObj = OBJECTDATA(obj,relay);
    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_relay(OBJECT *obj, char *classname)
{
    return OBJECTDATA(obj,relay)->isa(classname);
}

---

GridLAB-D^TM Version 1.0

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