powerflow/fuse.cpp

// $Id: fuse.cpp,v 1.12 2008/02/13 22:48:04 natet Exp $
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

#include "fuse.h"

//initialize pointers
CLASS* fuse::oclass = NULL;
CLASS* fuse::pclass = NULL;
fuse  *fuse::defaults = NULL;

// fuse CLASS FUNCTIONS

fuse::fuse(MODULE *mod):relay(mod)
{
    if(oclass == NULL)
    {
        pclass = relay::oclass;
        
        oclass = gl_register_class(mod,"fuse",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, "minimum_current_A",PADDR(minimum_current_A),
            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, "D",PHASE_D,
               PT_KEYWORD, "S",PHASE_S,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        defaults = this;
        to = from = NULL;
        minimum_current_A = 0.0;
        blow_time = TS_NEVER;
        time_curve = UNKNOWN;
        minimum_current_A = 1.0;
        phases = PHASE_A;
    }
}

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

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

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

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            a_mat[i][j] = d_mat[i][j] = A_mat[i][j] = (i == j ? 1.0 : 0.0);
            c_mat[i][j] = 0.0;
            B_mat[i][j] = b_mat[i][j] = 0.0;
        }

        i_abc_in[i] = i_n_in[i] = i_abc_out[i] = i_n_out[i] = 1.0;
    }
    return result;
}

TIMESTAMP fuse::sync(TIMESTAMP t0)
{
    int i = phase_index(phases);
    complex I = i_abc_in[i];

    if (t0 == blow_time)
        status = RS_OPEN;
    else if (I.Re() < minimum_current_A) {
        B_mat[i][i] = b_mat[i][i] = 0.001;
        blow_time = TS_NEVER;
    } else if (blow_time == TS_NEVER) {
        B_mat[i][i] = b_mat[i][i] = 0.0;
        switch (time_curve) {
            case UNKNOWN:
            default:
                blow_time = t0 + 1;
                break;
        }
    }

    TIMESTAMP t1 = relay::sync(t0);

    return blow_time != TS_NEVER && blow_time < t1 ? blow_time : t1;
}

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

// IMPLEMENTATION OF CORE LINKAGE: fuse

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

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

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

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

---

GridLAB-D^TM Version 1.0

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