powerflow/underground_line_conductor.cpp

Go to the documentation of this file.

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

#include "line.h"

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

underground_line_conductor::underground_line_conductor(MODULE *mod)
{
    if(oclass == NULL)
    {
        oclass = gl_register_class(mod,"underground_line_conductor",0x00);
        if(oclass == NULL)
            GL_THROW("unable to register underground_line_conductor class implemented by %s",__FILE__);
        
        if(gl_publish_variable(oclass,
            PT_double, "outer_diameter[in]",PADDR(outer_diameter),
            PT_double, "conductor_gmr[in]", PADDR(conductor_gmr),
            PT_double, "conductor_diameter[in]",PADDR(conductor_diameter),
            PT_double, "conductor_resistance[ohm/mile]",PADDR(conductor_resistance),
            PT_double, "neutral_gmr[in]",PADDR(neutral_gmr),
            PT_double, "neutral_diameter[in]",PADDR(neutral_diameter),
            PT_double, "neutral_resistance[ohm/mile]",PADDR(neutral_resistance),
            PT_int16,  "neutral_strands",PADDR(neutral_strands),
            PT_double, "shield_gmr[in]",PADDR(shield_gmr),
            PT_double, "shield_resistance[ohm/mile]",PADDR(shield_resistance),
            PT_double, "rating.summer.continuous[A]", PADDR(summer.continuous),
            PT_double, "rating.summer.emergency[A]", PADDR(summer.emergency),
            PT_double, "rating.winter.continuous[A]", PADDR(winter.continuous),
            PT_double, "rating.winter.emergency[A]", PADDR(winter.emergency),
            NULL) < 1) GL_THROW("unable to publish underground_line_conductor properties in %s",__FILE__);
        
        // Set up defaults
        defaults = this;
        outer_diameter = conductor_gmr = conductor_diameter = 0.0;
        conductor_resistance = neutral_gmr = neutral_diameter = 0.0;
        neutral_resistance = shield_gmr = 0.0;
        neutral_strands = 0;
        shield_resistance = 0.0;
        summer.continuous = winter.continuous = 1000;
        summer.emergency = winter.emergency = 2000;
    }
}
int underground_line_conductor::create(void)
{
    memcpy(this,defaults,sizeof(underground_line_conductor));
    return 1;
}

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


// IMPLEMENTATION OF CORE LINKAGE: underground_line_conductor

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

EXPORT TIMESTAMP sync_underground_line_conductor(OBJECT *obj, TIMESTAMP t1, PASSCONFIG pass)
{
    return TS_NEVER;
}

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

---

GridLAB-D^TM Version 1.0

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