residential/test.h

#ifndef _RESIDENTIAL_TEST_H
#define _RESIDENTIAL_TEST_H

#include "gridlabd.h"

#include "house.h"
#include "waterheater.h"
#include "lights.h"
#include "clotheswasher.h"

#include "test_framework.h"

#include "test_callbacks.h"
// Include any module specific headers needed for testing.

class residential_test : public test_helper
{
    OBJECT *obj;
public:
    residential_test(){}
    void setup(){}

    OBJECT *house_create(){
        CLASS *cl = get_class_by_name("house");
        CPPUNIT_ASSERT(cl != NULL);
        obj = gl_create_object(cl,sizeof(house));
        CPPUNIT_ASSERT(obj != NULL);
        return obj;
    }

    OBJECT *lights_create() {
        CLASS *cl = get_class_by_name("lights");
        CPPUNIT_ASSERT(cl != NULL);
        obj = gl_create_object(cl,sizeof(lights));
        CPPUNIT_ASSERT(obj != NULL);
        return obj;
    }

    OBJECT *clotheswasher_create() {
        CLASS *cl = get_class_by_name("clotheswasher");
        CPPUNIT_ASSERT(cl != NULL);
        obj = gl_create_object(cl,sizeof(clotheswasher));
        CPPUNIT_ASSERT(obj != NULL);
        return obj;
    }

    void lights_test() {
        gl_output("\n\nLights Unit Tests");
        gl_output("======================");
        OBJECT *house1 = house_create();
        OBJECTDATA(house1, house)->create();

        OBJECT *lights1 = lights_create();
        OBJECTDATA(lights1, lights)->create();
        gl_set_parent(lights1, house1);
        CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
        CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
        
        double curPower = 1500.0, curDemand = 1.0;
        OBJECTDATA(lights1, lights)->type = lights::INCANDESCENT;
        OBJECTDATA(lights1, lights)->placement = lights::INDOOR;
        OBJECTDATA(lights1, lights)->demand = curDemand;
        OBJECTDATA(lights1, lights)->installed_power = curPower;

        TIMESTAMP _time = gl_parsetime("2000-08-01 0:0:0 GMT");;
        house1->clock = _time;

        double nhours, lasthour;
        nhours = gl_tohours(_time);
        double toHour = nhours + 24;
        lasthour = nhours;
        double expectedPower, gridlabPower, expectedHeatgain, gridlabHeatgain;
        double demandSchedule[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.3, 0.4, 0.5, 0.6, 0.4, 0.2, 0.2};

        gl_output("\n            Expected      Gridlab       Expected        Gridlab"); 
        gl_output(  "   Hour     power_kw      power_kw      heatgain        heatgain"); 

        while (nhours < toHour)
        {
            curDemand = demandSchedule[(int)(nhours+24-toHour)];
            OBJECTDATA(lights1, lights)->demand = curDemand;
            
            TIMESTAMP nextSyncTime = local_callbacks->myobject_sync(lights1, _time, PC_BOTTOMUP);
            if (nextSyncTime == TS_NEVER )
                _time += 3600 * TS_RESOLUTION * TS_SECOND;  //synch every fifteen minutes
            else
            {
                gl_output("lights:  Unit test failed.  Unexpected synch time encountered.\n");
                return;
            }

            expectedPower = curDemand * curPower/1000.0;
            gridlabPower = OBJECTDATA(lights1, lights)->power_kw.Mag();
            expectedHeatgain =  expectedPower * (nhours-lasthour) * BTUPHPKW;
            gridlabHeatgain = OBJECTDATA(lights1, lights)->internal_heat;

            gl_output("%5.1lf   %10.2lf    %10.2lf    %10.2lf    %10.2lf", 
                (nhours+24-toHour), expectedPower, gridlabPower, expectedHeatgain, gridlabHeatgain);
            
            lasthour = nhours;
            nhours = gl_tohours(_time);
        }
    }

    void clotheswasher_test() {
        gl_output("\n\nClotheswasher Unit Tests");
        gl_output("======================");
        OBJECT *house1 = house_create();
        OBJECTDATA(house1, house)->create();

        OBJECT *clotheswasher1 = clotheswasher_create();
        OBJECTDATA(clotheswasher1, clotheswasher)->create();
        gl_set_parent(clotheswasher1, house1);
        CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
        CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
        
        double curPower = 2000.0, curDemand = 0.0, curHeatFraction = 0.5;
        OBJECTDATA(clotheswasher1, clotheswasher)->heat_fraction = curHeatFraction;
        OBJECTDATA(clotheswasher1, clotheswasher)->demand = curDemand;
        OBJECTDATA(clotheswasher1, clotheswasher)->installed_power = curPower;
        double demandSchedule[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.};

        TIMESTAMP _time = gl_parsetime("2000-08-01 0:0:0 GMT");;
        house1->clock = _time;

        double nhours, lasthour;
        nhours = gl_tohours(_time);
        double toHour = nhours + 24;
        lasthour = nhours;
        double expectedPower, gridlabPower, expectedHeatgain, gridlabHeatgain;

        gl_output("\n            Expected      Gridlab       Expected        Gridlab"); 
        gl_output(  "   Hour     power_kw      power_kw      heatgain        heatgain"); 

        while (nhours < toHour)
        {
            curDemand = demandSchedule[(int)(nhours+24-toHour)];
            OBJECTDATA(clotheswasher1, clotheswasher)->demand = curDemand;

            TIMESTAMP nextSyncTime = local_callbacks->myobject_sync(clotheswasher1, _time, PC_BOTTOMUP);
            if (nextSyncTime == TS_NEVER )
                _time += 3600 * TS_RESOLUTION * TS_SECOND;  //synch every fifteen minutes
            else
            {
                gl_output("clotheswasher:  Unit test failed.  Unexpected synch time encountered.\n");
                return;
            }

            expectedPower = curDemand * curPower/1000.0;
            gridlabPower = OBJECTDATA(clotheswasher1, clotheswasher)->power_kw.Mag();
            expectedHeatgain =  expectedPower * curHeatFraction * (nhours-lasthour) * BTUPHPKW;
            gridlabHeatgain = OBJECTDATA(clotheswasher1, clotheswasher)->internal_heat;

            gl_output("%5.1lf   %10.2lf    %10.2lf    %10.2lf    %10.2lf", 
                (nhours+24-toHour), expectedPower, gridlabPower, expectedHeatgain, gridlabHeatgain);
            
            lasthour = nhours;
            nhours = gl_tohours(_time);
        }
    }

    void house_test() {
        gl_output("\n\nHouse Unit Tests");
        gl_output("======================\n");
        OBJECT *house1 = house_create();
        OBJECTDATA(house1, house)->create();
        house1->latitude = 38.0;

        OBJECTDATA(house1, house)->floor_area = 2500.0;
        OBJECTDATA(house1, house)->Tair = 74.0;
        OBJECTDATA(house1, house)->airchange_per_hour = 5;
        OBJECTDATA(house1, house)->thermostat_deadband = 1.0;
        OBJECTDATA(house1, house)->heating_setpoint = 70.0;
        OBJECTDATA(house1, house)->cooling_setpoint = 74.0;
        OBJECTDATA(house1, house)->envelope_UA = 437.5;

        OBJECTDATA(house1, house)->air_density = 0.0735;
        OBJECTDATA(house1, house)->air_mass = 1470.0;
        OBJECTDATA(house1, house)->air_heat_capacity = 0.2402;
        OBJECTDATA(house1, house)->air_thermal_mass = 353.094;
        OBJECTDATA(house1, house)->house_content_heat_transfer_coeff = 1875.0;
        OBJECTDATA(house1, house)->COP_coeff = 1.0;
        OBJECTDATA(house1, house)->heat_cool_mode = house::OFF;
        OBJECTDATA(house1, house)->Tmaterials = 74.0;
        OBJECTDATA(house1, house)->design_cooling_capacity = 18.0;
        OBJECTDATA(house1, house)->design_heating_capacity = 18.0;
        OBJECTDATA(house1, house)->cooling_COP = 3.0;
        OBJECTDATA(house1, house)->heating_COP = 1.0;

        // Now we call init on the objects
        CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
        CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);

        // set climate object variables
        static double tout=95.0, rhout=0.75, solar[8] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
        OBJECTDATA(house1, house)->pTout = &tout;
        OBJECTDATA(house1, house)->pRhout = &rhout;
        OBJECTDATA(house1, house)->pSolar = &solar[1];

        // run the tests
        TIMESTAMP _time = gl_parsetime("2000-08-01 0:0:0 GMT");;
        double Tout_test[24] = {80, 77, 74, 70, 70, 70, 70, 73, 76, 79, 80, 80, 81, 80, 79, 78, 76, 75, 73, 70, 68, 66, 65, 65};

        house1->clock = _time;

        double nhours;
        nhours = gl_tohours(_time);
        double startTime = nhours;
        double toHour = nhours + 24;
        FILE *fp = fopen("house_test.csv", "w");
        double Tout, Tair, hvac_load;
        house::HCMODE unit_status;
        fprintf(fp, "Time stamp, Tout, Tair, Hvac_load (Btu/hr), unit_status(0=heat, 1=cool)\n");

        while (nhours <= toHour)
        {
            OBJECTDATA(house1, house)->thermostat(house1->clock, _time);
            OBJECTDATA(house1, house)->pTout = &(Tout_test[(int)(nhours+24-toHour)]);
            local_callbacks->myobject_sync(house1, _time, PC_PRETOPDOWN);
            TIMESTAMP nextSyncTime = local_callbacks->myobject_sync(house1, _time, PC_BOTTOMUP);
            TIMESTAMP simTime = _time + 900 * TS_RESOLUTION * TS_SECOND;  //synch every fifteen minutes
            
            // step to next hour unless hvac_load_sync needs to synch sooner
            if (nextSyncTime == TS_NEVER || nextSyncTime > simTime)
                _time = simTime;
            else
                _time = nextSyncTime;

            nhours = gl_tohours(_time);
            Tout = *(double *)(OBJECTDATA(house1, house)->pTout);
            Tair = OBJECTDATA(house1, house)->Tair;
            hvac_load = OBJECTDATA(house1, house)->hvac_kWh_use;
            unit_status = OBJECTDATA(house1, house)->heat_cool_mode;
            fprintf(fp, "%.2f, %.2lf, %.2lf, %.3lf, %d\n", nhours-startTime, Tout, Tair, hvac_load, (int)unit_status);
        }

    }
    
    void waterheater_test()
    {
        gl_output("\n\nWaterheater Unit Tests");
        gl_output("======================\n");
        OBJECT *house1 = house_create();
        OBJECTDATA(house1, house)->create();

        OBJECT* waterheater1;
        CLASS *cl = get_class_by_name("waterheater");
        waterheater1 = gl_create_object(cl,sizeof(waterheater));
        CPPUNIT_ASSERT(waterheater1 != NULL);
        OBJECTDATA(waterheater1, waterheater)->create();
        gl_set_parent(waterheater1, house1);

        // Water tank properties for unit test
        //  tank volume = 50 gallons
        //  tank diameter = 1.5 ft
        //  tank UA = 2.0
        //  heating element = 4500 W
        //  tank location = inside the house

        OBJECTDATA(waterheater1, waterheater)->tank_volume = 50.0;
        OBJECTDATA(waterheater1, waterheater)->tank_diameter = 1.5;
        OBJECTDATA(waterheater1, waterheater)->tank_UA = 2;
        OBJECTDATA(waterheater1, waterheater)->heating_element_capacity = 4500.0;
        OBJECTDATA(waterheater1, waterheater)->location = waterheater::INSIDE;

        CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
        CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);

        // call sync to set derived properties and sync the object clock and simulation clock
        TIMESTAMP _time = gl_parsetime("2000-08-01 0:0:0 GMT");;
        waterheater1->clock = _time;
        TIMESTAMP nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);

        double nhours;

        // Test 1:  Time to decay from 140 degF to 120 F
        OBJECTDATA(waterheater1, waterheater)->tank_setpoint = 130.0;
        OBJECTDATA(waterheater1, waterheater)->thermostat_deadband = 20.0;
        OBJECTDATA(waterheater1, waterheater)->Tw = 140.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("\nTest 1:  Time to decay from 140 degF to 120 F");
        gl_output("Expected value :  72.641 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 2:  Time to simple recovery from 110 degF to 135 F
        OBJECTDATA(waterheater1, waterheater)->tank_setpoint = 130.0;
        OBJECTDATA(waterheater1, waterheater)->thermostat_deadband = 10.0;
        OBJECTDATA(waterheater1, waterheater)->Tw = 110.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 2:  Time to simple recovery from 110 degF to 135 F");
        gl_output("Expected value :  0.683 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 3:  Time to simple recovery from 120 degF to 135 F
        OBJECTDATA(waterheater1, waterheater)->Tw = 120.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 3:  Time to simple recovery from 120 degF to 135 F");
        gl_output("Expected value :  0.410 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 4:  Time to simple recovery from 124 degF to 135 F
        OBJECTDATA(waterheater1, waterheater)->Tw = 124.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 4:  Time to simple recovery from 124 degF to 135 F");
        gl_output("Expected value :  0.301 hours\nGridlabD output:  %.3lf hours\n", nhours);

        OBJECTDATA(waterheater1, waterheater)->tank_setpoint = 125.0;
        OBJECTDATA(waterheater1, waterheater)->thermostat_deadband = 10.0;
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;

        // Test 5:  Time to depletion at 2.5 gpm 130 degF to 125 F
        OBJECTDATA(waterheater1, waterheater)->water_demand = 2.5;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 2.5;
        OBJECTDATA(waterheater1, waterheater)->h = OBJECTDATA(waterheater1, waterheater)->height;
        OBJECTDATA(waterheater1, waterheater)->set_current_model_and_load_state();
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 5:  Time to depletion at 2.5 gpm from 130 degF");
        gl_output("Expected value :  0.405 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 6:  Time to depletion at 0.4445 gpm 130 degF to 125 F
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;
        OBJECTDATA(waterheater1, waterheater)->water_demand = 0.4445;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 0.445;
        OBJECTDATA(waterheater1, waterheater)->set_current_model_and_load_state();
        OBJECTDATA(waterheater1, waterheater)->h = OBJECTDATA(waterheater1, waterheater)->height;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 6:  Time to depletion at 0.445 gpm from 130 degF");
        gl_output("Expected value :  263.787 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 7:  Time to depletion at 0.3 gpm 130 degF to 125 F
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;
        OBJECTDATA(waterheater1, waterheater)->water_demand = 0.3;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 0.3;
        OBJECTDATA(waterheater1, waterheater)->h = OBJECTDATA(waterheater1, waterheater)->height;
        OBJECTDATA(waterheater1, waterheater)->set_current_model_and_load_state();
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 7:  Time to depletion at 0.3 gpm from 130 degF");
        gl_output("Expected value :  -5.91 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 8:  Time to recovery at 2.5 gpm to 130 degF
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;
        OBJECTDATA(waterheater1, waterheater)->water_demand = 2.5;
        OBJECTDATA(waterheater1, waterheater)->cur_water_demand = 2.5;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 2.5;
        OBJECTDATA(waterheater1, waterheater)->h = 0.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 8:  Time to recovery at 2.5 gpm 130 degF to 125 F");
        gl_output("Expected value :  -0.404 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 9:  Time to recovery at 0.435 gpm to 130 degF
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;
        OBJECTDATA(waterheater1, waterheater)->water_demand = 0.435;
        OBJECTDATA(waterheater1, waterheater)->cur_water_demand = 0.435;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 0.435;
        OBJECTDATA(waterheater1, waterheater)->h = 0.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 9:  Time to recovery at 0.435 gpm to  130 degF");
        gl_output("Expected value :  146.227 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 10:  Time to recovery at 0.2 gpm to 130 degF
        OBJECTDATA(waterheater1, waterheater)->water_demand = 0.2;
        OBJECTDATA(waterheater1, waterheater)->cur_water_demand = 0.2;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 0.2;
        OBJECTDATA(waterheater1, waterheater)->h = 0.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 10:  Time to recovery at 0.2 gpm 130 degF to 120 F");
        gl_output("Expected value :  3.459 hours\nGridlabD output:  %.3lf hours\n", nhours);

        // Test 11:  Time to recovery at 0.0 gpm to 130 degF
        OBJECTDATA(waterheater1, waterheater)->Tw = 130.0;
        OBJECTDATA(waterheater1, waterheater)->water_demand = 0.0;
        OBJECTDATA(waterheater1, waterheater)->cur_water_demand = 0.0;
        OBJECTDATA(waterheater1, waterheater)->last_water_demand = 0.0;
        OBJECTDATA(waterheater1, waterheater)->h = 0.0;
        nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
        nhours = gl_tohours(nextSyncTime) - gl_tohours(_time);
        gl_output("Test 11:  Time to recovery at 0.0 gpm to 130 degF ");
        gl_output("Expected value :  1.890 hours\nGridlabD output:  %.3lf hours\n", nhours);

        _time = gl_parsetime("2000-08-01 0:0:0 GMT");;
        house1->clock = _time;
        double water_demand[24] = {0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 5.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 0.0, 0.0, 0.0};
        OBJECTDATA(waterheater1, waterheater)->tank_setpoint = 130.0;
        OBJECTDATA(waterheater1, waterheater)->thermostat_deadband = 20.0;
        OBJECTDATA(waterheater1, waterheater)->Tw = 140.0;
        OBJECTDATA(waterheater1, waterheater)->h = OBJECTDATA(waterheater1, waterheater)->height;

        OBJECTDATA(waterheater1, waterheater)->heat_needed = FALSE;  //reset for the full day test
        nhours = gl_tohours(_time);
        double toHour = nhours + 24;
        double lasthour = nhours, nextSynchours = 0.0;
        gl_output("Hour      power(kW)   flowrate(gpm)    h(ft)      Tw   next synchtime");

        double waterheaterPower = 0.0;
        while (nhours <= toHour)
        {
            OBJECTDATA(waterheater1, waterheater)->water_demand = water_demand[(int)(nhours-toHour+24)];
            nextSyncTime = local_callbacks->myobject_sync(waterheater1, _time, PC_BOTTOMUP);
            nextSynchours = gl_tohours(nextSyncTime) - gl_tohours(_time);
            
            if (nextSyncTime == TS_NEVER || (nextSynchours > 1))
                _time += 3600 * TS_RESOLUTION * TS_SECOND;  //synch every fifteen minutes
            else
                _time = nextSyncTime;

            waterheaterPower = OBJECTDATA(waterheater1, waterheater)->power_kw.Mag();

            gl_output("%5.2lf, %10.2lf, %15.2lf, %7.2lf, %8.2lf, %8.2lf hrs", 
                (nhours-toHour+24), waterheaterPower, water_demand[(int)(nhours-toHour+24)], OBJECTDATA(waterheater1, waterheater)->h, OBJECTDATA(waterheater1, waterheater)->Tw, nextSynchours);
            lasthour = nhours;
            nhours = gl_tohours(_time);
        }
}

    /*
     * This section creates the suite() method that will be used by the
     * CPPUnit testrunner to execute the tests that we have registered.
     * This section needs to be in the .h file
     */
    CPPUNIT_TEST_SUITE(residential_test);
    /*
     * For each test method defined above, we should have a separate
     * CPPUNIT_TEST() line.
     */
    CPPUNIT_TEST(house_test);
    CPPUNIT_TEST(waterheater_test);
    CPPUNIT_TEST(lights_test);
    CPPUNIT_TEST(clotheswasher_test);

    CPPUNIT_TEST_SUITE_END();

    
};

/*
 * Registers the test suite with the CPPUnit registration factory.  In most
 * cases, this is all that is required for it to be included and run by the
 * module_test method in test.cpp.
 */
CPPUNIT_TEST_SUITE_REGISTRATION(residential_test);

#endif

---

GridLAB-D^TM Version 1.0

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