residential/microwave.cpp

Go to the documentation of this file.

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

#include "house.h"
#include "microwave.h"

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

microwave::microwave(MODULE *module) 
{
    // first time init
    if (oclass==NULL)
    {
        // register the class definition
        oclass = gl_register_class(module,"microwave",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_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,"heat_fraction",PADDR(heat_fraction),
            PT_complex,"meter[kWh]",PADDR(kwh_meter),
            NULL)<1) 
            GL_THROW("unable to publish properties in %s",__FILE__);

        // setup the default values
        defaults = this;

        // other derived properties
        power_kw =0;
        power_factor = 0.95;
        kwh_meter = 0;
        internal_heat = 0;
    }
}

microwave::~microwave()
{
}

int microwave::create() 
{
    // copy the defaults
    memcpy(this,defaults,sizeof(*this));

    // defult properties
    installed_power = gl_random_uniform(700,1200);  // microwave size [W]
    demand = gl_random_uniform(0, 0.1);  // assuming a default maximum 10% of the sync time 
    heat_fraction = 0.25;  // assuming default 25% of power is transferred as heat
    return 1;
}

int microwave::init(OBJECT *parent)
{
    if (parent==NULL)
    {
        gl_error("microwave 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;

    // initial demand
    power_kw = installed_power * demand / 1000;

    return 1;
}

TIMESTAMP microwave::sync(TIMESTAMP t0, TIMESTAMP t1) 
{
    // get demand fraction as an average per hour since the last synch time
    // a function  prototype will be 'get_average_demand(t0, t1)' which will be used to set 'demand' 
    // by default 'demand' is 1.0, now provided by the tape
    
    if (t0 <= 0)
        return TS_NEVER;

    power_kw.SetPolar(installed_power * demand / 1000.0, acos(power_factor), J);
    double energy = power_kw.Mag() * (gl_tohours(t1)-gl_tohours(t0));
    internal_heat = energy * heat_fraction * BTUPHPKW;
    kwh_meter += energy;

    house *pHouse = OBJECTDATA((OBJECTHDR(this))->parent,house);
    pHouse->microwave_heat_energy += internal_heat;
    pHouse->power_kw += power_kw;

    return TS_NEVER; 
}

// IMPLEMENTATION OF CORE LINKAGE

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

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

EXPORT TIMESTAMP sync_microwave(OBJECT *obj, TIMESTAMP t0)
{
    microwave *my = OBJECTDATA(obj, microwave);
    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