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;

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


    inline complex V(CIRCUIT *c)            
    { return c->status==BRK_CLOSED ? *(c->pV) : complex(0,0);};
    complex *pCircuit_V;                    
    complex *pLine_I;                       
    complex *pShunt;                        
    complex *pPower;                        
    bool *pHouseConn;                       
    IMPLICITENDUSE *implicit_enduse_list;   
    static set implicit_enduses_active;     
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;

    // 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;               

    // system design variables
    // thermostat
    double thermostat_deadband;     
    int16 thermostat_cycle_time;    
    TIMESTAMP thermostat_last_cycle_time;
    double heating_setpoint;        
    double cooling_setpoint;        

    // hvac control variable
    enum {TC_FULL=0, TC_BAND=1, TC_NONE=2} 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 latent_load_fraction;    
    
    // current hvac properties
    double system_rated_power;      
    double system_rated_capacity;   

    /* inherited res_enduse::load is hvac system load */
    double hvac_load;
    double total_load;
    enduse total; /* total load */
    double heating_demand;
    double cooling_demand;


    typedef enum {
        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;
    AUXILIARYSYSTEMTYPE auxiliary_system_type;

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

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

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

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

    typedef enum {
        WF_NONE = 0,
        WF_ALUMINUM = 1,
        WF_THERMAL_BREAK = 2,
        WF_WOOD = 3,
        WF_INSULATED = 4,
    } WINDOWFRAME;
    WINDOWFRAME 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;
    GLAZINGTREATMENT glazing_treatment;

    typedef enum {
        GL_ONE=1,
        GL_TWO=2,
        GL_THREE=3,
        GL_OTHER,
    } GLAZINGLAYERS;
    GLAZINGLAYERS 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;
    THERMAL_INTEGRITY thermal_integrity_level;

    typedef enum {
        MM_NONE     = 0,        
        MM_BASIC    = 1,        
        MM_FULL     = 2         
    } MOTORMODEL;               
    MOTORMODEL 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;
    MOTOREFFICIENCY motor_efficiency;

    typedef enum {  
        SM_UNKNOWN  =0,             
        SM_OFF      =1,             
        SM_HEAT     =2,             
        SM_AUX      =3,             
        SM_COOL     =4,             
    } SYSTEMMODE;                   
    SYSTEMMODE 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 *pTout;  // pointer to outdoor temperature (see climate)
    double *pRhout; // pointer to outdoor humidity (see climate)
    double *pSolar; // pointer to solar radiation array (see climate)
    double incident_solar_radiation;

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

private:
    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,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;
#ifdef _DEBUG
    double d;
#endif
    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 *NR_mode;          //Toggle for NR soling cycle.  If not NR, just goes to false
    TIMESTAMP Off_Return;   //Return time for the accumulation cycle in NR

    complex load_values[3][3];  //Power, Current, and impedance (admittance) load accumulators for NR solving method

public:
    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);

// access methods
public:
    inline double get_floor_area () { return floor_area; };
    inline double get_Tout () { return *pTout; };
    inline double get_Tair () { return Tair; };

    complex *get_complex(OBJECT *obj, char *name);
    bool *get_bool(OBJECT *obj, char *name);
};

inline double sgn(double x) 
{
    if (x<0) return -1;
    if (x>0) return 1;
    return 0;
}

#endif

---

GridLAB-D^TM Version 2.0

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