openstudio-standards 0.8.4 → 0.8.5.rc1

data/lib/openstudio-standards/create_typical/create_typical.rb

@@ -211,13 +211,16 @@ module OpenstudioStandards
         runperiodctrl_daylightsaving.setEndDate(end_date)
       end
 
+      # set space type additional properties
+      standard.prototype_space_type_map(model, reset_standards_space_type: false, set_additional_properties: true)
+
       # add internal loads to space types
       if add_space_type_loads
 
         # remove internal loads
         if remove_objects
           model.getSpaceLoads.sort.each do |instance|
-            # most prototype building types model exterior elevators with name Elevator
+            # most prototype building types model elevators with name Elevator
             next if instance.name.to_s.include?('Elevator')
             next if instance.to_InternalMass.is_initialized
             next if instance.to_WaterUseEquipment.is_initialized
@@ -229,15 +232,17 @@ module OpenstudioStandards
         end
 
         model.getSpaceTypes.sort.each do |space_type|
-          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true)
+          # split out parts here to allow different options for lighting and ventilation
+          # lighting standard or technology
+          # ventilation standard
+          test = standard.space_type_apply_internal_loads(space_type)
           if test == false
             OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CreateTypical', "Could not add loads for #{space_type.name}. Not expected for #{template}")
             next
           end
 
           # apply internal load schedules
-          # the last bool test it to make thermostat schedules. They are now added in HVAC section instead of here
-          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, false)
+          standard.space_type_apply_internal_load_schedules(space_type)
 
           # extend space type name to include the template. Consider this as well for load defs
           space_type.setName("#{space_type.name} - #{template}")
@@ -458,10 +463,10 @@ module OpenstudioStandards
             ext_light.remove
           end
         end
-        exterior_lights = OpenstudioStandards::ExteriorLighting.model_create_typical_exterior_lighting(model,
-                                                                                                       lighting_generation: 'default',
-                                                                                                       lighting_zone: exterior_lighting_zone.chars[0].to_i,
-                                                                                                       onsite_parking_fraction: onsite_parking_fraction)
+        exterior_lights = OpenstudioStandards::ExteriorLighting.create_typical_exterior_lighting(model,
+                                                                                                 lighting_generation: 'default',
+                                                                                                 lighting_zone: exterior_lighting_zone.chars[0].to_i,
+                                                                                                 onsite_parking_fraction: onsite_parking_fraction)
         exterior_lights.each do |v|
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Adding Exterior Lights named #{v.exteriorLightsDefinition.name} with design level of #{v.exteriorLightsDefinition.designLevel} * #{OpenStudio.toNeatString(v.multiplier, 0, true)}.")
         end
@@ -578,28 +583,7 @@ module OpenstudioStandards
           model.getThermostatSetpointDualSetpoints.each(&:remove)
         end
 
-        model.getSpaceTypes.sort.each do |space_type|
-          # create thermostat schedules
-          # skip un-recognized space types
-          next if standard.space_type_get_standards_data(space_type).empty?
-
-          # the last bool test it to make thermostat schedules. They are added to the model but not assigned
-          standard.space_type_apply_internal_load_schedules(space_type, false, false, false, false, false, true)
-
-          # identify thermal thermostat and apply to zones (apply_internal_load_schedules names )
-          model.getThermostatSetpointDualSetpoints.sort.each do |thermostat|
-            next if thermostat.name.to_s != "#{space_type.name} Thermostat"
-            next if !thermostat.coolingSetpointTemperatureSchedule.is_initialized
-            next if !thermostat.heatingSetpointTemperatureSchedule.is_initialized
-
-            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Assigning #{thermostat.name} to thermal zones with #{space_type.name} assigned.")
-            space_type.spaces.sort.each do |space|
-              next if !space.thermalZone.is_initialized
-
-              space.thermalZone.get.setThermostatSetpointDualSetpoint(thermostat)
-            end
-          end
-        end
+        OpenstudioStandards::ThermalZone.thermal_zones_set_thermostat_schedules(model.getThermalZones)
       end
 
       # add internal mass
@@ -933,13 +917,13 @@ module OpenstudioStandards
           space_types_new << space_type
 
           # add internal loads (the nil check isn't necessary, but I will keep it in as a warning instad of an error)
-          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true)
+          test = standard.space_type_apply_internal_loads(space_type)
           if test.nil?
             OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CreateTypical', "Could not add loads for #{space_type.name}. Not expected for #{template} #{lookup_building_type}")
           end
 
-          # the last bool test it to make thermostat schedules. They are added to the model but not assigned
-          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true)
+          # assign internal load schedules
+          standard.space_type_apply_internal_load_schedules(space_type)
 
           # assign colors
           standard.space_type_apply_rendering_color(space_type)

data/lib/openstudio-standards/create_typical/space_type_ratios.rb

@@ -308,43 +308,43 @@ module OpenstudioStandards
       when 'SmallDataCenterHighITE', 'SmallDataCenterLowITE'
         hash['ComputerRoom'] = { ratio: 1.0, space_type_gen: true, default: true }
       when 'Courthouse'
-        hash['Courthouse - Break Room'] = { ratio: 0.0067, space_type_gen: true, default: false }
-        hash['Courthouse - Cell'] = { ratio: 0.0731, space_type_gen: true, default: false }
-        hash['Courthouse - Conference'] = { ratio: 0.0203, space_type_gen: true, default: false }
-        hash['Courthouse - Corridor'] = { ratio: 0.0829, space_type_gen: true, default: false }
-        hash['Courthouse - Courtroom'] = { ratio: 0.1137, space_type_gen: true, default: false }
-        hash['Courthouse - Courtroom Waiting'] = { ratio: 0.051, space_type_gen: true, default: false }
-        hash['Courthouse - Elevator Lobby'] = { ratio: 0.0085, space_type_gen: true, default: false }
-        hash['Courthouse - Elevator Shaft'] = { ratio: 0.0047, space_type_gen: true, default: false }
-        hash['Courthouse - Entrance Lobby'] = { ratio: 0.0299, space_type_gen: true, default: false }
-        hash['Courthouse - Judges Chamber'] = { ratio: 0.0261, space_type_gen: true, default: false }
-        hash['Courthouse - Jury Assembly'] = { ratio: 0.0355, space_type_gen: true, default: false }
-        hash['Courthouse - Jury Deliberation'] = { ratio: 0.0133, space_type_gen: true, default: false }
-        hash['Courthouse - Library'] = { ratio: 0.0302, space_type_gen: true, default: false }
-        hash['Courthouse - Office'] = { ratio: 0.1930, space_type_gen: true, default: true }
-        hash['Courthouse - Parking'] = { ratio: 0.1083, space_type_gen: true, default: false }
-        hash['Courthouse - Restrooms'] = { ratio: 0.04, space_type_gen: true, default: false }
-        hash['Courthouse - Security Screening'] = { ratio: 0.0132, space_type_gen: true, default: false }
-        hash['Courthouse - Service Shaft'] = { ratio: 0.0019, space_type_gen: true, default: false }
-        hash['Courthouse - Stairs'] = { ratio: 0.0111, space_type_gen: true, default: false }
-        hash['Courthouse - Storage'] = { ratio: 0.0882, space_type_gen: true, default: false }
-        hash['Courthouse - Utility'] = { ratio: 0.0484, space_type_gen: true, default: false }
+        hash['Break Room'] = { ratio: 0.0067, space_type_gen: true, default: false }
+        hash['Cell'] = { ratio: 0.0731, space_type_gen: true, default: false }
+        hash['Conference'] = { ratio: 0.0203, space_type_gen: true, default: false }
+        hash['Corridor'] = { ratio: 0.0829, space_type_gen: true, default: false }
+        hash['Courtroom'] = { ratio: 0.1137, space_type_gen: true, default: false }
+        hash['Courtroom Waiting'] = { ratio: 0.051, space_type_gen: true, default: false }
+        hash['Elevator Lobby'] = { ratio: 0.0085, space_type_gen: true, default: false }
+        hash['Elevator Shaft'] = { ratio: 0.0047, space_type_gen: true, default: false }
+        hash['Entrance Lobby'] = { ratio: 0.0299, space_type_gen: true, default: false }
+        hash['Judges Chamber'] = { ratio: 0.0261, space_type_gen: true, default: false }
+        hash['Jury Assembly'] = { ratio: 0.0355, space_type_gen: true, default: false }
+        hash['Jury Deliberation'] = { ratio: 0.0133, space_type_gen: true, default: false }
+        hash['Library'] = { ratio: 0.0302, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.1930, space_type_gen: true, default: true }
+        hash['Parking'] = { ratio: 0.1083, space_type_gen: true, default: false }
+        hash['Restrooms'] = { ratio: 0.04, space_type_gen: true, default: false }
+        hash['Security Screening'] = { ratio: 0.0132, space_type_gen: true, default: false }
+        hash['Service Shaft'] = { ratio: 0.0019, space_type_gen: true, default: false }
+        hash['Stairs'] = { ratio: 0.0111, space_type_gen: true, default: false }
+        hash['Storage'] = { ratio: 0.0882, space_type_gen: true, default: false }
+        hash['Utility'] = { ratio: 0.0484, space_type_gen: true, default: false }
       when 'College'
-        hash['College - Art Classroom'] = { ratio: 0.1868, space_type_gen: true, default: false }
-        hash['College - Classroom'] = { ratio: 0.2348, space_type_gen: true, default: true }
-        hash['College - Conference'] = { ratio: 0.0215, space_type_gen: true, default: false }
-        hash['College - Corridor'] = { ratio: 0.0716, space_type_gen: true, default: false }
-        hash['College - Elevator Shaft'] = { ratio: 0.0074, space_type_gen: true, default: false }
-        hash['College - Entrance Lobby'] = { ratio: 0.0117, space_type_gen: true, default: false }
-        hash['College - Laboratory'] = { ratio: 0.0843, space_type_gen: true, default: false }
-        hash['College - Lecture Hall'] = { ratio: 0.0421, space_type_gen: true, default: false }
-        hash['College - Lounge'] = { ratio: 0.028, space_type_gen: true, default: false }
-        hash['College - Media Center'] = { ratio: 0.0421, space_type_gen: true, default: false }
-        hash['College - Office'] = { ratio: 0.1894, space_type_gen: true, default: false }
-        hash['College - Restroom'] = { ratio: 0.0363, space_type_gen: true, default: false }
-        hash['College - Stairs'] = { ratio: 0.0272, space_type_gen: true, default: false }
-        hash['College - Storage'] = { ratio: 0.0117, space_type_gen: true, default: false }
-        hash['College - Utility'] = { ratio: 0.0051, space_type_gen: true, default: false }
+        hash['Art Classroom'] = { ratio: 0.1868, space_type_gen: true, default: false }
+        hash['Classroom'] = { ratio: 0.2348, space_type_gen: true, default: true }
+        hash['Conference'] = { ratio: 0.0215, space_type_gen: true, default: false }
+        hash['Corridor'] = { ratio: 0.0716, space_type_gen: true, default: false }
+        hash['Elevator Shaft'] = { ratio: 0.0074, space_type_gen: true, default: false }
+        hash['Entrance Lobby'] = { ratio: 0.0117, space_type_gen: true, default: false }
+        hash['Laboratory'] = { ratio: 0.0843, space_type_gen: true, default: false }
+        hash['Lecture Hall'] = { ratio: 0.0421, space_type_gen: true, default: false }
+        hash['Lounge'] = { ratio: 0.028, space_type_gen: true, default: false }
+        hash['Media Center'] = { ratio: 0.0421, space_type_gen: true, default: false }
+        hash['Office'] = { ratio: 0.1894, space_type_gen: true, default: false }
+        hash['Restroom'] = { ratio: 0.0363, space_type_gen: true, default: false }
+        hash['Stairs'] = { ratio: 0.0272, space_type_gen: true, default: false }
+        hash['Storage'] = { ratio: 0.0117, space_type_gen: true, default: false }
+        hash['Utility'] = { ratio: 0.0051, space_type_gen: true, default: false }
 
       # DEER Prototypes
       when 'Asm'

data/lib/openstudio-standards/equipment/create_transformer.rb

@@ -0,0 +1,104 @@
+module OpenstudioStandards
+  # The Equipment module provides methods to create, modify, and get information about equipment
+  module Equipment
+    # @!group Create Transformer
+    # Methods to create electrical transformers.
+
+    # Add transformer to the model
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param name [String] the name of the transformer
+    # @param wired_lighting_frac [Double] the wired lighting fraction, 0-1
+    # @param transformer_size [Double] the transformer size in VA
+    # @param transformer_efficiency [Double] the transformer efficiency, 0-1
+    # @param excluded_interiorequip_key [String] key to exclude
+    # @param excluded_interiorequip_meter [String] meter to exclude
+    # @return [OpenStudio::Model::ElectricLoadCenterTransformer] the transformer object
+    def self.create_transformer(model,
+                                name: 'Transformer_1',
+                                wired_lighting_frac: nil,
+                                transformer_size: nil,
+                                transformer_efficiency: nil,
+                                excluded_interiorequip_key: '',
+                                excluded_interiorequip_meter: nil)
+      # throw an error if transformer properties are missing
+      if wired_lighting_frac.nil? || transformer_size.nil? || transformer_efficiency.nil?
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Equipment', "Either 'wired_lighting_frac', 'transformer_size', or 'transformer_efficiency' is unspecified.  Cannot add transformer.")
+        return false
+      end
+
+      # throw an error if Decepticon
+      if ['megatron', 'starscream', 'soundwave', 'shockwave', 'skywarp', 'thundercracker', 'reflector'].include? name.downcase
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Equipment', "Decepticons will corrupt the OpenStudio model. Will not add transformer.")
+        return false
+      end
+
+      # @todo default values are for testing only
+      # ems sensor for interior lighting
+      facility_int_ltg = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'InteriorLights:Electricity')
+      facility_int_ltg.setName('Facility_Int_LTG')
+
+      # declaire ems variable for transformer wired lighting portion
+      wired_ltg_var = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'Wired_LTG')
+
+      # ems program for transformer load
+      transformer_load_prog = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+      transformer_load_prog.setName('Transformer_Load_Prog')
+      transformer_load_prog_body = <<-EMS
+      SET Wired_LTG = Facility_Int_LTG*#{wired_lighting_frac}
+      EMS
+      transformer_load_prog.setBody(transformer_load_prog_body)
+
+      # ems program calling manager
+      transformer_load_prog_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+      transformer_load_prog_manager.setName('Transformer_Load_Prog_Manager')
+      transformer_load_prog_manager.setCallingPoint('AfterPredictorAfterHVACManagers')
+      transformer_load_prog_manager.addProgram(transformer_load_prog)
+
+      # ems output variable
+      wired_ltg_emsout = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, wired_ltg_var)
+      wired_ltg_emsout.setName('Wired_LTG')
+      wired_ltg_emsout.setTypeOfDataInVariable('Summed')
+      wired_ltg_emsout.setUpdateFrequency('ZoneTimeStep')
+      wired_ltg_emsout.setUnits('J')
+
+      # meter for ems output
+      wired_ltg_meter = OpenStudio::Model::MeterCustom.new(model)
+      wired_ltg_meter.setName('Wired_LTG_Electricity')
+      wired_ltg_meter.setFuelType('Electricity')
+      wired_ltg_meter.addKeyVarGroup('', 'Wired_LTG')
+
+      # meter for wired int equip
+      unless excluded_interiorequip_meter.nil?
+        wired_int_equip_meter = OpenStudio::Model::MeterCustomDecrement.new(model, 'InteriorEquipment:Electricity')
+        wired_int_equip_meter.setName('Wired_Int_EQUIP')
+        wired_int_equip_meter.setFuelType('Electricity')
+        wired_int_equip_meter.addKeyVarGroup(excluded_interiorequip_key, excluded_interiorequip_meter)
+      end
+
+      # add transformer
+      transformer = OpenStudio::Model::ElectricLoadCenterTransformer.new(model)
+      transformer.setName(name)
+      transformer.setAvailabilitySchedule(model.alwaysOnDiscreteSchedule)
+      transformer.setTransformerUsage('PowerInFromGrid')
+      transformer.setRatedCapacity(transformer_size)
+      transformer.setPhase('3')
+      transformer.setConductorMaterial('Aluminum')
+      transformer.setFullLoadTemperatureRise(150)
+      transformer.setFractionofEddyCurrentLosses(0.1)
+      transformer.setPerformanceInputMethod('NominalEfficiency')
+      transformer.setNameplateEfficiency(transformer_efficiency)
+      transformer.setPerUnitLoadforNameplateEfficiency(0.35)
+      transformer.setReferenceTemperatureforNameplateEfficiency(75)
+      transformer.setConsiderTransformerLossforUtilityCost(true)
+      transformer.addMeter('Wired_LTG_Electricity')
+      if excluded_interiorequip_meter.nil?
+        transformer.addMeter('InteriorEquipment:Electricity') # by default, add this as the second meter
+      else
+        transformer.addMeter('Wired_Int_EQUIP')
+      end
+
+      return transformer
+    end
+  end
+end

data/lib/openstudio-standards/equipment/create_typical_equipment.rb

@@ -0,0 +1,117 @@
+module OpenstudioStandards
+  # The Equipment module provides methods to create, modify, and get information about equipment
+  module Equipment
+    # @!group Create Typical Equipment
+    # Methods to create typical equipment
+
+    # Create typical equipment in a model
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @return [Boolean] returns true if successful, false if not
+    def self.create_typical_equipment(model)
+      # load equipment data
+      electric_equipment_space_type_data = JSON.parse(File.read("#{File.dirname(__FILE__)}/data/electric_equipment_space_types.json"), symbolize_names: true)
+      gas_equipment_space_type_data = JSON.parse(File.read("#{File.dirname(__FILE__)}/data/gas_equipment_space_types.json"), symbolize_names: true)
+
+      if electric_equipment_space_type_data.nil? || gas_equipment_space_type_data.nil?
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Equipment', 'Unable to load equipment space types data. No equipment will be added to model.')
+        return false
+      end
+
+      # loop over space types and apply equipment
+      model.getSpaceTypes.each do |space_type|
+        # remove existing equipment objects
+        space_type.electricEquipment.sort.each(&:remove)
+        space_type.gasEquipment.sort.each(&:remove)
+
+        # remove existing equipment objects from spaces
+        space_type.spaces.each do |space|
+          space.electricEquipment.sort.each(&:remove)
+          space.gasEquipment.sort.each(&:remove)
+        end
+
+        # get building type
+        standards_building_type = nil
+        if space_type.standardsBuildingType.is_initialized
+          standards_building_type = space_type.standardsBuildingType.get
+        end
+
+        # get equipment space type from the object
+        has_electric_equipment_space_type = space_type.additionalProperties.hasFeature('electric_equipment_space_type')
+        has_gas_equipment_space_type = space_type.additionalProperties.hasFeature('natural_gas_equipment_space_type')
+        unless has_electric_equipment_space_type || has_gas_equipment_space_type
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Equipment', "Space type '#{space_type.name}' does not have a electric_equipment_space_type or natural_gas_equipment_space_type property assigned. Ignoring space type.")
+          next
+        end
+        if has_electric_equipment_space_type
+          electric_equipment_space_type = space_type.additionalProperties.getFeatureAsString('electric_equipment_space_type').to_s
+        else
+          electric_equipment_space_type = nil
+        end
+        if has_gas_equipment_space_type
+          gas_equipment_space_type = space_type.additionalProperties.getFeatureAsString('natural_gas_equipment_space_type').to_s
+        else
+          gas_equipment_space_type = nil
+        end
+
+        if has_electric_equipment_space_type && !electric_equipment_space_type.nil? && (electric_equipment_space_type != 'na')
+          # get equipment properties for the electric equipment space type
+          electric_equipment_space_type_properties = electric_equipment_space_type_data.select { |r| (r[:electric_equipment_space_type_name] == electric_equipment_space_type) && (r[:standards_building_type] == standards_building_type) }
+          if electric_equipment_space_type_properties.empty?
+            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Equipment', "Unable to find electric equipment space type data for '#{electric_equipment_space_type}' with standards_building_type #{standards_building_type}.")
+          else
+            electric_equipment_space_type_properties = electric_equipment_space_type_properties[0]
+            elec_equip_per_area = electric_equipment_space_type_properties[:electric_equipment_per_area].to_f
+            elec_equip_frac_latent = electric_equipment_space_type_properties[:electric_equipment_fraction_latent]
+            elec_equip_frac_radiant = electric_equipment_space_type_properties[:electric_equipment_fraction_radiant]
+            elec_equip_frac_lost = electric_equipment_space_type_properties[:electric_equipment_fraction_lost]
+            if elec_equip_per_area > 0
+              definition = OpenStudio::Model::ElectricEquipmentDefinition.new(space_type.model)
+              definition.setName("#{space_type.name} Elec Equip Definition")
+              definition.setWattsperSpaceFloorArea(OpenStudio.convert(elec_equip_per_area.to_f, 'W/ft^2', 'W/m^2').get)
+              definition.resetFractionLatent unless definition.isFractionLatentDefaulted
+              definition.resetFractionRadiant unless definition.isFractionRadiantDefaulted
+              definition.resetFractionLost unless definition.isFractionLostDefaulted
+              definition.setFractionLatent(elec_equip_frac_latent.to_f) if elec_equip_frac_latent
+              definition.setFractionRadiant(elec_equip_frac_radiant.to_f) if elec_equip_frac_radiant
+              definition.setFractionLost(elec_equip_frac_lost.to_f) if elec_equip_frac_lost
+              instance = OpenStudio::Model::ElectricEquipment.new(definition)
+              instance.setName("#{space_type.name} Elec Equip")
+              instance.setSpaceType(space_type)
+            end
+          end
+        end
+
+        if has_gas_equipment_space_type && !gas_equipment_space_type.nil? && (gas_equipment_space_type != 'na')
+          # get equipment properties for the gas equipment space type
+          gas_equipment_space_type_properties = gas_equipment_space_type_data.select { |r| (r[:natural_gas_equipment_space_type_name] == gas_equipment_space_type) && (r[:standards_building_type] == standards_building_type) }
+          if gas_equipment_space_type_properties.empty?
+            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Equipment', "Unable to find gas equipment space type data for '#{gas_equipment_space_type}' with standards_building_type #{standards_building_type}.")
+          else
+            gas_equipment_space_type_properties = gas_equipment_space_type_properties[0]
+            gas_equip_per_area = gas_equipment_space_type_properties[:gas_equipment_per_area].to_f
+            gas_equip_frac_latent = gas_equipment_space_type_properties[:gas_equipment_fraction_latent]
+            gas_equip_frac_radiant = gas_equipment_space_type_properties[:gas_equipment_fraction_radiant]
+            gas_equip_frac_lost = gas_equipment_space_type_properties[:gas_equipment_fraction_lost]
+            if gas_equip_per_area > 0
+              definition = OpenStudio::Model::GasEquipmentDefinition.new(space_type.model)
+              definition.setName("#{space_type.name} Gas Equip Definition")
+              definition.setWattsperSpaceFloorArea(OpenStudio.convert(gas_equip_per_area.to_f, 'Btu/hr*ft^2', 'W/m^2').get)
+              definition.resetFractionLatent unless definition.isFractionLatentDefaulted
+              definition.resetFractionRadiant unless definition.isFractionRadiantDefaulted
+              definition.resetFractionLost unless definition.isFractionLostDefaulted
+              definition.setFractionLatent(gas_equip_frac_latent.to_f) if gas_equip_frac_latent
+              definition.setFractionRadiant(gas_equip_frac_radiant.to_f) if gas_equip_frac_radiant
+              definition.setFractionLost(gas_equip_frac_lost.to_f) if gas_equip_frac_lost
+              instance = OpenStudio::Model::GasEquipment.new(definition)
+              instance.setName("#{space_type.name} Gas Equip")
+              instance.setSpaceType(space_type)
+            end
+          end
+        end
+      end
+
+      return true
+    end
+  end
+end