residential/lights.cpp

Go to the documentation of this file.

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

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

double lights::power_factor[_MAXTYPES];

// the constructor registers the class and properties and sets the defaults
lights::lights(MODULE *mod) 
{
    // first time init
    if (oclass==NULL)
    {
        // register the class definition
        oclass = gl_register_class(mod,"lights",PC_BOTTOMUP);
        if (oclass==NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);

        // publish the class properties
        if (gl_publish_variable(oclass,
            PT_enumeration,"type",PADDR(type),
                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_KEYWORD,"INDOOR",INDOOR,
                PT_KEYWORD,"OUTDOOR",OUTDOOR,
            PT_double,"installed_power[W]",PADDR(installed_power),
            PT_double,"circuit_split",PADDR(circuit_split),
            PT_double,"demand[%]",PADDR(demand),
            PT_complex,"power[kW]",PADDR(power_kw),
            PT_double,"internal_heat",PADDR(internal_heat),
            PT_double,"external_heat",PADDR(external_heat),
            PT_complex,"meter[kWh]",PADDR(kwh_meter),       //< local meter variable to keep track of energy
            NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);

        // default global values
        power_factor[INCANDESCENT]  = 1.00;
        power_factor[FLUORESCENT]   = 0.93;
        power_factor[CFL]           = 0.86;
        power_factor[SSL]           = 0.75;
        power_factor[HID]           = 0.97;

        // setup the default values
        defaults = this;
        type = INCANDESCENT;
        placement = INDOOR;
        circuit_split = 0;
        power_density = 0;
        installed_power = 0;
        demand = 0.0;
        power_kw = 0;
        kwh_meter = 0.0;
        internal_heat = 0.0;
        external_heat = 0.0;
        pVoltage = NULL;
    }
}

// create is called every time a new object is loaded
int lights::create(void) 
{
    // copy the defaults
    memcpy(this,defaults,sizeof(*this));

    // set basic properties
    circuit_split = gl_random_uniform(-1,1); // @todo circuit_split is ignored and should be delete; the split is done automatically by panel.attach()
    power_density = gl_random_normal(1.0, 0.075);  // W/sf
    
    // other initial conditions
    demand = 1.0;
    return 1;
}

int lights::init(OBJECT *parent)
{
    // lights must have a parent house
    if (parent==NULL)
    {
        gl_error("lights must have a parent house");
        return 0;
    }
    house *pHouse = OBJECTDATA(parent,house);

    // attach object to house panel
    pVoltage = (pHouse->attach(OBJECTHDR(this),20,false))->pV;

    // installed power intially overrides use of power density
    if (installed_power==0) 
        installed_power = power_density * pHouse->floor_area;

    // initial demand (assume power factor is 1.0
    power_kw = installed_power * demand / 1000;

    return 1;
}

TIMESTAMP lights::sync(TIMESTAMP t0, TIMESTAMP t1) 
{
    // compute nominal power consumption (adjust with power factor)
    power_kw.SetPolar(installed_power/power_factor[type] * demand / 1000.0, acos(power_factor[type]),J);

    // adjust power based on lamp type's response to voltage
    double puV = pVoltage->Mag()/120.0;
    switch (type) {
    case INCANDESCENT:
        if (puV<0.25)
            power_kw = 0;
        else
            power_kw *= puV; // proportional to voltage
        break;
    case FLUORESCENT:
    case CFL:
    case SSL:
        if (puV<0.1)
            power_kw = 0;
        else
        {   
            power_kw.Re() *= puV; 
            power_kw.Im() *= sqrt(puV);
        }
        break;
    case HID:
        if (puV<0.75)
            power_kw = 0;
        else
            power_kw *= pow(puV,-2); 
        break;
    default:
        break;
    }

    // update energy if clock is started
    if (t0>0)
    {
        double energy = power_kw.Mag()*(gl_tohours(t1)-gl_tohours(t0));
        internal_heat = (placement==INDOOR ? (energy * BTUPHPKW) : 0);
        external_heat = (placement==OUTDOOR ? (energy * BTUPHPKW) : 0);
        kwh_meter += energy;
    }

    // update parent house 
    OBJECT *parent = (OBJECTHDR(this))->parent;
    house *pHouse = OBJECTDATA(parent,house);
    LOCK_OBJECT(parent);
    pHouse->lights_heat_energy += internal_heat;
    UNLOCK_OBJECT(parent);

    return TS_NEVER; 
}

// IMPLEMENTATION OF CORE LINKAGE

EXPORT int create_lights(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(lights::oclass,sizeof(lights));
    if (*obj!=NULL)
    {
        lights *my = OBJECTDATA(*obj,lights);
        gl_set_parent(*obj,parent);
        my->create();
        return 1;
    }
    return 0;
}

EXPORT int init_lights(OBJECT *obj)
{
    lights *my = OBJECTDATA(obj,lights);
    return my->init(obj->parent);
}

EXPORT TIMESTAMP sync_lights(OBJECT *obj, TIMESTAMP t0)
{
    lights *my = OBJECTDATA(obj,lights);
    TIMESTAMP t1 = my->sync(obj->clock, t0);
    obj->clock = t0;
    return t1;
}

---

GridLAB-D^TM Version 1.0

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