powerflow/transformer.cpp

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <iostream>
using namespace std;

#include "transformer.h"

CLASS* transformer::oclass = NULL;
CLASS* transformer::pclass = NULL;
transformer  *transformer::defaults = NULL;

transformer::transformer(MODULE *mod) : link(mod)
{
    if(oclass == NULL)
    {
        pclass = link::oclass;
        
        oclass = gl_register_class(mod,"transformer",PC_BOTTOMUP|PC_POSTTOPDOWN);
        if(oclass == NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);
        
        if(gl_publish_variable(oclass,
                PT_object, "configuration", PADDR(configuration),
            PT_object, "to",PADDR(to),
            PT_object, "from",PADDR(from),
            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,
                PT_KEYWORD, "D",PHASE_D,
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
        
        // Set up defaults
        defaults = this;
        memset(this,0,sizeof(transformer));
    }
}

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

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

int transformer::init()
{
    double V_base,za_basehi,za_baselo,V_basehi;
    int32 sa_base;
    complex nt, nt_a, nt_b, nt_c, zt, zt_a, zt_b, zt_c,
            inv_nt_a, inv_nt_b, inv_nt_c,z0,z1,z2;

    link::init();

    if (!configuration)
        throw "no transformer configuration specified.";

    if (!gl_object_isa(configuration, "transformer_configuration"))
        throw "invalid transformer configuration";
    transformer_configuration *config = OBJECTDATA(configuration,
                                       transformer_configuration);

    V_base = config->V_secondary;
    nt = config->V_primary / config->V_secondary;
//  zt = (complex(config->R_pu, config->X_pu) * V_base * V_base) / ((double) config->kVA_rating * 1000.0);
    zt = (config->impedence * V_base * V_base) / ((double) config->kVA_rating * 1000.0);
    /* that shouldn't mutate impedence. */

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            a_mat[i][j] = b_mat[i][j] = c_mat[i][j] = d_mat[i][j] =
                                    A_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;
    }

    switch (config->connect_type) {
        case transformer_configuration::WYE_WYE: 
        case transformer_configuration::SINGLE_PHASE:
            if (has_phase(PHASE_A)) {
                nt_a = nt;
                zt_a = nt_a * zt;
                inv_nt_a = complex(1.0) / nt_a;
            } else {
                nt_a = zt_a = inv_nt_a = 0.0;
            }

            if (has_phase(PHASE_B)) {
                nt_b = nt;
                zt_b = nt_b * zt;
                inv_nt_b = complex(1.0) / nt_b;
            } else {
                nt_b = zt_b = inv_nt_b = 0.0;
            }

            if (has_phase(PHASE_C)) {
                nt_c = nt;
                zt_c = nt_c * zt;
                inv_nt_c = complex(1.0) / nt_c;
            } else {
                nt_c = zt_c = inv_nt_c = 0.0;
            }

            a_mat[0][0] = nt_a;
            a_mat[1][1] = nt_b;
            a_mat[2][2] = nt_c;

            b_mat[0][0] = zt_a;
            b_mat[1][1] = zt_b;
            b_mat[2][2] = zt_c;

            B_mat[0][0] = zt;
            B_mat[1][1] = zt;
            B_mat[2][2] = zt;

            d_mat[0][0] = A_mat[0][0] = inv_nt_a;
            d_mat[1][1] = A_mat[1][1] = inv_nt_b;
            d_mat[2][2] = A_mat[2][2] = inv_nt_c;

            break;
        case transformer_configuration::DELTA_DELTA:
            a_mat[0][0] = a_mat[1][1] = a_mat[2][2] = nt * 2.0 / 3.0;
            a_mat[0][1] = a_mat[0][2] = a_mat[1][0] = a_mat[1][2] = a_mat[2][0] = a_mat[2][1] = -nt / 3.0;

            b_mat[0][0] = b_mat[1][1] = nt * zt;
            b_mat[2][0] = b_mat[2][1] = -nt * zt;

            d_mat[0][0] = d_mat[1][1] = d_mat[2][2] = complex(1.0) / nt;

            A_mat[0][0] = A_mat[1][1] = A_mat[2][2] = complex(2.0) / (nt * 3.0);
            A_mat[0][1] = A_mat[0][2] = A_mat[1][0] = A_mat[1][2] = A_mat[2][0] = A_mat[2][1] = complex(-1.0) / (nt * 3.0);

            B_mat[0][0] = B_mat[1][1] = zt;
            B_mat[2][0] = B_mat[2][1] = -zt;
        
            break;
        case transformer_configuration::DELTA_GWYE:
            if (nt.Mag()>1.0)//step down transformer
            {
            nt *= sqrt(3.0);
            
            a_mat[0][1] = a_mat[1][2] = a_mat[2][0] = -nt * 2.0 / 3.0;
            a_mat[0][2] = a_mat[1][0] = a_mat[2][1] = -nt / 3.0;

            b_mat[0][1] = b_mat[1][2] = b_mat[2][0] = -nt * zt * 2.0 / 3.0;    
            b_mat[0][2] = b_mat[1][0] = b_mat[2][1] = -nt * zt / 3.0;    
            
            d_mat[0][0] = d_mat[1][1] = d_mat[2][2] = complex(1.0) / nt;
            d_mat[0][1] = d_mat[1][2] = d_mat[2][0] = complex(-1.0) / nt;

            A_mat[0][0] = A_mat[1][1] = A_mat[2][2] = complex(1.0) / nt;
            A_mat[0][2] = A_mat[1][0] = A_mat[2][1] = complex(-1.0) / nt;

            B_mat[0][0] = B_mat[1][1] = B_mat[2][2] = zt;
            }
            else {//step up transformer
            nt *= sqrt(3.0);
            
            a_mat[0][0] = a_mat[1][1] = a_mat[2][2] = nt * 2.0 / 3.0;
            a_mat[0][1] = a_mat[1][2] = a_mat[2][0] = nt / 3.0;

            b_mat[0][0] = b_mat[1][1] = b_mat[2][2] = nt * zt * 2.0 / 3.0;    
            b_mat[0][1] = b_mat[1][2] = b_mat[2][0] = nt * zt / 3.0;    
            
            d_mat[0][0] = d_mat[1][1] = d_mat[2][2] = complex(1.0) / nt;
            d_mat[0][2] = d_mat[1][0] = d_mat[2][1] = complex(-1.0) / nt;

            A_mat[0][0] = A_mat[1][1] = A_mat[2][2] = complex(1.0) / nt;
            A_mat[0][1] = A_mat[1][2] = A_mat[2][0] = complex(-1.0) / nt;

            B_mat[0][0] = B_mat[1][1] = B_mat[2][2] = zt;
            }

            break;
        case transformer_configuration::SINGLE_PHASE_CENTER_TAPPED:
            V_basehi = config->V_primary;
            sa_base = config->phaseA_kVA_rating;
            za_basehi = (V_basehi*V_basehi)/(sa_base*1000);
            za_baselo = (V_base * V_base)/(sa_base*1000);
            nt = config->V_primary/config->V_secondary;
            //z0 = complex(0.5 * config->R_pu,0.8*config->X_pu) * complex(za_basehi,0);
            z0 = complex(0.5 * config->impedence.Re(),0.8*config->impedence.Im()) * complex(za_basehi,0);
            //z1 = complex(config->R_pu,0.4 * config->X_pu) * complex(za_baselo,0);
            z1 = complex(config->impedence.Re(),0.4 * config->impedence.Im()) * complex(za_baselo,0);
            //z2 = complex(config->R_pu,0.4 * config->X_pu) * complex(za_baselo,0);
            z2 = complex(config->impedence.Re(),0.4 * config->impedence.Im()) * complex(za_baselo,0);
            zt_b = complex(0,0);
            zt_c = complex(0,0);

            b_mat[0][0] = (nt *z1)+(z0/nt);
            b_mat[0][1] = complex(-1,0) * (z0/nt);
            b_mat[0][2] = complex(0,0);
            b_mat[1][0] = (z0/nt);
            b_mat[1][1] = complex(-1,0) * ((nt*z2) + z0/nt);
            b_mat[1][2] = complex(0,0);
            b_mat[2][0] = complex(0,0);
            b_mat[2][1] = complex(0,0);
            b_mat[2][2] = complex(0,0);

            B_mat[0][0] = (z1) + (z0/(nt^2));
            B_mat[0][1] = complex(-1,0) * (z0/(nt^2));
            B_mat[1][0] = (z0/(nt^2));
            B_mat[1][1] = complex(-1,0) * ((z2) + (z0/(nt^2)));

            if (has_phase(PHASE_A)) {
                a_mat[0][0] = a_mat[1][0] = nt;
            
                d_mat[0][0] = complex(1,0)/nt;
                d_mat[0][1] = complex(-1,0)/nt;

                A_mat[0][0] = complex(1,0)/nt;
                A_mat[1][0] = complex(1,0)/nt;
            }

            else if (has_phase(PHASE_B)) {
                a_mat[0][1] = a_mat[1][1] = nt;
            
                d_mat[1][0] = complex(1,0)/nt;
                d_mat[1][1] = complex(-1,0)/nt;

                A_mat[0][1] = complex(1,0)/nt;
                A_mat[1][1] = complex(1,0)/nt;
            }

            else if (has_phase(PHASE_C)) {
                a_mat[0][2] = a_mat[1][2] = nt;
            
                d_mat[2][0] = complex(1,0)/nt;
                d_mat[2][1] = complex(-1,0)/nt;

                A_mat[0][2] = complex(1,0)/nt;
                A_mat[1][2] = complex(1,0)/nt;
            }
            break;
        default:
            throw "unknown transformer connect type";
    }

#ifdef _TESTING
    extern bool show_matrix_values;
    if (show_matrix_values)
    {
        gl_testmsg("transformer:\ta matrix");
        print_matrix(a_mat);
        gl_testmsg("transformer:\tA matrix");
        print_matrix(A_mat);
        gl_testmsg("transformer:\tb matrix");
        print_matrix(b_mat);
        gl_testmsg("transformer:\tB matrix");
        print_matrix(B_mat);
        gl_testmsg("transformer:\td matrix");
        print_matrix(d_mat);
    }
#endif

    return 1;
}

// IMPLEMENTATION OF CORE LINKAGE: transformer

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



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

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

---

GridLAB-D^TM Version 1.0

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