powerflow/capacitor.cpp

Go to the documentation of this file.

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

#include "capacitor.h"

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

capacitor::capacitor(MODULE *mod):node(mod)
{
    if(oclass == NULL)
    {
        pclass = node::oclass;
        
        oclass = gl_register_class(mod,"capacitor",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,"sync_V_limit[V]",PADDR(sync_V_limit),
            PT_complex, "phaseA_V[V]", PADDR(phaseA_V),
            PT_complex, "phaseB_V[V]", PADDR(phaseB_V),
            PT_complex, "phaseC_V[V]", PADDR(phaseC_V),
            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,
            PT_set, "pt_phase", PADDR(pt_phase),
                PT_KEYWORD, "A",PHASE_A,
                PT_KEYWORD, "B",PHASE_B,
                PT_KEYWORD, "C",PHASE_C,
            PT_enumeration, "switch", switch_state,
                PT_KEYWORD, "OPEN", OPEN,
                PT_KEYWORD, "CLOSED", CLOSED,
            PT_enumeration, "control", control,
                PT_KEYWORD, "MANUAL", MANUAL,
                PT_KEYWORD, "VAR", VAR,
                PT_KEYWORD, "VOLT", VOLT,
                PT_KEYWORD, "VARVOLT", VARVOLT,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);

        // Set up defaults
        memset(this,0,sizeof(capacitor));
        defaults = this;  
        switch_state = CLOSED;
        control = MANUAL;
        var_close = 0.0;
        var_open = 0.0;
        volt_close = 0.0;
        volt_open = 0.0;
        pt_ratio = 60;
        pt_phase = PHASE_A;
        time_delay = 0;
        time_to_change = 0.0;
      
    }
}

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

TIMESTAMP capacitor::sync(TIMESTAMP t0)
{
    if (switch_state==CLOSED) {
        switch (control) {
            case MANUAL:  // manual
                break;
            case VAR:  // VAr
                break;
            case VOLT:  // V
                break;
            case VARVOLT:  // VAr, V
                break;
            default:
                break;
        }
    } else {
        switch (control) {
            case MANUAL:  // manual
                break;
            case VAR:  // VAr
                break;
            case VOLT:  // V
                break;
            case VARVOLT:  // VAr, V
                break;
            default:
                break;
        }
    }
    return node::sync(t0);
}

TIMESTAMP capacitor::postsync(TIMESTAMP t0)
{
    return node::postsync(t0);
}

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

// IMPLEMENTATION OF CORE LINKAGE: capacitor

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



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

EXPORT TIMESTAMP sync_capacitor(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    capacitor *pObj = OBJECTDATA(obj,capacitor);
    try {
        TIMESTAMP t1 = TS_NEVER;
        switch (pass) {
        case PC_PRETOPDOWN:
            return pObj->presync(t0);
        case PC_BOTTOMUP:
            return pObj->sync(t0);
        case PC_POSTTOPDOWN:
            t1 = pObj->postsync(t0);
            obj->clock = t0;
            return t1;
        default:
            throw "invalid pass request";
        }
    } catch (const char *error) {
        GL_THROW("%s (capacitor:%d): %s", pObj->get_name(), pObj->get_id(), error);
        return 0; 
    } catch (...) {
        GL_THROW("%s (capacitor:%d): %s", pObj->get_name(), pObj->get_id(), "unknown exception");
        return 0;
    }
}

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

---

GridLAB-D^TM Version 1.0

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