residential/lights.cpp

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include "residential.h"
#include "lights.h"

// lights CLASS FUNCTIONS
CLASS* lights::oclass = NULL;
CLASS* lights::pclass = NULL;

double lights::power_factor[_MAXTYPES] = {
    1.00, // INCANDESCENT
    0.95, // FLUORESCENT
    0.92, // CFL
    0.90, // SSL
    0.97, // HID
};

// the constructor registers the class and properties and sets the defaults
lights::lights(MODULE *mod) 
: residential_enduse(mod)
{
    // first time init
    if (oclass==NULL)
    {
        pclass = residential_enduse::oclass;

        // register the class definition
        oclass = gl_register_class(mod,"lights",sizeof(lights),PC_BOTTOMUP);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);
            /* TROUBLESHOOT
                The file that implements the lights in the residential module cannot register the class.
                This is an internal error.  Contact support for assistance.
             */

        // publish the class properties
        if (gl_publish_variable(oclass,
            PT_INHERIT, "residential_enduse",
            PT_enumeration,"type",PADDR(type), PT_DESCRIPTION, "lighting type (affects power_factor)",
                PT_KEYWORD,"INCANDESCENT",INCANDESCENT,
                PT_KEYWORD,"FLUORESCENT",FLUORESCENT,
                PT_KEYWORD,"CFL",CFL,
                PT_KEYWORD,"SSL",SSL,
                PT_KEYWORD,"HID",HID,
            PT_enumeration,"placement",PADDR(placement), PT_DESCRIPTION, "lighting location (affects where heatgains go)",
                PT_KEYWORD,"INDOOR",INDOOR,
                PT_KEYWORD,"OUTDOOR",OUTDOOR,
            PT_double,"installed_power[kW]",PADDR(shape.params.analog.power), PT_DESCRIPTION, "installed lighting capacity",
            PT_double,"power_density[W/sf]",PADDR(power_density), PT_DESCRIPTION, "installed power density",
            PT_double,"curtailment[pu]", PADDR(curtailment), PT_DESCRIPTION, "lighting curtailment factor",
            PT_double,"demand[pu]", PADDR(shape.load), PT_DESCRIPTION, "the current lighting demand",
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
            /* TROUBLESHOOT
                The file that implements the specified class cannot publisht the variables in the class.
                This is an internal error.  Contact support for assistance.
             */
    }
}

// create is called every time a new object is loaded
int lights::create(void) 
{
    int res = residential_enduse::create();

    // name of enduse
    load.name = oclass->name;

    load.power = load.admittance = load.current = load.total = complex(0,0,J);
    load.voltage_factor = 1.0;
    load.power_factor = 0.95;

    return res;
}

int lights::init(OBJECT *parent)
{
    OBJECT *hdr = OBJECTHDR(this);
    hdr->flags |= OF_SKIPSAFE;

    // check the load configuration before initializing the parent class
    if(shape.load > 1.0)
        gl_warning("lighting load %f exceeds installed capacity", shape.load);
        /* TROUBLESHOOT
            The lighting load cannot exceed the installed capacity.  
            Use a lighting load that is less than or equal to 1.0 and try again.
         */
    else if (shape.load < 0.0)
        gl_warning("lights load %f is negative", shape.load);
        /* TROUBLESHOOT
            The lighting load cannot be negative.
            Use a positive lighting load and try again.
         */

    if (load.power_factor==0) load.power_factor = power_factor[type];
    if (load.voltage_factor==0) load.voltage_factor = 1.0;

    // check for the right kind of loadshape schedule 
    if (shape.type!=MT_ANALOG && shape.type != MT_UNKNOWN)
        throw("residential lighting only supports analog loadshapes");
        /* TROUBLESHOOT
            Lighting load use analog loadshapes.
            Change the load shape type to analogy and try again.
         */
    if (shape.params.analog.energy>0)
        throw("residential lighting does not support fixed energy");
        /* TROUBLESHOOT
            It is not possible to define the total energy consumed by a lighting load in relation to a schedule.
            Use either scaled power or installed power to define the lighting load and try again.
         */

    // installed power intially overrides use of power density
    double *floor_area = parent?gl_get_double_by_name(parent, "floor_area"):NULL;
    if (shape.params.analog.power==0 && shape.schedule==NULL) 
    {       
        // set basic properties
        if (power_density==0) power_density = gl_random_triangle(0.75, 1.25);  // W/sf

        if(floor_area == NULL)
        {
            gl_error("lights parent must publish \'floor_area\' to work properly if no installed_power is given ~ default 2500 sf");
            /* TROUBLESHOOT
                The lights did not reference a parent object that publishes a floor are, so 2500 sf was assumed.
                Change the parent reference and try again.
             */
            shape.params.analog.power = power_density * 2500 / 1000;
        } else {
            shape.params.analog.power = power_density * *floor_area / 1000;
        }
    }
    else if (power_density==0 && shape.params.analog.power>0)
    {
        if (floor_area!=NULL)
            power_density = shape.params.analog.power / *floor_area ;
        else
            power_density = shape.params.analog.power / 2500;
    }

    //load.power_factor = power_factor[type];
    load.breaker_amps = 40;

    if(placement == INDOOR){
        load.heatgain_fraction = 0.90;
    } else if (placement == OUTDOOR){
        load.heatgain_fraction = 0.0;
    }

    // circuit config and breaker amps

    // waiting this long to initialize the parent class is normal
    return residential_enduse::init(parent);
}

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

TIMESTAMP lights::sync(TIMESTAMP t0, TIMESTAMP t1) 
{
    double val = 0.0;
    TIMESTAMP t2 = TS_NEVER;

    if (pCircuit!=NULL)
        load.voltage_factor = pCircuit->pV->Mag() / 120; // update voltage factor

    t2 = residential_enduse::sync(t0,t1);

    if(shape.type == MT_UNKNOWN){ /* manual power calculation*/
        double frac = shape.load * (1-curtailment);
        if(shape.load < 0){
            gl_warning("lights shape demand is negative, capping to 0");
            shape.load = 0.0;
        } else if (shape.load > 1.0){
            gl_warning("lights shape demand exceeds installed lighting power, capping to 100%%");
            shape.load = 1.0;
        }
        load.power = shape.params.analog.power * shape.load;
        if(fabs(load.power_factor) < 1){
            val = (load.power_factor<0?-1.0:1.0) * load.power.Re() * sqrt(1/(load.power_factor * load.power_factor) - 1);
        } else {
            val = 0;
        }
        load.power.SetRect(load.power.Re(), val);
    }

    gl_enduse_sync(&(residential_enduse::load),t1);
    return t2;
}

// IMPLEMENTATION OF CORE LINKAGE

EXPORT int create_lights(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(lights::oclass);
    if (*obj!=NULL)
    {
        lights *my = OBJECTDATA(*obj,lights);
        gl_set_parent(*obj,parent);
        try {
            my->create();
        }
        catch (char *msg)
        {
            gl_error("%s::%s.create(OBJECT **obj={name='%s', id=%d},...): %s", (*obj)->oclass->module->name, (*obj)->oclass->name, (*obj)->name, (*obj)->id, msg);
            /* TROUBLESHOOT
                The create operation of the specified object failed.  
                The message given provide additional details and can be looked up under the Exceptions section.
             */
            return 0;
        }
        return 1;
    }
    return 0;
}

EXPORT int init_lights(OBJECT *obj)
{
    lights *my = OBJECTDATA(obj,lights);
    try {
        return my->init(obj->parent);
    }
    catch (char *msg)
    {
        gl_error("%s::%s.init(OBJECT *obj={name='%s', id=%d}): %s", obj->oclass->module->name, obj->oclass->name, obj->name, obj->id, msg);
        /* TROUBLESHOOT
            The initialization operation of the specified object failed.  
            The message given provide additional details and can be looked up under the Exceptions section.
         */
        return 0;
    }
}

EXPORT int isa_lights(OBJECT *obj, char *classname)
{
    if(obj != 0 && classname != 0){
        return OBJECTDATA(obj,lights)->isa(classname);
    } else {
        return 0;
    }
}

EXPORT TIMESTAMP sync_lights(OBJECT *obj, TIMESTAMP t1)
{
    lights *my = OBJECTDATA(obj,lights);
    try {
        TIMESTAMP t2 = my->sync(obj->clock, t1);
        obj->clock = t1;
        return t2;
    }
    catch (char *msg)
    {
        DATETIME dt;
        char ts[64];
        gl_localtime(t1,&dt);
        gl_strtime(&dt,ts,sizeof(ts));
        gl_error("%s::%s.init(OBJECT **obj={name='%s', id=%d},TIMESTAMP t1='%s'): %s", obj->oclass->module->name, obj->oclass->name, obj->name, obj->id, ts, msg);
        /* TROUBLESHOOT
            The synchronization operation of the specified object failed.  
            The message given provide additional details and can be looked up under the Exceptions section.
         */
        return 0;
    }
}

---

GridLAB-D^TM Version 2.0

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