generators/power_electronics.cpp

Go to the documentation of this file.

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

#include "generators.h"
#include "power_electronics.h"

#define DEFAULT 1.0;
#define S_DEFAULT 1.0;
#define G_DEFAULT 1000.0; 

CLASS *power_electronics::oclass = NULL;
power_electronics *power_electronics::defaults = NULL;

static PASSCONFIG passconfig = PC_BOTTOMUP|PC_POSTTOPDOWN;
static PASSCONFIG clockpass = PC_BOTTOMUP;





power_electronics::power_electronics(){}

/* Class registration is only called once to register the class with the core */
power_electronics::power_electronics(MODULE *module)
{
    if (oclass==NULL)
    {
        oclass = gl_register_class(module,"power_electronics",sizeof(power_electronics),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s", __FILE__); 

        if (gl_publish_variable(oclass,
            //should this be "GENERATOR_MODE" OR "gen_mode_v"?
            PT_enumeration,"generator_mode",PADDR(gen_mode_v),
                PT_KEYWORD,"UNKNOWN",UNKNOWN,
                PT_KEYWORD,"CONSTANT_V",CONSTANT_V,
                PT_KEYWORD,"CONSTANT_PQ",CONSTANT_PQ,
                PT_KEYWORD,"CONSTANT_PF",CONSTANT_PF,
                PT_KEYWORD,"SUPPLY_DRIVEN",SUPPLY_DRIVEN,

            PT_enumeration,"generator_status",PADDR(gen_status_v),
                PT_KEYWORD,"OFFLINE",OFFLINE,
                PT_KEYWORD,"ONLINE",ONLINE, 
            
            PT_enumeration,"converter_type",PADDR(converter_type_v),
                PT_KEYWORD,"VOLTAGE_SOURCED",VOLTAGE_SOURCED,
                PT_KEYWORD,"CURRENT_SOURCED",CURRENT_SOURCED,

            PT_enumeration,"switch_type",PADDR(switch_type_v),
                PT_KEYWORD,"IDEAL_SWITCH",IDEAL_SWITCH,
                PT_KEYWORD,"BJT",BJT,
                PT_KEYWORD,"MOSFET",MOSFET,
                PT_KEYWORD,"SCR",SCR,
                PT_KEYWORD,"JFET",JFET,
                PT_KEYWORD,"IBJT",IBJT,
                PT_KEYWORD,"DARLINGTON",DARLINGTON,

            PT_enumeration,"filter_type",PADDR(filter_type_v),
                PT_KEYWORD,"LOW_PASS",LOW_PASS,
                PT_KEYWORD,"HIGH_PASS",HIGH_PASS,
                PT_KEYWORD,"BAND_STOP",BAND_STOP,
                PT_KEYWORD,"BAND_PASS",BAND_PASS,

            PT_enumeration,"filter_implementation",PADDR(filter_imp_v),
                PT_KEYWORD,"IDEAL_FILTER",IDEAL_FILTER,
                PT_KEYWORD,"CAPACITVE",CAPACITIVE,
                PT_KEYWORD,"INDUCTIVE",INDUCTIVE,
                PT_KEYWORD,"SERIES_RESONANT",SERIES_RESONANT,
                PT_KEYWORD,"PARALLEL_RESONANT",PARALLEL_RESONANT,

            PT_enumeration,"filter_frequency",PADDR(filter_freq_v),
                PT_KEYWORD,"F120HZ",F120HZ,
                PT_KEYWORD,"F180HZ",F180HZ,
                PT_KEYWORD,"F240HZ",F240HZ,

            
            PT_enumeration,"power_type",PADDR(power_type_v),
                PT_KEYWORD,"AC",AC,
                PT_KEYWORD,"DC",DC,

            PT_double, "Rated_kW[kW]", PADDR(Rated_kW), //< nominal power in kW
            PT_double, "Max_P[kW]", PADDR(Max_P),//< maximum real power capacity in kW
            PT_double, "Min_P[kW]", PADDR(Min_P),//< minimum real power capacity in kW
            //PT_double, "Max_Q[kVAr]", PADDR(Max_Q),//< maximum reactive power capacity in kVar
            //PT_double, "Min_Q[kVAr]", PADDR(Min_Q),//< minimum reactive power capacity in kVar
    
            PT_double, "Rated_kVA[kVA]", PADDR(Rated_kVA),
            PT_double, "Rated_kV[kV]", PADDR(Rated_kV),
            //PT_int64, "generator_mode_choice", PADDR(generator_mode_choice),
            
/*          
            PT_double, Rinternal;
            PT_double, Rload;
            PT_double, Rtotal;
            PT_double, Rphase;
            PT_double, Rground;
            PT_double, Rground_storage;
            PT_double[3], Rfilter;

            PT_double, Cinternal;
            PT_double, Cground;
            PT_double, Ctotal;
            PT_double[3], Cfilter;

            PT_double, Linternal;
            PT_double, Lground;
            PT_double, Ltotal;
            PT_double[3], Lfilter;

            PT_bool, filter_120HZ;
            PT_bool, filter_180HZ;
            PT_bool, filter_240HZ;
*/
            //PT_double, "pf_in[double]", PADDR(pf_in),
            //PT_double, "pf_out[double]", PADDR(pf_out),
/*
            PT_int, number_of_phases_in;
            PT_int, number_of_phases_out;

            SWITCH_TYPE switch_type_choice;
            SWITCH_IMPLEMENTATION switch_implementation_choice;
            GENERATOR_MODE generator_mode_choice;
            POWER_TYPE power_in;
            POWER_TYPE power_out;
*/
            //PT_double, "efficiency[double]", PADDR(efficiency),


/*
            PT_complex, "voltage_A[V]", PADDR(voltage_A),
            PT_complex, "voltage_B[V]", PADDR(voltage_B),
            PT_complex, "voltage_C[V]", PADDR(voltage_C),
            PT_complex, "current_A[A]", PADDR(current_A),
            PT_complex, "current_B[A]", PADDR(current_B),
            PT_complex, "current_C[A]", PADDR(current_C),
            PT_complex, "EfA[V]", PADDR(EfA),
            PT_complex, "EfB[V]", PADDR(EfB),
            PT_complex, "EfC[V]", PADDR(EfC),
            PT_complex, "power_A[VA]", PADDR(power_A),
            PT_complex, "power_B[VA]", PADDR(power_B),
            PT_complex, "power_C[VA]", PADDR(power_C),
            PT_complex, "power_A_sch[VA]", PADDR(power_A_sch),
            PT_complex, "power_B_sch[VA]", PADDR(power_B_sch),
            PT_complex, "power_C_sch[VA]", PADDR(power_C_sch),
            PT_complex, "EfA_sch[V]", PADDR(EfA_sch),
            PT_complex, "EfB_sch[V]", PADDR(EfB_sch),
            PT_complex, "EfC_sch[V]", PADDR(EfC_sch),
*/          
            
            PT_set, "phases", PADDR(phases),
                PT_KEYWORD, "A",(set)PHASE_A,
                PT_KEYWORD, "B",(set)PHASE_B,
                PT_KEYWORD, "C",(set)PHASE_C,
                PT_KEYWORD, "N",(set)PHASE_N,
                PT_KEYWORD, "S",(set)PHASE_S,
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
        defaults = this;
        memset(this,0,sizeof(power_electronics));
        /* TODO: set the default values of all properties here */
    }
}



int power_electronics::filter_circuit_impact(power_electronics::FILTER_TYPE filter_type_choice, power_electronics::FILTER_IMPLEMENTATION filter_implementation_choice){
    switch(filter_type_choice){
        case BAND_PASS:
            switch(filter_implementation_choice){
                case IDEAL_FILTER:
                    if(filter_120HZ){
                    Rsfilter[0] = S_DEFAULT;
                    Rgfilter[0] = G_DEFAULT;
                    Xsfilter[0] = S_DEFAULT;
                    Xgfilter[0] = G_DEFAULT;
                    }
                    if(filter_180HZ){
                    Rsfilter[1] = S_DEFAULT;
                    Rgfilter[1] = G_DEFAULT;
                    Xsfilter[1] = S_DEFAULT;
                    Xgfilter[1] = G_DEFAULT;
                    }
                    if(filter_240HZ){
                    Rsfilter[2] = S_DEFAULT;
                    Rgfilter[2] = G_DEFAULT;
                    Xsfilter[2] = S_DEFAULT;
                    Xgfilter[2] = G_DEFAULT;
                    }
                    break;
                case CAPACITIVE:
                    if(filter_120HZ){
                    Rsfilter[0] = S_DEFAULT;
                    Rgfilter[0] = G_DEFAULT;
                    Xsfilter[0] = S_DEFAULT;
                    Xgfilter[0] = G_DEFAULT;
                    }
                    if(filter_180HZ){
                    Rsfilter[1] = S_DEFAULT;
                    Rgfilter[1] = G_DEFAULT;
                    Xsfilter[1] = S_DEFAULT;
                    Xgfilter[1] = G_DEFAULT;
                    }
                    if(filter_240HZ){
                    Rsfilter[2] = S_DEFAULT;
                    Rgfilter[2] = G_DEFAULT;
                    Xsfilter[2] = S_DEFAULT;
                    Xgfilter[2] = G_DEFAULT;
                    }
                    break;
                case INDUCTIVE:
                    if(filter_120HZ){
                    Rsfilter[0] = S_DEFAULT;
                    Rgfilter[0] = G_DEFAULT;
                    Xsfilter[0] = S_DEFAULT;
                    Xgfilter[0] = G_DEFAULT;
                    }
                    if(filter_180HZ){
                    Rsfilter[1] = S_DEFAULT;
                    Rgfilter[1] = G_DEFAULT;
                    Xsfilter[1] = S_DEFAULT;
                    Xgfilter[1] = G_DEFAULT;
                    }
                    if(filter_240HZ){
                    Rsfilter[2] = S_DEFAULT;
                    Rgfilter[2] = G_DEFAULT;
                    Xsfilter[2] = S_DEFAULT;
                    Xgfilter[2] = G_DEFAULT;
                    }
                    break;
                case SERIES_RESONANT:
                    if(filter_120HZ){
                    Rsfilter[0] = S_DEFAULT;
                    Rgfilter[0] = G_DEFAULT;
                    Xsfilter[0] = S_DEFAULT;
                    Xgfilter[0] = G_DEFAULT;
                    }
                    if(filter_180HZ){
                    Rsfilter[1] = S_DEFAULT;
                    Rgfilter[1] = G_DEFAULT;
                    Xsfilter[1] = S_DEFAULT;
                    Xgfilter[1] = G_DEFAULT;
                    }
                    if(filter_240HZ){
                    Rsfilter[2] = S_DEFAULT;
                    Rgfilter[2] = G_DEFAULT;
                    Xsfilter[2] = S_DEFAULT;
                    Xgfilter[2] = G_DEFAULT;
                    }
                    break;
                case PARALLEL_RESONANT:
                    if(filter_120HZ){
                    Rsfilter[0] = S_DEFAULT;
                    Rgfilter[0] = G_DEFAULT;
                    Xsfilter[0] = S_DEFAULT;
                    Xgfilter[0] = G_DEFAULT;
                    }
                    if(filter_180HZ){
                    Rsfilter[1] = S_DEFAULT;
                    Rgfilter[1] = G_DEFAULT;
                    Xsfilter[1] = S_DEFAULT;
                    Xgfilter[1] = G_DEFAULT;
                    }
                    if(filter_240HZ){
                    Rsfilter[2] = S_DEFAULT;
                    Rgfilter[2] = G_DEFAULT;
                    Xsfilter[2] = S_DEFAULT;
                    Xgfilter[2] = G_DEFAULT;
                    }
                    break;
                default:
                    break;
            }
        break;

        default:
        break;
            
    }
    Rsfilter_total = Rsfilter[0] + Rsfilter[1] + Rsfilter[2];
    Rgfilter_total = Rgfilter[0] + Rgfilter[1] + Rgfilter[2];
    Xsfilter_total = Xsfilter[0] + Xsfilter[1] + Xsfilter[2];
    Xgfilter_total = Xgfilter[0] + Xgfilter[1] + Xgfilter[2];
    return 1;
}

//given output voltage, solves source voltage

complex power_electronics::filter_voltage_impact_source(complex desired_I_out, complex desired_V_out){
    if(desired_V_out == 0){
        return complex(0,0);
    }else{
    complex Is = filter_current_impact_source(desired_I_out, desired_V_out);
    complex Vs = desired_V_out + (Is * complex(Rsfilter_total,Xsfilter_total));
    return Vs;
    }
}

//given output current, solves source current

complex power_electronics::filter_current_impact_source(complex desired_I_out, complex desired_V_out){
    if(desired_I_out == 0){
        return complex(0,0);
    }else{
    complex Ig = desired_V_out / complex(Rgfilter_total,Xgfilter_total);
    complex Is = desired_I_out + Ig;
    return Is;
    }
}


//given the input source and voltage, compute output voltage
complex power_electronics::filter_voltage_impact_out(complex source_I_in, complex source_V_in){
    if(source_V_in == 0){
        return complex(0,0);
    }else{
    complex Vo = source_V_in - (source_I_in * complex(Rsfilter_total,Xsfilter_total));
    return Vo;
    }
}

//given the input source and voltage, compute output current
complex power_electronics::filter_current_impact_out(complex source_I_in, complex source_V_in){
    if(source_I_in == 0){
        return complex(0,0);
    }else{
    complex Vo = filter_voltage_impact_out(source_I_in, source_V_in);
    complex Ig = Vo / complex(Rgfilter_total,Xgfilter_total);
    complex Io = source_I_in - Ig;
    return Io;
    }
}



double power_electronics::internal_switch_resistance(power_electronics::SWITCH_TYPE switch_type_choice){
    switch(switch_type_choice){
        case IDEAL_SWITCH:
            Rinternal += 0;
            break;
        case BJT:
            Rinternal += DEFAULT;
            break;
        case MOSFET:
            Rinternal += DEFAULT;
            break;
        case SCR:
            Rinternal += DEFAULT;
            break;  
        case JFET:
            Rinternal += DEFAULT;
            break;  
        case IBJT:
            Rinternal += DEFAULT;
            break;
        case DARLINGTON:
            Rinternal += DEFAULT;
            break;
        default:
            break;
    }
    return 1;
}

double power_electronics::calculate_loss(double Rtotal, double LTotal, double Ctotal, POWER_TYPE power_in, POWER_TYPE power_out){
    //placeholder
    return 0;
}

double power_electronics::calculate_frequency_loss(double frequency, double Rtotal, double Ltotal, double Ctotal){
    //placeholder
    return 0;
}




/* Object creation is called once for each object that is created by the core */
int power_electronics::create(void) 
{
    memcpy(this,defaults,sizeof(*this));
    /* TODO: set the context-free initial value of properties */
    return 1; /* return 1 on success, 0 on failure */
}

/* Object initialization is called once after all object have been created */
int power_electronics::init(OBJECT *parent)
{
    
    /* TODO: set the context-dependent initial value of properties */
    return 1;
}

/* Presync is called when the clock needs to advance on the first top-down pass */
TIMESTAMP power_electronics::presync(TIMESTAMP t0, TIMESTAMP t1)
{
    //current_A = current_B = current_C = 0.0;

    TIMESTAMP t2 = TS_NEVER;
    /* TODO: implement pre-topdown behavior */
    return t2; /* return t2>t1 on success, t2=t1 for retry, t2<t1 on failure */
}

/* Sync is called when the clock needs to advance on the bottom-up pass */
TIMESTAMP power_electronics::sync(TIMESTAMP t0, TIMESTAMP t1) 
{

//  complex PA,QA,PB,QB,PC,QC;
//  double Rated_kVar;
//  if (Gen_mode==CONSTANTEf)
//  {
//      current_A += AMx[0][0]*(voltage_A-EfA) + AMx[0][1]*(voltage_B-EfB) + AMx[0][2]*(voltage_C-EfC);
//      current_B += AMx[1][0]*(voltage_A-EfA) + AMx[1][1]*(voltage_B-EfB) + AMx[1][2]*(voltage_C-EfC);
//      current_C += AMx[2][0]*(voltage_A-EfA) + AMx[2][1]*(voltage_B-EfB) + AMx[2][2]*(voltage_C-EfC);
// //       PA = Re(voltage_A * phaseA_I_in); 
//  
//  }else if (Gen_mode==CONSTANTPQ){
//          Rated_kVar = Rated_kW *sqrt(1-Rated_pf^2)/Rated_pf;
//      }
//*/
//      current_A = - (~(complex(power_A_sch)/voltage_A/3));
//      current_B = - (~(complex(power_B_sch)/voltage_B/3));
//      current_C = - (~(complex(power_C_sch)/voltage_C/3));
//  }
//
//
TIMESTAMP t2 = TS_NEVER;
//  /* TODO: implement bottom-up behavior */
return t2; /* return t2>t1 on success, t2=t1 for retry, t2<t1 on failure */
}

/* Postsync is called when the clock needs to advance on the second top-down pass */
TIMESTAMP power_electronics::postsync(TIMESTAMP t0, TIMESTAMP t1)
{
    TIMESTAMP t2 = TS_NEVER;
    return t2; /* return t2>t1 on success, t2=t1 for retry, t2<t1 on failure */
}

// IMPLEMENTATION OF CORE LINKAGE

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

EXPORT int init_power_electronics(OBJECT *obj, OBJECT *parent) 
{
    try 
    {
        if (obj!=NULL)
            return OBJECTDATA(obj,power_electronics)->init(parent);
    }
    catch (char *msg)
    {
        gl_error("init_power_electronics(obj=%d;%s): %s", obj->id, obj->name?obj->name:"unnamed", msg);
    }
    
    return 0;
}

EXPORT TIMESTAMP sync_power_electronics(OBJECT *obj, TIMESTAMP t1, PASSCONFIG pass)
{
    TIMESTAMP t2 = TS_NEVER;
    power_electronics *my = OBJECTDATA(obj,power_electronics);
    try
    {
        switch (pass) {
        case PC_PRETOPDOWN:
            t2 = my->presync(obj->clock,t1);
            break;
        case PC_BOTTOMUP:
            t2 = my->sync(obj->clock,t1);
            break;
        case PC_POSTTOPDOWN:
            t2 = my->postsync(obj->clock,t1);
            break;
        default:
            GL_THROW("invalid pass request (%d)", pass);
            break;
        }
        if (pass==clockpass)
            obj->clock = t1;        
    }
    catch (char *msg)
    {
        gl_error("sync_power_electronics(obj=%d;%s): %s", obj->id, obj->name?obj->name:"unnamed", msg);
    }
    return t2;
}

---

GridLAB-D^TM Version 2.0

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