Module: BTAP

Defined in:

lib/openstudio-standards/btap/btap.rb,
lib/openstudio-standards/btap/mpc.rb,
lib/openstudio-standards/btap/equest.rb,
lib/openstudio-standards/btap/fileio.rb,
lib/openstudio-standards/btap/analysis.rb,
lib/openstudio-standards/btap/envelope.rb,
lib/openstudio-standards/btap/geometry.rb,
lib/openstudio-standards/btap/measures.rb,
lib/openstudio-standards/btap/economics.rb,
lib/openstudio-standards/btap/reporting.rb,
lib/openstudio-standards/btap/schedules.rb,
lib/openstudio-standards/btap/compliance.rb,
lib/openstudio-standards/btap/simmanager.rb,
lib/openstudio-standards/btap/spaceloads.rb,
lib/openstudio-standards/btap/spacetypes.rb,
lib/openstudio-standards/btap/btap_result.rb,
lib/openstudio-standards/btap/visualization.rb,
lib/openstudio-standards/weather/Weather.Model.rb

Overview

This module has been created to make it easier to manipulate weather files can contains region specific data.

Defined Under Namespace

Modules: Analysis, Common, Compliance, EQuest, Environment, FileIO, Geometry, MPC, Measures, Reporting, Reports, Resources, SimManager, SimulationSettings, Site, Visualization Classes: OpenStudioLibrary

Constant Summary

ENERGY_PLUS_MAJOR_VERSION =

EnergyPlus version

8

ENERGY_PLUS_MINOR_VERSION =

3

OS_RUBY_PATH =

Path constants

File.expand_path("..\\..\\..", __FILE__)

TESTING_FOLDER =

"C:\\test"

Class Method Summary

• .gut_building(model) ⇒ Object
• .perform_qaqc(model) ⇒ Object
• .runner_register(type, text, runner = nil) ⇒ Object

  A wrapper for outputing feedback to users and developers.

• .runner_register_value(name, value, runner = nil) ⇒ Object

Class Method Details

.gut_building(model) ⇒ Object

# File 'lib/openstudio-standards/btap/btap.rb', line 154

def self.gut_building(model)
  #clean up any remaining items that we don't need for NECB.
  puts "Removing casual loads."
  BTAP::Resources::SpaceLoads::remove_all_casual_loads(model)
  puts "Removing space loads."
  BTAP::Resources::SpaceLoads::remove_all_SpaceLoads(model)
  puts "Removing OA loads."
  BTAP::Resources::SpaceLoads::remove_all_DesignSpecificationOutdoorAir(model)
  puts "Removing Envelope"
  BTAP::Resources::Envelope::remove_all_envelope_information(model)
  puts "Removing Infiltration"
  BTAP::Resources::SpaceLoads::remove_all_SpaceInfiltrationDesignFlowRate(model)
  puts "Removing all Schedules"
  BTAP::Resources::Schedules::remove_all_schedules( model )
  puts "Removing HVAC"
  BTAP::Resources::HVAC.clear_all_hvac_from_model( model )
end

.perform_qaqc(model) ⇒ Object

# File 'lib/openstudio-standards/btap/btap_result.rb', line 2

def self.perform_qaqc(model)
  surfaces = {}
  outdoor_surfaces = BTAP::Geometry::Surfaces::filter_by_boundary_condition(model.getSurfaces(), "Outdoors")
  outdoor_walls = BTAP::Geometry::Surfaces::filter_by_surface_types(outdoor_surfaces, "Wall")
  outdoor_roofs = BTAP::Geometry::Surfaces::filter_by_surface_types(outdoor_surfaces, "RoofCeiling")
  outdoor_floors = BTAP::Geometry::Surfaces::filter_by_surface_types(outdoor_surfaces, "Floor")
  outdoor_subsurfaces = BTAP::Geometry::Surfaces::get_subsurfaces_from_surfaces(outdoor_surfaces)

  ground_surfaces = BTAP::Geometry::Surfaces::filter_by_boundary_condition(model.getSurfaces(), "Ground")
  ground_walls = BTAP::Geometry::Surfaces::filter_by_surface_types(ground_surfaces, "Wall")
  ground_roofs = BTAP::Geometry::Surfaces::filter_by_surface_types(ground_surfaces, "RoofCeiling")
  ground_floors = BTAP::Geometry::Surfaces::filter_by_surface_types(ground_surfaces, "Floor")

  windows = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(outdoor_subsurfaces, ["FixedWindow" , "OperableWindow" ])
  skylights = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(outdoor_subsurfaces, ["Skylight", "TubularDaylightDiffuser","TubularDaylightDome" ])
  doors = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(outdoor_subsurfaces, ["Door" , "GlassDoor" ])
  overhead_doors = BTAP::Geometry::Surfaces::filter_subsurfaces_by_types(outdoor_subsurfaces, ["OverheadDoor" ])
  electric_peak = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM tabulardatawithstrings WHERE ReportName='EnergyMeters'" +
      " AND ReportForString='Entire Facility' AND TableName='Annual and Peak Values - Electricity' AND RowName='Electricity:Facility'" +
      " AND ColumnName='Electricity Maximum Value' AND Units='W'")
  natural_gas_peak = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM tabulardatawithstrings WHERE ReportName='EnergyMeters'" +
      " AND ReportForString='Entire Facility' AND TableName='Annual and Peak Values - Gas' AND RowName='Gas:Facility'" +
      " AND ColumnName='Gas Maximum Value' AND Units='W'")

  # Create hash to store all the collected data. 
  qaqc = {}
  error_warning=[]
  qaqc[:os_standards_revision] = OpenstudioStandards::git_revision
  qaqc[:os_standards_version] = OpenstudioStandards::VERSION
  # Store Building data. 
  qaqc[:building] = {}
  qaqc[:building][:name] = model.building.get.name.get
  qaqc[:building][:conditioned_floor_area_m2]=nil
  unless model.building.get.conditionedFloorArea().empty?
    qaqc[:building][:conditioned_floor_area_m2] = model.building.get.conditionedFloorArea().get 
  else
    error_warning <<  "model.building.get.conditionedFloorArea() is empty for #{model.building.get.name.get}"
  end
  qaqc[:building][:exterior_area_m2] = model.building.get.exteriorSurfaceArea() #m2
  qaqc[:building][:volume] = model.building.get.airVolume() #m3
  qaqc[:building][:number_of_stories] = model.getBuildingStorys.size
  # Store Geography Data
  qaqc[:geography] ={}
  qaqc[:geography][:hdd] = BTAP::Environment::WeatherFile.new( model.getWeatherFile.path.get.to_s ).hdd18
  qaqc[:geography][:cdd] = BTAP::Environment::WeatherFile.new( model.getWeatherFile.path.get.to_s ).cdd18
  qaqc[:geography][:climate_zone] = BTAP::Compliance::NECB2011::get_climate_zone_name(qaqc[:geography][:hdd])
  qaqc[:geography][:city] = model.getWeatherFile.city
  qaqc[:geography][:state_province_region] = model.getWeatherFile.stateProvinceRegion
  qaqc[:geography][:country] = model.getWeatherFile.country
  qaqc[:geography][:latitude] = model.getWeatherFile.latitude
  qaqc[:geography][:longitude] = model.getWeatherFile.longitude
  
  #Spacetype Breakdown
  qaqc[:spacetype_area_breakdown]={}
  model.getSpaceTypes.sort.each do |spaceType|
    next if spaceType.floorArea == 0

    # data for space type breakdown
    display = spaceType.name.get
    floor_area_si = 0
    # loop through spaces so I can skip if not included in floor area
    spaceType.spaces.sort.each do |space|
      next if not space.partofTotalFloorArea
      floor_area_si += space.floorArea * space.multiplier
    end
    qaqc[:spacetype_area_breakdown][spaceType.name.get.gsub(/\s+/, "_").downcase.to_sym] = floor_area_si
  end
  
  
  
  #Economics Section
  qaqc[:economics] = {}
  costing_rownames = model.sqlFile().get().execAndReturnVectorOfString("SELECT RowName FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost'")
  #==> ["Electricity", "Natural Gas", "Additional", "Total"]
  costing_rownames = validate_optional(costing_rownames, model, "N/A")
  unless costing_rownames == "N/A"
    costing_rownames.each do |rowname|
      case rowname
      when "Electricity"
        qaqc[:economics][:electricity_cost] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost' AND RowName='#{rowname}'").get
        qaqc[:economics][:electricity_cost_per_m2]=qaqc[:economics][:electricity_cost]/qaqc[:building][:conditioned_floor_area_m2] unless model.building.get.conditionedFloorArea().empty?
      when "Natural Gas"
        qaqc[:economics][:natural_gas_cost] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost' AND RowName='#{rowname}'").get
        qaqc[:economics][:natural_gas_cost_per_m2]=qaqc[:economics][:natural_gas_cost]/qaqc[:building][:conditioned_floor_area_m2] unless model.building.get.conditionedFloorArea().empty?
    
      when "Additional"
        qaqc[:economics][:additional_cost] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost' AND RowName='#{rowname}'").get
        qaqc[:economics][:additional_cost_per_m2]=qaqc[:economics][:additional_cost]/qaqc[:building][:conditioned_floor_area_m2] unless model.building.get.conditionedFloorArea().empty?
    
      when "Total"
        qaqc[:economics][:total_cost] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost' AND RowName='#{rowname}'").get
        qaqc[:economics][:total_cost_per_m2]=qaqc[:economics][:total_cost]/qaqc[:building][:conditioned_floor_area_m2] unless model.building.get.conditionedFloorArea().empty?
      end
    end
  else
    error_warning <<  "costing is unavailable because the sql statement is nil RowName FROM TabularDataWithStrings WHERE ReportName='LEEDsummary' AND ReportForString='Entire Facility' AND TableName='EAp2-7. Energy Cost Summary' AND ColumnName='Total Energy Cost'"
  end
  
  #Store end_use data
  end_uses = [
    'Heating',
    'Cooling',
    'Interior Lighting',
    'Exterior Lighting',
    'Interior Equipment',
    'Exterior Equipment',
    'Fans',
    'Pumps',
    'Heat Rejection',
    'Humidification',
    'Heat Recovery',
    'Water Systems',
    'Refrigeration',
    'Generators',                                                                                
    'Total End Uses'
  ]
  
  fuels = [ 
    ['Electricity', 'GJ'],       
    ['Natural Gas', 'GJ'] , 
    ['Additional Fuel', 'GJ'],
    ['District Cooling','GJ'],             
    ['District Heating', 'GJ'], 
  ]
  
  qaqc[:end_uses] = {}
  qaqc[:end_uses_eui] = {}
  end_uses.each do |use_type|
    qaqc[:end_uses]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_gj"] = 0
    qaqc[:end_uses_eui]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_gj_per_m2"] = 0
    fuels.each do |fuel_type|
      value = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND RowName='#{use_type}' AND ColumnName='#{fuel_type[0]}' AND Units='#{fuel_type[1]}'")
      if value.empty? or value.get == 0
      else
        qaqc[:end_uses]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_gj"] += value.get
        unless qaqc[:building][:conditioned_floor_area_m2].nil?
          qaqc[:end_uses_eui]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_gj_per_m2"] += value.get / qaqc[:building][:conditioned_floor_area_m2]
        end
      end
    end
    value = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND RowName='#{use_type}' AND ColumnName='Water' AND Units='m3'")
   if value.empty? or value.get == 0
    else
      qaqc[:end_uses]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_water_m3"] = value.get
      unless qaqc[:building][:conditioned_floor_area_m2].nil?
        qaqc[:end_uses_eui]["#{use_type.gsub(/\s+/, "_").downcase.to_sym}_water_m3_per_m2"] = value.get / qaqc[:building][:conditioned_floor_area_m2]
      end
    end
  end
  
  # Store Peak Data
  qaqc[:meter_peaks] = {}
  qaqc[:meter_peaks][:electric_w] = electric_peak.empty? ? "NA" : electric_peak.get  
  qaqc[:meter_peaks][:natural_gas_w] = natural_gas_peak.empty? ? "NA" : natural_gas_peak.get 
  
  
  #Store unmet hour data
  qaqc[:unmet_hours] = {}
  qaqc[:unmet_hours][:cooling] = model.getFacility.hoursCoolingSetpointNotMet().get unless model.getFacility.hoursCoolingSetpointNotMet().empty?
  qaqc[:unmet_hours][:heating] = model.getFacility.hoursHeatingSetpointNotMet().get unless model.getFacility.hoursHeatingSetpointNotMet().empty?
  
  
  
  
  
  
  #puts "\n\n\n#{costing_rownames}\n\n\n"
  #Padmassun's Code -- Tarrif end


  #Padmassun's Code -- Service Hotwater Heating *start*
  qaqc[:service_water_heating] = {}
  qaqc[:service_water_heating][:total_nominal_occupancy]=-1
  #qaqc[:service_water_heating][:total_nominal_occupancy]=model.sqlFile().get().execAndReturnVectorOfDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='OutdoorAirSummary' AND ReportForString='Entire Facility' AND TableName='Average Outdoor Air During Occupied Hours' AND ColumnName='Nominal Number of Occupants'").get.inject(0, :+)
  qaqc[:service_water_heating][:total_nominal_occupancy]=get_total_nominal_capacity(model)
  
  qaqc[:service_water_heating][:electricity_per_year]=model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND ColumnName='Electricity' AND RowName='Water Systems'")
  qaqc[:service_water_heating][:electricity_per_year]= validate_optional(qaqc[:service_water_heating][:electricity_per_year], model, -1)

  qaqc[:service_water_heating][:electricity_per_day]=qaqc[:service_water_heating][:electricity_per_year]/365.5
  qaqc[:service_water_heating][:electricity_per_day_per_occupant]=qaqc[:service_water_heating][:electricity_per_day]/qaqc[:service_water_heating][:total_nominal_occupancy]
	
  
  qaqc[:service_water_heating][:natural_gas_per_year]=model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND ColumnName='Natural Gas' AND RowName='Water Systems'")
  qaqc[:service_water_heating][:natural_gas_per_year]=validate_optional(qaqc[:service_water_heating][:natural_gas_per_year], model, -1)

  qaqc[:service_water_heating][:additional_fuel_per_year]=model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND ColumnName='Additional Fuel' AND RowName='Water Systems'")
  qaqc[:service_water_heating][:additional_fuel_per_year] = validate_optional(qaqc[:service_water_heating][:additional_fuel_per_year], model, -1)
  
  qaqc[:service_water_heating][:water_m3_per_year]=model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' AND ReportForString='Entire Facility' AND TableName='End Uses' AND ColumnName='Water' AND RowName='Water Systems'")
  qaqc[:service_water_heating][:water_m3_per_year]=validate_optional(qaqc[:service_water_heating][:water_m3_per_year], model, -1)
  
  qaqc[:service_water_heating][:water_m3_per_day]=qaqc[:service_water_heating][:water_m3_per_year]/365.5
  qaqc[:service_water_heating][:water_m3_per_day_per_occupant]=qaqc[:service_water_heating][:water_m3_per_day]/qaqc[:service_water_heating][:total_nominal_occupancy]
  #puts qaqc[:service_water_heating][:total_nominal_occupancy]
  #Padmassun's Code -- Service Hotwater Heating *end*

  #Store Envelope data.
  qaqc[:envelope] = {}
	
  qaqc[:envelope][:outdoor_walls_average_conductance_w_per_m2_k] 	= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(outdoor_walls).round(4) if outdoor_walls.size > 0
  qaqc[:envelope][:outdoor_roofs_average_conductance_w_per_m2_k]  = BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(outdoor_roofs).round(4) if outdoor_roofs.size > 0
  qaqc[:envelope][:outdoor_floors_average_conductance_w_per_m2_k] = BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(outdoor_floors).round(4) if outdoor_floors.size > 0
  qaqc[:envelope][:ground_walls_average_conductance_w_per_m2_k]  	= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(ground_walls).round(4) if ground_walls.size > 0
  qaqc[:envelope][:ground_roofs_average_conductance_w_per_m2_k]  	= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(ground_roofs).round(4) if ground_roofs.size > 0
  qaqc[:envelope][:ground_floors_average_conductance_w_per_m2_k]  = BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(ground_floors).round(4) if ground_floors.size > 0
  qaqc[:envelope][:windows_average_conductance_w_per_m2_k]  		= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(windows).round(4) if windows.size > 0
  qaqc[:envelope][:skylights_average_conductance_w_per_m2_k]  	= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(skylights).round(4) if skylights.size > 0
  qaqc[:envelope][:doors_average_conductance_w_per_m2_k]  		= BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(doors).round(4) if doors.size > 0
  qaqc[:envelope][:overhead_doors_average_conductance_w_per_m2_k] = BTAP::Geometry::Surfaces::get_weighted_average_surface_conductance(overhead_doors).round(4) if overhead_doors.size > 0
  qaqc[:envelope][:fdwr]  										= (BTAP::Geometry::get_fwdr(model) * 100.0).round(1)
  qaqc[:envelope][:srr]  											= (BTAP::Geometry::get_srr(model) * 100.0).round(1)
	
	
  qaqc[:envelope][:constructions] = {}
  qaqc[:envelope][:constructions][:exterior_fenestration] = []
  constructions = []
  outdoor_subsurfaces.each { |surface| constructions << surface.construction.get }
  ext_const_base = Hash.new(0)
  constructions.each { |name| ext_const_base[name] += 1 }
  #iterate thought each construction and get store data
  ext_const_base.sort.each do |construction, count|
    construction_info = {}
    qaqc[:envelope][:constructions][:exterior_fenestration] << construction_info
    construction_info[:name] = construction.name.get
    construction_info[:net_area_m2] = construction.getNetArea.round(2)
    construction_info[:thermal_conductance_m2_w_per_k] = BTAP::Resources::Envelope::Constructions::get_conductance(construction).round(3)
    construction_info[:solar_transmittance] = BTAP::Resources::Envelope::Constructions::get_shgc(model, construction).round(3)
    construction_info[:visible_tranmittance] = BTAP::Resources::Envelope::Constructions::get_tvis(model,construction).round(3)
  end	
  
  #Exterior
  qaqc[:envelope][:constructions][:exterior_opaque] = []
  constructions = []
  outdoor_surfaces.each { |surface| constructions << surface.construction.get }
  ext_const_base = Hash.new(0)
  constructions.each { |name| ext_const_base[name] += 1 }
  #iterate thought each construction and get store data
  ext_const_base.sort.each do |construction, count|
    construction_info = {}
    qaqc[:envelope][:constructions][:exterior_opaque] << construction_info
    construction_info[:name] = construction.name.get
    construction_info[:net_area_m2] = construction.getNetArea.round(2)
    construction_info[:thermal_conductance_m2_w_per_k] = construction.thermalConductance.get.round(3) if construction.thermalConductance.is_initialized
    construction_info[:net_area_m2] = construction.to_Construction.get.getNetArea.round(2)
    construction_info[:solar_absorptance] = construction.to_Construction.get.layers[0].exteriorVisibleAbsorptance.get
  end
	
  #Ground
  qaqc[:envelope][:constructions][:ground] = []
  constructions = []
  ground_surfaces.each { |surface| constructions << surface.construction.get }
  ext_const_base = Hash.new(0)
  constructions.each { |name| ext_const_base[name] += 1 }
  #iterate thought each construction and get store data
  ext_const_base.sort.each do |construction, count|
    construction_info = {}
    qaqc[:envelope][:constructions][:ground] << construction_info
    construction_info[:name] = construction.name.get
    construction_info[:net_area_m2] = construction.getNetArea.round(2)
    construction_info[:thermal_conductance_m2_w_per_k] = construction.thermalConductance.get.round(3) if construction.thermalConductance.is_initialized
    construction_info[:net_area_m2] = construction.to_Construction.get.getNetArea.round(2)
    construction_info[:solar_absorptance] = construction.to_Construction.get.layers[0].exteriorVisibleAbsorptance.get
  end
	

  # Store Space data.
  qaqc[:spaces] =[]
  model.getSpaces.sort.each do |space|
    spaceinfo = {}
    qaqc[:spaces] << spaceinfo
    spaceinfo[:name] = space.name.get #name should be defined test
    spaceinfo[:multiplier] = space.multiplier 
    spaceinfo[:volume] = space.volume # should be greater than zero
    spaceinfo[:exterior_wall_area] = space.exteriorWallArea # just for information. 
    spaceinfo[:space_type_name] = space.spaceType.get.name.get unless space.spaceType.empty? #should have a space types name defined. 
    spaceinfo[:thermal_zone] = space.thermalZone.get.name.get unless space.thermalZone.empty? # should be assigned a thermalzone name.
    #puts space.name.get
    #puts space.thermalZone.empty?
    spaceinfo[:breathing_zone_outdoor_airflow_vbz] =-1
    breathing_zone_outdoor_airflow_vbz= model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='Standard62.1Summary' AND ReportForString='Entire Facility' AND TableName='Zone Ventilation Parameters' AND ColumnName='Breathing Zone Outdoor Airflow - Vbz' AND Units='m3/s' AND RowName='#{spaceinfo[:thermal_zone].to_s.upcase}' ")
    spaceinfo[:breathing_zone_outdoor_airflow_vbz] =breathing_zone_outdoor_airflow_vbz.get unless breathing_zone_outdoor_airflow_vbz.empty?
    spaceinfo[:infiltration_method] = 'N/A' 
    spaceinfo[:infiltration_flow_per_m2]  =-1.0
    unless space.spaceInfiltrationDesignFlowRates[0].nil?
      spaceinfo[:infiltration_method] = space.spaceInfiltrationDesignFlowRates[0].designFlowRateCalculationMethod
      spaceinfo[:infiltration_flow_per_m2] = "N/A"
      spaceinfo[:infiltration_flow_per_m2] = space.spaceInfiltrationDesignFlowRates[0].flowperExteriorSurfaceArea.get.round(5) unless space.spaceInfiltrationDesignFlowRates[0].flowperExteriorSurfaceArea.empty?
    else
      error_warning <<  "space.spaceInfiltrationDesignFlowRates[0] is empty for #{spaceinfo[:name]}"
      error_warning <<  "space.spaceInfiltrationDesignFlowRates[0].designFlowRateCalculationMethod is empty for #{spaceinfo[:name]}"
      error_warning <<  "space.spaceInfiltrationDesignFlowRates[0].flowperExteriorSurfaceArea is empty for #{spaceinfo[:name]}"
    end  

    #the following should have values unless the spacetype is "undefined" other they should be set to the correct NECB values. 
    unless space.spaceType.empty?
      spaceinfo[:occupancy_schedule] = nil
      unless (space.spaceType.get.defaultScheduleSet.empty?)
        unless space.spaceType.get.defaultScheduleSet.get.numberofPeopleSchedule.empty?
          spaceinfo[:occupancy_schedule] = space.spaceType.get.defaultScheduleSet.get.numberofPeopleSchedule.get.name.get  #should not empty.
        else
          error_warning <<  "space.spaceType.get.defaultScheduleSet.get.numberofPeopleSchedule is empty for #{space.name.get }"
        end
      else
        error_warning <<  "space.spaceType.get.defaultScheduleSet is empty for #{space.name.get }"
      end
    
      spaceinfo[:occ_per_m2] = space.spaceType.get.people[0].peopleDefinition.peopleperSpaceFloorArea.get.round(3) unless space.spaceType.get.people[0].nil? 
      unless space.spaceType.get.lights[0].nil?
        spaceinfo[:lighting_w_per_m2] = space.spaceType.get.lights[0].lightsDefinition.wattsperSpaceFloorArea#.get.round(3) unless space.spaceType.get.lights[0].nil?
        spaceinfo[:lighting_w_per_m2] = validate_optional(spaceinfo[:lighting_w_per_m2], model, -1.0)
        unless spaceinfo[:lighting_w_per_m2].nil?
          spaceinfo[:lighting_w_per_m2] = spaceinfo[:lighting_w_per_m2].round(3)
        end
      end
      #spaceinfo[:electric_w_per_m2] = space.spaceType.get.electricEquipment[0].electricEquipmentDefinition.wattsperSpaceFloorArea.get.round(3) unless space.spaceType.get.electricEquipment[0].nil?
    
      unless space.spaceType.get.electricEquipment[0].nil?
        unless space.spaceType.get.electricEquipment[0].electricEquipmentDefinition.wattsperSpaceFloorArea.empty?
          spaceinfo[:electric_w_per_m2] = space.spaceType.get.electricEquipment[0].electricEquipmentDefinition.wattsperSpaceFloorArea.get.round(3)
        end
      end
      spaceinfo[:shw_m3_per_s] = space.waterUseEquipment[0].waterUseEquipmentDefinition.peakFlowRate.round(3) unless space.waterUseEquipment[0].nil?
      spaceinfo[:waterUseEquipment] = []
      if !space.waterUseEquipment.empty?
        waterUseEquipment_info={}
        spaceinfo[:waterUseEquipment] << waterUseEquipment_info
        waterUseEquipment_info[:peak_flow_rate]= space.waterUseEquipment[0].waterUseEquipmentDefinition.peakFlowRate
        waterUseEquipment_info[:peak_flow_rate_per_area] = waterUseEquipment_info[:peak_flow_rate] / space.floorArea
        area_per_occ = space.spaceType.get.people[0].spaceFloorAreaPerPerson.get
        #                             Watt per person =             m3/s/m3                * 1000W/kW * (specific heat * dT) * m2/person
        waterUseEquipment_info[:shw_watts_per_person] = waterUseEquipment_info[:peak_flow_rate_per_area] * 1000 * (4.19 * 44.4) * 1000 * area_per_occ
        #puts waterUseEquipment_info[:shw_watts_per_person]
        #puts "\n\n\n"
      end
    else
      error_warning <<  "space.spaceType is empty for #{space.name.get }"
    end
  end
  
  # Store Thermal zone data
  qaqc[:thermal_zones] = [] 
  model.getThermalZones.sort.each do  |zone|
    zoneinfo = {}
    qaqc[:thermal_zones] << zoneinfo
    zoneinfo[:name] = zone.name.get
    zoneinfo[:floor_area] = zone.floorArea
    zoneinfo[:multiplier] = zone.multiplier
    zoneinfo[:is_conditioned] = "N/A"
    unless zone.isConditioned.empty?
      zoneinfo[:is_conditioned] = zone.isConditioned.get
    else
      error_warning <<  "zone.isConditioned is empty for #{zone.name.get}"
    end
    
    zoneinfo[:is_ideal_air_loads] = zone.useIdealAirLoads
    zoneinfo[:heating_sizing_factor] = -1.0
    unless zone.sizingZone.zoneHeatingSizingFactor.empty?
      zoneinfo[:heating_sizing_factor] = zone.sizingZone.zoneHeatingSizingFactor.get
    else
      error_warning <<  "zone.sizingZone.zoneHeatingSizingFactor is empty for #{zone.name.get}"
    end  
    
    zoneinfo[:cooling_sizing_factor] = -1.0 #zone.sizingZone.zoneCoolingSizingFactor.get
    unless zone.sizingZone.zoneCoolingSizingFactor.empty?
      zoneinfo[:cooling_sizing_factor] = zone.sizingZone.zoneCoolingSizingFactor.get
    else
      error_warning <<  "zone.sizingZone.zoneCoolingSizingFactor is empty for #{zone.name.get}"
    end  
    
    zoneinfo[:zone_heating_design_supply_air_temperature] = zone.sizingZone.zoneHeatingDesignSupplyAirTemperature
    zoneinfo[:zone_cooling_design_supply_air_temperature] = zone.sizingZone.zoneCoolingDesignSupplyAirTemperature
    zoneinfo[:spaces] = []
    zone.spaces.sort.each do |space|
      spaceinfo ={}
      zoneinfo[:spaces] << spaceinfo
      spaceinfo[:name] = space.name.get  
      spaceinfo[:type] = space.spaceType.get.name.get unless space.spaceType.empty?
    end
    zoneinfo[:equipment] = []
    zone.equipmentInHeatingOrder.each do |equipment|
      item = {}
      zoneinfo[:equipment] << item
      item[:name] = equipment.name.get
      if equipment.to_ZoneHVACComponent.is_initialized
        item[:type] = 'ZoneHVACComponent'
      elsif  equipment.to_StraightComponent.is_initialized
        item[:type] = 'StraightComponent'
      end
    end
  end #zone
  # Store Air Loop Information
  qaqc[:air_loops] = []
  model.getAirLoopHVACs.sort.each do |air_loop|
    air_loop_info = {}
    air_loop_info[:name] = air_loop.name.get
    air_loop_info[:thermal_zones] = []
    air_loop_info[:total_floor_area_served] = 0.0
    air_loop_info[:total_breathing_zone_outdoor_airflow_vbz] = 0.0
    air_loop.thermalZones.sort.each do |zone|
      air_loop_info[:thermal_zones] << zone.name.get
      vbz = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='Standard62.1Summary' AND ReportForString='Entire Facility' AND TableName='Zone Ventilation Parameters' AND ColumnName='Breathing Zone Outdoor Airflow - Vbz' AND Units='m3/s' AND RowName='#{zone.name.get.to_s.upcase}' ")
      vbz = validate_optional(vbz, model, 0)
      air_loop_info[:total_breathing_zone_outdoor_airflow_vbz] += vbz
      air_loop_info[:total_floor_area_served] += zone.floorArea
    end
    air_loop_info[:area_outdoor_air_rate_m3_per_s_m2] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='Standard62.1Summary' AND ReportForString='Entire Facility' AND TableName='System Ventilation Parameters' AND ColumnName='Area Outdoor Air Rate - Ra' AND Units='m3/s-m2' AND RowName='#{air_loop_info[:name].to_s.upcase}' ")
    air_loop_info[:area_outdoor_air_rate_m3_per_s_m2] = validate_optional(air_loop_info[:area_outdoor_air_rate_m3_per_s_m2], model, -1.0)
    
    air_loop_info[:outdoor_air_L_per_s] = -1.0
    unless air_loop_info[:area_outdoor_air_rate_m3_per_s_m2] ==-1.0
      air_loop_info[:outdoor_air_L_per_s] = air_loop_info[:area_outdoor_air_rate_m3_per_s_m2]*air_loop_info[:total_floor_area_served]*1000
    end
    #Fan

    unless air_loop.supplyFan.empty?
      air_loop_info[:supply_fan] = {}
      if air_loop.supplyFan.get.to_FanConstantVolume.is_initialized 
        air_loop_info[:supply_fan][:type] = 'CV'
        fan = air_loop.supplyFan.get.to_FanConstantVolume.get
      elsif air_loop.supplyFan.get.to_FanVariableVolume.is_initialized 
        air_loop_info[:supply_fan][:type]  = 'VV'
        fan = air_loop.supplyFan.get.to_FanVariableVolume.get
      end
      air_loop_info[:supply_fan][:name] = fan.name.get
      #puts "\n\n\n\n#{fan.name.get}\n\n\n\n"
      air_loop_info[:supply_fan][:fan_efficiency] = fan.fanEfficiency
      air_loop_info[:supply_fan][:motor_efficiency] = fan.motorEfficiency
      air_loop_info[:supply_fan][:pressure_rise] = fan.pressureRise
      air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s]  = -1.0
     
      max_air_flow_info = model.sqlFile().get().execAndReturnVectorOfString("SELECT RowName FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Fans' AND ColumnName='Max Air Flow Rate' AND Units='m3/s' ")
      max_air_flow_info = validate_optional(max_air_flow_info, model, "N/A")
      unless max_air_flow_info == "N/A"
        if max_air_flow_info.include? "#{air_loop_info[:supply_fan][:name].to_s.upcase}"
          air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Fans' AND ColumnName='Max Air Flow Rate' AND Units='m3/s' AND RowName='#{air_loop_info[:supply_fan][:name].upcase}' ").get
          air_loop_info[:supply_fan][:rated_electric_power_w] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Fans' AND ColumnName='Rated Electric Power' AND Units='W' AND RowName='#{air_loop_info[:supply_fan][:name].upcase}' ").get
        else
          error_warning <<  "#{air_loop_info[:supply_fan][:name]} does not exist in sql file WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Fans' AND ColumnName='Max Air Flow Rate' AND Units='m3/s'"
        end
      else
        error_warning <<  "max_air_flow_info is nil because the following sql statement returned nil: RowName FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Fans' AND ColumnName='Max Air Flow Rate' AND Units='m3/s' "
      end
    end

    #economizer                                                                                             
    air_loop_info[:economizer] = {}
    air_loop_info[:economizer][:name] = air_loop.airLoopHVACOutdoorAirSystem.get.getControllerOutdoorAir.name.get
    air_loop_info[:economizer][:control_type] = air_loop.airLoopHVACOutdoorAirSystem.get.getControllerOutdoorAir.getEconomizerControlType

    #DX cooling coils
    air_loop_info[:cooling_coils] ={}
    air_loop_info[:cooling_coils][:dx_single_speed]=[]
    air_loop_info[:cooling_coils][:dx_two_speed]=[]

    #Heating Coil
    air_loop_info[:heating_coils] = {}
    air_loop_info[:heating_coils][:coil_heating_gas] = []
    air_loop_info[:heating_coils][:coil_heating_electric]= []
    air_loop_info[:heating_coils][:coil_heating_water]= []

    #Heat Excahnger
    air_loop_info[:heat_exchanger] = {}
    
    air_loop.supplyComponents.each do |supply_comp|
      if supply_comp.to_CoilHeatingGas.is_initialized
        coil={}
        air_loop_info[:heating_coils][:coil_heating_gas] << coil
        gas = supply_comp.to_CoilHeatingGas.get
        coil[:name]=gas.name.get
        coil[:type]="Gas"
        coil[:efficency] = gas.gasBurnerEfficiency
        #coil[:nominal_capacity]= gas.nominalCapacity()
        coil[:nominal_capacity]= model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Heating Coils' AND ColumnName='Nominal Total Capacity' AND RowName='#{coil[:name].to_s.upcase}'")
        coil[:nominal_capacity]=validate_optional(coil[:nominal_capacity],model,-1.0 )
      end
      if supply_comp.to_CoilHeatingElectric.is_initialized
        coil={}
        air_loop_info[:heating_coils][:coil_heating_electric] << coil
        electric = supply_comp.to_CoilHeatingElectric.get
        coil[:name]= electric.name.get
        coil[:type]= "Electric"
        coil[:nominal_capacity]= model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Heating Coils' AND ColumnName='Nominal Total Capacity' AND RowName='#{coil[:name].to_s.upcase}'")
        coil[:nominal_capacity]=validate_optional(coil[:nominal_capacity],model,-1.0 )
      end
      if supply_comp.to_CoilHeatingWater.is_initialized
        coil={}
        air_loop_info[:heating_coils][:coil_heating_water] << coil
        water = supply_comp.to_CoilHeatingWater.get
        coil[:name]= water.name.get
        coil[:type]= "Water"
        coil[:nominal_capacity]= model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Heating Coils' AND ColumnName='Nominal Total Capacity' AND RowName='#{coil[:name].to_s.upcase}'")
        coil[:nominal_capacity]=validate_optional(coil[:nominal_capacity],model,-1.0 )
      end
      if supply_comp.to_HeatExchangerAirToAirSensibleAndLatent.is_initialized
        heatExchanger = supply_comp.to_HeatExchangerAirToAirSensibleAndLatent.get
        air_loop_info[:heat_exchanger][:name] = heatExchanger.name.get
      end
    end
    
    #I dont think i need to get the type of heating coil from the sql file, because the coils are differentiated by class, and I have hard coded the information
    #model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName= 'Heating Coils' AND ColumnName='Type' ").get #padmussen to complete #AND RowName='#{air_loop_info[:heating_coils][:name].upcase}'
    
    
    #Collect all the fans into the the array.
    air_loop.supplyComponents.each do |supply_comp|
      if supply_comp.to_CoilCoolingDXSingleSpeed.is_initialized
        coil = {}
        air_loop_info[:cooling_coils][:dx_single_speed] << coil
        single_speed = supply_comp.to_CoilCoolingDXSingleSpeed.get
        coil[:name] = single_speed.name.get
        coil[:cop] = single_speed.ratedCOP.get
        coil[:nominal_total_capacity_w] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Cooling Coils' AND ColumnName='Nominal Total Capacity' AND RowName='#{coil[:name].upcase}' ")
        coil[:nominal_total_capacity_w] = validate_optional(coil[:nominal_total_capacity_w], model, -1.0)
      end
      if supply_comp.to_CoilCoolingDXTwoSpeed.is_initialized
        coil = {}
        air_loop_info[:cooling_coils][:dx_two_speed] << coil
        two_speed = supply_comp.to_CoilCoolingDXTwoSpeed.get
        coil[:name] = two_speed.name.get
        coil[:cop_low] = two_speed.ratedLowSpeedCOP.get
        coil[:cop_high] =  two_speed.ratedHighSpeedCOP.get
        coil[:nominal_total_capacity_w] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Cooling Coils' AND ColumnName='Nominal Total Capacity' AND RowName='#{coil[:name].upcase}' ")
        coil[:nominal_total_capacity_w] = validate_optional(coil[:nominal_total_capacity_w] , model,-1.0)
      end
    end
    qaqc[:air_loops] << air_loop_info
  end


  qaqc[:plant_loops] = []
  model.getPlantLoops.sort.each do |plant_loop|
    plant_loop_info = {}
    qaqc[:plant_loops] << plant_loop_info
    plant_loop_info[:name] = plant_loop.name.get
    
    sizing = plant_loop.sizingPlant
    plant_loop_info[:design_loop_exit_temperature] = sizing.designLoopExitTemperature
    plant_loop_info[:loop_design_temperature_difference] = sizing.loopDesignTemperatureDifference
    
    #Create Container for plant equipment arrays.
    plant_loop_info[:pumps] = []
    plant_loop_info[:boilers] = []
    plant_loop_info[:chiller_electric_eir] = []
    plant_loop_info[:cooling_tower_single_speed] = []
    plant_loop_info[:water_heater_mixed] =[]
    plant_loop.supplyComponents.each do |supply_comp|
    
      #Collect Constant Speed
      if supply_comp.to_PumpConstantSpeed.is_initialized
        pump = supply_comp.to_PumpConstantSpeed.get
        pump_info = {}
        plant_loop_info[:pumps] << pump_info
        pump_info[:name] = pump.name.get
        pump_info[:type] = "Pump:ConstantSpeed"
        pump_info[:head_pa] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Head' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:head_pa] = validate_optional(pump_info[:head_pa], model, -1.0)
        pump_info[:water_flow_m3_per_s] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Water Flow' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:water_flow_m3_per_s] = validate_optional(pump_info[:water_flow_m3_per_s], model, -1.0)
        pump_info[:electric_power_w] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Electric Power' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:electric_power_w] = validate_optional(pump_info[:electric_power_w], model, -1.0)
        pump_info[:motor_efficency] = pump.motorEfficiency
      end
      
      #Collect Variable Speed
      if supply_comp.to_PumpVariableSpeed.is_initialized
        pump = supply_comp.to_PumpVariableSpeed.get
        pump_info = {}
        plant_loop_info[:pumps] << pump_info
        pump_info[:name] = pump.name.get
        pump_info[:type] = "Pump:VariableSpeed" 
        pump_info[:head_pa] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Head' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:head_pa] = validate_optional(pump_info[:head_pa], model, -1.0)
        pump_info[:water_flow_m3_per_s] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Water Flow' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:water_flow_m3_per_s] = validate_optional(pump_info[:water_flow_m3_per_s], model, -1.0)
        pump_info[:electric_power_w] = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='EquipmentSummary' AND ReportForString='Entire Facility' AND TableName='Pumps' AND ColumnName='Electric Power' AND RowName='#{pump_info[:name].upcase}' ")
        pump_info[:electric_power_w] = validate_optional(pump_info[:electric_power_w], model, -1.0)
        pump_info[:motor_efficency] = pump.motorEfficiency
      end
      
      # Collect HotWaterBoilers
      if supply_comp.to_BoilerHotWater.is_initialized
        boiler = supply_comp.to_BoilerHotWater.get
        boiler_info = {}
        plant_loop_info[:boilers] << boiler_info
        boiler_info[:name] = boiler.name.get
        boiler_info[:type] = "Boiler:HotWater" 
        boiler_info[:fueltype] = boiler.fuelType
        boiler_info[:nominal_capacity] = boiler.nominalCapacity
        boiler_info[:nominal_capacity] = validate_optional(boiler_info[:nominal_capacity], model, -1.0)
      end
      
      # Collect ChillerElectricEIR
      if supply_comp.to_ChillerElectricEIR.is_initialized
        chiller = supply_comp.to_ChillerElectricEIR.get
        chiller_info = {}
        plant_loop_info[:chiller_electric_eir] << chiller_info
        chiller_info[:name] = chiller.name.get
        chiller_info[:type] = "Chiller:Electric:EIR" 
        chiller_info[:reference_capacity] = validate_optional(chiller.referenceCapacity, model, -1.0)
        chiller_info[:reference_leaving_chilled_water_temperature] =chiller.referenceLeavingChilledWaterTemperature
      end
      
      # Collect CoolingTowerSingleSpeed
      if supply_comp.to_CoolingTowerSingleSpeed.is_initialized
        coolingTower = supply_comp.to_CoolingTowerSingleSpeed.get
        coolingTower_info = {}
        plant_loop_info[:cooling_tower_single_speed] << coolingTower_info
        coolingTower_info[:name] = coolingTower.name.get
        coolingTower_info[:type] = "CoolingTower:SingleSpeed" 
        coolingTower_info[:fan_power_at_design_air_flow_rate] = validate_optional(coolingTower.fanPoweratDesignAirFlowRate, model, -1.0)

      end

      # Collect WaterHeaterMixed
      if supply_comp.to_WaterHeaterMixed.is_initialized
        waterHeaterMixed = supply_comp.to_WaterHeaterMixed.get
        waterHeaterMixed_info = {}
        plant_loop_info[:water_heater_mixed] << waterHeaterMixed_info
        waterHeaterMixed_info[:name] = waterHeaterMixed.name.get
        waterHeaterMixed_info[:type] = "WaterHeater:Mixed"
        waterHeaterMixed_info[:heater_thermal_efficiency] = waterHeaterMixed.heaterThermalEfficiency.get unless waterHeaterMixed.heaterThermalEfficiency.empty?
        waterHeaterMixed_info[:heater_fuel_type] = waterHeaterMixed.heaterFuelType
      end
    end
    
    qaqc[:eplusout_err] ={}  
    warnings = model.sqlFile().get().execAndReturnVectorOfString("SELECT ErrorMessage FROM Errors WHERE ErrorType='0' ")
    warnings = validate_optional(warnings, model, "N/A")
    unless warnings == "N/A"
      qaqc[:eplusout_err][:warnings] = model.sqlFile().get().execAndReturnVectorOfString("SELECT ErrorMessage FROM Errors WHERE ErrorType='0' ").get
      qaqc[:eplusout_err][:fatal] =model.sqlFile().get().execAndReturnVectorOfString("SELECT ErrorMessage FROM Errors WHERE ErrorType='2' ").get
      qaqc[:eplusout_err][:severe] =model.sqlFile().get().execAndReturnVectorOfString("SELECT ErrorMessage FROM Errors WHERE ErrorType='1' ").get
    end
    
    qaqc[:ruby_warnings] = error_warning
  end
     
  
  # Perform qaqc
  necb_2011_qaqc(qaqc, model) if qaqc[:building][:name].include?("NECB2011") #had to nodify this because this is specifically for "NECB-2011" standard
  sanity_check(qaqc)
  
  qaqc[:information] = qaqc[:information].sort
  qaqc[:warnings] = qaqc[:warnings].sort
  qaqc[:errors] = qaqc[:errors].sort
  qaqc[:unique_errors]= qaqc[:unique_errors].sort
  
  return qaqc
end

.runner_register(type, text, runner = nil) ⇒ Object

A wrapper for outputing feedback to users and developers.

BTAP::runner_register("InitialCondition",   "Your Information Message Here", runner)
BTAP::runner_register("Info",    "Your Information Message Here", runner)
BTAP::runner_register("Warning", "Your Information Message Here", runner)
BTAP::runner_register("Error",   "Your Information Message Here", runner)
BTAP::runner_register("Debug",   "Your Information Message Here", runner)
BTAP::runner_register("FinalCondition",   "Your Information Message Here", runner)
@params type [String]
@params runner [OpenStudio::Ruleset::OSRunner] # or a nil.

# File 'lib/openstudio-standards/btap/btap.rb', line 113

def self.runner_register(type,text,runner = nil)

  #dump to console. 
  puts "#{type.upcase}: #{text}"
  #dump to runner. 
  if runner.is_a?(OpenStudio::Ruleset::OSRunner)
    case type.downcase
    when "info"
      runner.registerInfo(text)
    when "warning"
      runner.registerWarning(text)
    when "error"
      runner.registerError(text)
    when "notapplicable"
      runner.registerAsNotApplicable(text)
    when "finalcondition"
      runner.registerFinalCondition(text)
    when "initialcondition"
      runner.registerInitialCondition(text)
    when "debug"
    when "macro"
    else
      raise("Runner Register type #{type.downcase} not info,warning,error,notapplicable,finalcondition,initialcondition,macro.")
    end
  end
end

.runner_register_value(name, value, runner = nil) ⇒ Object

# File 'lib/openstudio-standards/btap/btap.rb', line 140

def self.runner_register_value(name,value,runner = nil)
  if runner.is_a?(OpenStudio::Ruleset::OSRunner)
    runner.registerValue( name,value.to_s)
    BTAP::runner_register("Info", "#{name} = #{value} has been registered in the runner", runner)
  end
end