residential/house_e.h

Go to the documentation of this file.

#ifndef _HOUSE_E_H
#define _HOUSE_E_H

#include "residential.h"
#include "complex.h"
#include "enduse.h"
#include "loadshape.h"
#include "residential_enduse.h"

typedef struct s_implicit_enduse {
    enduse load;
    double amps;
    int is220;
    struct s_implicit_enduse *next;
} IMPLICITENDUSE;

typedef enum {
    // analog loads (continuous load) - bits 0-15
    IEU_LIGHTS          = 0x00000001, 
    IEU_PLUGS           = 0x00000002, 
    IEU_OCCUPANCY       = 0x00000004, 
    
    // pulsed loads (unqueued aperiodic loads) - bits 16-31
    IEU_DISHWASHER      = 0x00000100, 
    IEU_MICROWAVE       = 0x00000200, 

    // modulated loads (periodic loads) - bits 32-47
    IEU_FREEZER         = 0x00010000, 
    IEU_REFRIGERATOR    = 0x00020000, 
    IEU_RANGE           = 0x00040000, 
    IEU_EVCHARGER       = 0x00080000, 
    IEU_WATERHEATER     = 0x00100000, 

    // queued loads (queued aperiodic loads) - bits 48-63
    IEU_CLOTHESWASHER   = 0x01000000, 
    IEU_DRYER           = 0x02000000, 

    IEU_ALL             = 0x03170303, 
} IMPLICITENDUSEFLAGS; 

typedef enum {
    IES_ELCAP1990   = 0,    
    IES_ELCAP2010   = 1,    
    IES_RBSA2014    = 2,    
} IMPLICITENDUSESOURCE; 

//Solar quadrant definitions
#define NO_SOLAR    0x0000
#define HORIZONTAL  0x0001
#define NORTH       0x0002
#define EAST        0x0004
#define SOUTH       0x0008
#define WEST        0x0010

EXPORT SIMULATIONMODE interupdate_house_e(OBJECT *obj, unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val);
EXPORT STATUS postupdate_house_e(OBJECT *obj);

class house_e : public residential_enduse { /*inherits due to HVAC being a load */
public:
    object weather; 
    PANEL panel; 


    IMPLICITENDUSE *implicit_enduse_list;   
    static set implicit_enduses_active;     
    static enumeration implicit_enduse_source; 
public:
    // building design variables
    double floor_area;                          
    double envelope_UA;                         
    double number_of_doors;                     
    double area_per_door;                       
    double total_door_area;                     
    double total_wall_area;                     
    double gross_wall_area;                     
    double ceiling_height;                      
    double interior_exterior_wall_ratio;        
    double exterior_wall_fraction;              
    double exterior_ceiling_fraction;           
    double exterior_floor_fraction;
    double aspect_ratio;                        
    double solar_aperture[N_SOLAR_SURFACES];    
    double house_content_heat_transfer_coeff;   
    double air_density;                         
    double air_heat_capacity;                   
    double house_content_thermal_mass;          
    double total_thermal_mass_per_floor_area;   
    double interior_surface_heat_transfer_coeff;
    double air_heat_fraction;                   
    double mass_solar_gain_fraction;            
    double mass_internal_gain_fraction;     
    double number_of_stories;
    
    // additional reverse etp parameters
    set include_solar_quadrant;
    typedef enum {HC_DEFAULT=0, HC_FLAT=1, HC_LINEAR=2, HC_CURVED=3};
    enumeration heating_cop_curve;
    typedef enum {HP_DEFAULT=0, HP_FLAT=1, HP_LINEAR=2, HP_CURVED=3};
    enumeration heating_cap_curve;
    typedef enum {CC_DEFAULT=0, CC_FLAT=1, CC_LINEAR=2, CC_CURVED=3};
    enumeration cooling_cop_curve;
    typedef enum {CP_DEFAULT=0, CP_FLAT=1, CP_LINEAR=2, CP_CURVED=3};
    enumeration cooling_cap_curve;
    bool use_latent_heat;
    bool include_fan_heatgain;
    double fan_heatgain_fraction;
    double horizontal_diffuse_solar_radiation;
    double north_incident_solar_radiation;
    double north_west_incident_solar_radiation;
    double west_incident_solar_radiation;
    double south_west_incident_solar_radiation;
    double south_incident_solar_radiation;
    double south_east_incident_solar_radiation;
    double east_incident_solar_radiation;
    double north_east_incident_solar_radiation;

    // window variables
    double glazing_shgc;                        
    double window_wall_ratio;                   
    double window_roof_ratio;                   
    double total_window_area;
    double window_exterior_transmission_coefficient; 
    double solar_heatgain_factor;               

    /* Simulated window openings */
    bool window_openings;       // Activate this mode...by default, not activated
    double window_open;         // Tracks the state of the window
    double window_low_temp;     // Low temperature cutoff
    double window_high_temp;    // High temperature cutoff
    double window_a;            // quadratic coefficient for function between low and high cutoffs
    double window_b;            // linear coefficient for function between low and high cutoffs
    double window_c;            // constant coefficient for function between low and high cutoffs
    double window_temp_delta;   // difference in outdoor temperature that triggers a re-calculation of the model
    double last_temperature;    // last temperature of a state change
    int window_first_time_through; // determine if this is the first time through the model or not

    // system design variables
    // thermostat
    double thermostat_deadband;     
    int16 thermostat_cycle_time;    
    int16 thermostat_off_cycle_time; 
    int16 thermostat_on_cycle_time; 
    TIMESTAMP thermostat_last_cycle_time;
    TIMESTAMP thermostat_last_off_cycle_time;
    TIMESTAMP thermostat_last_on_cycle_time;
    double heating_setpoint;        
    double cooling_setpoint;        
    double dlc_offset;

    // hvac control variable
    typedef enum {TC_FULL=0, TC_BAND=1, TC_NONE=2};
    enumeration thermostat_control; 
    double TcoolOn;     
    double TcoolOff;    
    double TheatOn;     
    double TheatOff;    
    double TauxOn;      

    // hvac characteristics
    double design_heating_setpoint; 
    double design_cooling_setpoint; 
    double design_heating_capacity; 
    double design_cooling_capacity; 
    double heating_COP;             
    double cooling_COP;             

    double over_sizing_factor;      
    double rated_heating_capacity;  
    double rated_cooling_capacity;  
    double hvac_breaker_rating;     
    double hvac_power_factor;       
    // auxiliary heat characteristics
    double aux_heat_capacity;       
    double aux_heat_deadband;       
    double aux_heat_temp_lockout;   
    double aux_heat_time_delay;     
    // fan characteristics
    double fan_design_power;        
    double fan_low_power_fraction;  
    double fan_power;               
    double fan_design_airflow;      

    double fan_impedance_fraction;  
    double fan_current_fraction;    
    double fan_power_fraction;      
    double fan_power_factor;        

    double duct_pressure_drop;      
    double cooling_supply_air_temp;
    double heating_supply_air_temp;
    // building HVAC effects
    double airchange_per_hour;      
    double airchange_UA;            
    double UA;                      
    double latent_load_fraction;    
    
    // current hvac properties
    double system_rated_power;      
    double system_rated_capacity;   
    complex hvac_power;             

    /* inherited res_enduse::load is hvac system load */
    double hvac_load;
    double total_load;
    enduse total; /* total load */
    double heating_demand;
    double cooling_demand;
    double last_heating_load; 
    double last_cooling_load; 
    bool    compressor_on;
    int64   compressor_count;
    
    /* cycle tracking values */
    TIMESTAMP hvac_last_on;
    TIMESTAMP hvac_last_off;
    double hvac_period_on;
    double hvac_period_off;
    double hvac_period_length; // minutes
    double hvac_duty_cycle;

    /* Energy Storage Variable */
    bool thermal_storage_present;       //Indication of if thermal storage is present and available for drawing
    bool thermal_storage_inuse;     //Flag to indicate thermal storage is being pulled at the moment

    typedef enum {
        ST_NONE = 0x00000000,   
        ST_GAS  = 0x00000001,   
        ST_AC   = 0x00000002,   
        ST_AIR  = 0x00000004,   
        ST_VAR  = 0x00000008,   
        ST_RST  = 0x00000010,   
    } SYSTEMTYPE; 
    set system_type;
    /* obsolete? -MH */

    typedef enum  {
        AX_NONE = 0x0,
        AX_DEADBAND = 0x1,
        AX_TIMER = 0x2,
        AX_LOCKOUT = 0x4,
    } AUXSTRATEGY;
    set auxiliary_strategy;

    typedef enum{
        AT_UNKNOWN = 0,
        AT_NONE = 1,
        AT_ELECTRIC = 2,
    } AUXILIARYSYSTEMTYPE;
    enumeration auxiliary_system_type;

    typedef enum{
        HT_UNKNOWN = 0,
        HT_NONE = 1,
        HT_GAS = 2,
        HT_HEAT_PUMP = 3,
        HT_RESISTANCE = 4,
    } HEATSYSTEMTYPE;
    enumeration heating_system_type;

    typedef enum {
        CT_UNKNOWN = 0,
        CT_NONE = 1,
        CT_ELECTRIC = 2,
    } COOLSYSTEMTYPE;
    enumeration cooling_system_type;

    typedef enum {
        FT_UNKNOWN = 0,
        FT_NONE = 1,
        FT_ONE_SPEED = 2,
        FT_TWO_SPEED = 3,
    } FANTYPE;
    enumeration fan_type;

    typedef enum {
        GM_OTHER = 0,
        GM_GLASS = 1,
        GM_LOW_E_GLASS = 2,
    } GLASSTYPE;
    enumeration glass_type;

    typedef enum {
        WF_NONE = 0,
        WF_ALUMINUM = 1,
        WF_THERMAL_BREAK = 2,
        WF_WOOD = 3,
        WF_INSULATED = 4,
    } WINDOWFRAME;
    enumeration window_frame;

    typedef enum {
        GT_OTHER = 0,
        GT_CLEAR = 1,
        GT_ABS = 2,
        GT_REFL = 3,
        GT_LOW_S = 4,
        GT_HIGH_S = 5,
    } GLAZINGTREATMENT;
    enumeration glazing_treatment;

    typedef enum {
        GL_ONE=1,
        GL_TWO=2,
        GL_THREE=3,
        GL_OTHER,
    } GLAZINGLAYERS;
    enumeration glazing_layers;

    typedef enum {              
        TI_VERY_LITTLE  =0,     
        TI_LITTLE       =1,     
        TI_BELOW_NORMAL =2,     
        TI_NORMAL       =3,     
        TI_ABOVE_NORMAL =4,     
        TI_GOOD         =5,     
        TI_VERY_GOOD    =6,
        TI_UNKNOWN      =7
    } THERMAL_INTEGRITY;
    enumeration thermal_integrity_level;

    typedef enum {
        MM_NONE     = 0,        
        MM_BASIC    = 1,        
        MM_FULL     = 2         
    } MOTORMODEL;               
    enumeration motor_model;

    // Motor variables and enumerations
    double hvac_motor_efficiency;   
    double hvac_motor_loss_power_factor; 
    double hvac_motor_real_loss;         
    double hvac_motor_reactive_loss;     
    typedef enum {
        ME_VERY_POOR    = 0,    
        ME_POOR         = 1,    
        ME_AVERAGE      = 2,
        ME_GOOD         = 3,
        ME_VERY_GOOD    = 4,
    } MOTOREFFICIENCY;
    enumeration motor_efficiency;

    typedef enum {  
        SM_UNKNOWN  =0,             
        SM_OFF      =1,             
        SM_HEAT     =2,             
        SM_AUX      =3,             
        SM_COOL     =4,             
    } SYSTEMMODE;                   
    enumeration system_mode,            
        last_system_mode;
    int64 last_mode_timer;

    // derived/calculated variables
    double volume;                  
    double air_mass;                
    double air_thermal_mass;        
    double solar_load;              
    //Qs reads in data that is assumed to be in W/sf and
    //converts the data into Btu/hr.
    //please note that the product of 
    //gross_wall_area*window_wall_ratio*glazing_shgc*window_exterior_transmission_coefficient should be the
    //same as the equivalent solar aperature located in Rob Pratt's ETP Excel spreadsheet.
    double cooling_design_temperature;
    double heating_design_temperature;
    double design_peak_solar;
    double design_internal_gains;
    double design_internal_gain_density;

    double Rroof;
    double Rwall;
    double Rfloor;
    double Rwindows;
    double Rdoors;

    double incident_solar_radiation;

    double Tair;
    double Tmaterials;
    double outside_temperature;
    double outdoor_rh;

    double is_AUX_on,is_HEAT_on,is_COOL_on; // A logic statement so that the population dynamics of the AC can be observed with collectors.

    typedef enum {
        TM_OFF = 0,
        TM_AUTO = 1,
        TM_HEAT = 2,
        TM_COOL = 3,
    }THERMOSTATMODE;
    enumeration thermostat_mode;

private:
    TIMESTAMP simulation_beginning_time;
    void set_thermal_integrity();
    void set_window_shgc();
    void set_window_Rvalue();
    // internal variables used to track state of house */
    double dTair;
    double a,b,c,d,c1,c2,A3,A4,k1,k2,r1,r2,Teq,Tevent,Qi,Qa,Qm,adj_cooling_cap,adj_heating_cap,adj_cooling_cop,adj_heating_cop;
    double Qlatent;
    static bool warn_control;
    static double warn_low_temp;
    static double warn_high_temp;
    static double system_dwell_time; // time interval at which hvac checks its state (approximates true dwell time)
    bool check_start;
    bool heat_start;

    bool deltamode_inclusive;   //Boolean for deltamode calls - pulled from object flags
    bool deltamode_registered;  //Boolean for deltamode registration -- basically a "first run" flag
    bool proper_meter_parent;       //Flag to see if powerflow interactions should occur
    bool proper_climate_found;      //Flag to see if climate interactions should occur

    //Pointers for powerflow properties
    gld_property *pCircuit_V[3];                    
    gld_property *pLine_I[3];                       
    gld_property *pShunt[3];                        
    gld_property *pPower[3];                        
    gld_property *pMeterStatus;                     
    gld_property *pFrequency;                       

    //Default or "connecting point" values for powerflow interactions
    complex value_Circuit_V[3];                 
    complex value_Line_I[3];                    
    complex value_Shunt[3];                     
    complex value_Power[3];                     
    enumeration value_MeterStatus;              
    double value_Frequency;                     

    //Pointers for climate properties
    gld_property *pTout;        // pointer to outdoor temperature (see climate)
    gld_property *pRhout;       // pointer to outdoor humidity (see climate)
    gld_property *pSolar[9];    // pointer to solar radiation array (see climate)

    //Values for the weather information
    double value_Tout;          //< Value holder for outside temperature
    double value_Rhout;         //< Value holder for relative humidity
    double value_Solar[9];      //< Value holder for solar irradiance

public:
    int error_flag;
    static CLASS *oclass, *pclass;
    house_e( MODULE *module);
    ~house_e();

    int create();
    TIMESTAMP presync(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP sync(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP postsync(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP sync_billing(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP sync_thermostat(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP sync_panel(TIMESTAMP t0, TIMESTAMP t1);
    TIMESTAMP sync_enduses(TIMESTAMP t0, TIMESTAMP t1);
    void update_system(double dt=0);
    void update_model(double dt=0);
    void check_controls(void);
    void update_Tevent(void);

    int init(OBJECT *parent);
    int init_climate(void);
    int isa(char *classname);

    CIRCUIT *attach(OBJECT *obj, double limit, int is220=false, enduse *pEnduse=NULL);
    void attach_implicit_enduses(void);

    SIMULATIONMODE inter_deltaupdate(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val);
    STATUS post_deltaupdate(void);

// access methods
public:
    //Map function
    gld_property *map_complex_value(OBJECT *obj, char *name);
    gld_property *map_double_value(OBJECT *obj, char *name);
    void pull_complex_powerflow_values(void);
    void pull_climate_values(void);
    void push_complex_powerflow_values(void);
};

#endif

---

GridLAB-D™ Version 4.1

An open-source smart grid simulator created by PNNL for the US Department of Energy Office of Electricity