Top Level Namespace

Defined Under Namespace

Instance Method Summary collapse

#calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule) ⇒ Object
#check_boolean_value(value, varname) ⇒ Object
#create_cbes_class_array ⇒ Object
#create_class_array ⇒ Object
#create_deer_class_array ⇒ Object
#create_meta_classes ⇒ Object
#distance(loc1, loc2) ⇒ Object
#get_additional_property_as_boolean(component, key, default = false) ⇒ Boolean

PRM get an additional property from an OpenStudio object as a boolean, if no such additional property, then return default value.
#get_additional_property_as_double(component, key, default = 0.0) ⇒ Double

PRM get an additional property from an OpenStudio object as a double, if no such additional property, then return default value.
#get_additional_property_as_integer(component, key, default = 0.0) ⇒ Integer

PRM get an additional property from an OpenStudio object as a double, if no such additional property, then return default value.
#get_additional_property_as_string(component, key, default = '') ⇒ String

PRM get an additional property from an OpenStudio object as a string, if no such additional property, then return default value.
#get_logs(log_type = OpenStudio::Error) ⇒ Array<String>

Get an array of all messages of a given type in the log.
#get_schedule_max_delta_t(model, surface) ⇒ Object

returns -999 if current surface does not have heating OR cooling schedule returns -997 if all adjacent surfaces does not have BOTH heating AND cooling returns nil if the surface does not have adjacent surface.
#get_total_nominal_capacity(model) ⇒ Object
#log_messages_to_file(file_path, debug = false) ⇒ Array<String>

Log the info, warning, and error messages to a file.
#log_messages_to_file_prm(file_path, debug = false) ⇒ Array

A function to export log messages specific to PRM to a log file.
#log_messages_to_runner(runner, debug = false) ⇒ Runner

Log the info, warning, and error messages to a runner.
#look_up_csv_data(csv_fname, search_criteria) ⇒ Object
#map_spacetypes ⇒ Object
#model_out_path(test_name) ⇒ Object
#necb_2011_qaqc(qaqc, model) ⇒ Object
#necb_section_test(qaqc, result_value, bool_operator, expected_value, necb_section_name, test_text, tolerance = nil) ⇒ Object
#prm_get_component_name(component) ⇒ String

This is a PRM handler to get a name from an OpenStudio object instance If the object instance does not have a name, then it will return the object name.
#prm_get_optional_handler(component, log_dir, data_key, *remaining_keys) ⇒ OpenStudio::Model::Component

This is a PRM handler function handles the .get from an optional object The handler will try to access the OpenStudio Object data key And do it recursively until all the keys have been checked and final object get or raise exception for non_initialized objects.
#prm_raise(bool, log_dir, err_msg) ⇒ Object

PRM assertion method Raise assertion if the test (bool) is failed.
#prm_read_user_data(user_data, key, default = nil) ⇒ String

PRM reading function reads user data from a hash map.
#read_space_types ⇒ Object
#remove_meta_class_file ⇒ Object
#report_path(test_name) ⇒ Object
#reset_log ⇒ Object

resets the log.
#run_dir(test_name) ⇒ Object
#sanity_check(qaqc) ⇒ Object
#save_meta_classes_to_file ⇒ Object
#sql_path(test_name) ⇒ Object
#terminate_prm_write_log(msg, log_path, debug = false) ⇒ Object

A function that writes error message to log file and stop the execution.
#validate_optional(var, model, return_value = "N/A") ⇒ Object
#workspace_path(test_name) ⇒ Object

Instance Method Details

#calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule) ⇒ `Object`

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 27

def calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule)
  max = -999
  #  #if either one of schedule does not exist then it will return the max of the existing schedule
  #  if adj_DaySchedule.nil?
  #    0.upto(23) do |hour|
  #      time = OpenStudio::Time.new(0,hour,0,0)
  #      max = cur_DaySchedule.getValue(time) if cur_DaySchedule.getValue(time) > max
  #    end
  #  elsif cur_DaySchedule.nil?
  #    0.upto(23) do |hour|
  #      time = OpenStudio::Time.new(0,hour,0,0)
  #      max = adj_DaySchedule.getValue(time) if adj_DaySchedule.getValue(time) > max
  #    end
  #  elsif (cur_DaySchedule.nil? and cur_DaySchedule.nil?)
  #    return nil
  #  end
  if cur_DaySchedule.nil? || adj_DaySchedule.nil?
    raise 'cur_DaySchedule or adj_DaySchedule is nil'
    return nil
  end

  0.upto(23) do |hour|
    time = OpenStudio::Time.new(0, hour, 0, 0)
    difference = (cur_DaySchedule.getValue(time) - adj_DaySchedule.getValue(time)).abs
    max = difference if difference > max
  end
  return max
end

#check_boolean_value(value, varname) ⇒ `Object`

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

def check_boolean_value (value,varname)
  return true if value =~ (/^(true|t|yes|y|1)$/i)
  return false if value.empty? || value =~ (/^(false|f|no|n|0)$/i)

  raise ArgumentError.new "invalid value for #{varname}: #{value}"
end

#create_cbes_class_array ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 701

def create_cbes_class_array
  prototype_buildings = [
    'MediumOffice',
    'RetailStandalone',
    'SmallOffice'
  ]

  templates = {
    'CBESPre1978' => 'CBES Pre-1978',
    'CBEST241978' => 'CBES T24 1978',
    'CBEST241992' => 'CBES T24 1992',
    'CBEST242001' => 'CBES T24 2001',
    'CBEST242005' => 'CBES T24 2005',
    'CBEST242008' => 'CBES T24 2008'
  }

  class_array = []
  templates.each_pair do |template, template_string|
    # Create Prototype base class (May not be needed...)
    # Ex: class CBESPre1978_Prototype < CBESPre1978
    class_array << "
  class #{template}_Prototype < #{template}
  attr_reader :instvarbuilding_type
  def initialize
    super()
  end
end
"

    # Create Building Specific classes for each building.
    # Example class CBESPre1978_MediumOffice
    prototype_buildings.each do |building_type|
      class_array << "
  # This class represents a prototypical #{template} #{building_type}.
  class #{template}#{building_type} < #{template}
  @@building_type = \"#{building_type}\"
  register_standard (\"#{template_string}_\#{@@building_type}\")
  attr_accessor :prototype_database
  attr_accessor :prototype_input
  attr_accessor :lookup_building_type
  attr_accessor :space_type_map
  attr_accessor :geometry_file
  attr_accessor :building_story_map
  attr_accessor :system_to_space_map

  def initialize
    super()
    @instvarbuilding_type = @@building_type
    @prototype_input = self.model_find_object(standards_data['prototype_inputs'], {'template' => @template,'building_type' => @@building_type}, nil)
    if @prototype_input.nil?
      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', \"Could not find prototype inputs for \#{{'template' => @template,'building_type' => @@building_type}}, cannot create model.\")
      raise(\"Could not find prototype inputs for #{template}#{building_type}, cannot create model.\")
      return false
    end
    @lookup_building_type = self.model_get_lookup_name(@building_type)
    #ideally we should map the data required to a instance variable.
    @geometry_file = 'geometry/' + @prototype_input['geometry_osm']
    hvac_map_file =  'geometry/' + @prototype_input['hvac_json']
    @system_to_space_map = load_hvac_map(hvac_map_file)
    self.set_variables()
  end

  # This method is used to extend the class with building-type-specific
  # methods, as defined in Prototype.SomeBuildingType.rb.  Each building type
  # has its own set of methods that change things which are not
  # common across all prototype buildings, even within a given Standard.
  def set_variables()
    # Will be overwritten in class reopen file.
    # add all building methods for now.
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the space types
  # available for this particular Standard.
  def define_space_type_map(building_type, climate_zone)
    return @space_type_map
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the HVAC system that will
  # be applied to those spaces.
  def define_hvac_system_map(building_type, climate_zone)
    return @system_to_space_map
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the building story
  # that they are located on.
  def define_building_story_map(building_type, climate_zone)
     return @building_story_map
  end

  # Does nothing unless implmented by the specific standard
  def model_modify_oa_controller(model)
  end

  # Does nothing unless implmented by the specific standard
  def model_reset_or_room_vav_minimum_damper(prototype_input, model)
  end

  # update exhuast fan efficiency
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @return [Boolean] returns true if successful, false if not
  def model_update_exhaust_fan_efficiency(model)
    return true
  end

  # Does nothing unless implmented by the specific standard
  def model_update_fan_efficiency(model)
  end

  # Get the name of the building type used in lookups.
  # For CBES, this lookup matches the DOE prototype building types.
  #
  # @param building_type [String] the building type
  # @return [String] returns the lookup name as a string
  def model_get_lookup_name(building_type)
    lookup_name = building_type
    case building_type
      when 'SmallOffice'
        lookup_name = 'Office'
      when 'MediumOffice'
        lookup_name = 'Office'
      when 'LargeOffice'
        lookup_name = 'Office'
      when 'LargeOfficeDetailed'
        lookup_name = 'Office'
      when 'RetailStandalone'
        lookup_name = 'Retail'
      when 'RetailStripmall'
        lookup_name = 'StripMall'
      when 'Office'
        lookup_name = 'Office'
    end
    return lookup_name
  end

  # hvac adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_hvac_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # swh adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_swh_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # geometry adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_geometry_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # daylighting adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_daylighting_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end
end
"
    end
  end
  return class_array
end

#create_class_array ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 6

def create_class_array
  prototype_buildings = ['FullServiceRestaurant',
                         'Hospital',
                         'HighriseApartment',
                         'LargeHotel',
                         'LargeOffice',
                         'MediumOffice',
                         'MidriseApartment',
                         'Outpatient',
                         'PrimarySchool',
                         'QuickServiceRestaurant',
                         'RetailStandalone',
                         'SecondarySchool',
                         'SmallHotel',
                         'SmallOffice',
                         'RetailStripmall',
                         'Warehouse',
                         'SuperMarket',
                         'SmallDataCenterLowITE',
                         'SmallDataCenterHighITE',
                         'LargeDataCenterLowITE',
                         'LargeDataCenterHighITE',
                         'SmallOfficeDetailed',
                         'MediumOfficeDetailed',
                         'LargeOfficeDetailed',
                         'Laboratory',
                         'College',
                         'Courthouse',
                         'TallBuilding',
                         'SuperTallBuilding']

  templates = {
    'ASHRAE9012004' => '90.1-2004',
    'ASHRAE9012007' => '90.1-2007',
    'ASHRAE9012010' => '90.1-2010',
    'ASHRAE9012013' => '90.1-2013',
    'ASHRAE901PRM2019' => '90.1-PRM-2019',
    'ASHRAE9012016' => '90.1-2016',
    'ASHRAE9012019' => '90.1-2019',
    'DOERef1980to2004' => 'DOE Ref 1980-2004',
    'DOERefPre1980' => 'DOE Ref Pre-1980',
    'NRELZNEReady2017' => 'NREL ZNE Ready 2017'
  }
  class_array = []
  templates.each_pair do |template, template_string|
    # Create Prototype base class (May not be needed...)
    # Ex: class NECB2011_Prototype < NECB2011
    class_array << "
  class #{template}_Prototype < #{template}
  attr_reader :instvarbuilding_type
  def initialize
    super()
  end
end
"

    # Create Building Specific classes for each building.
    # Example class NECB2011Hospital
    prototype_buildings.each do |name|
      class_array << "
  # This class represents a prototypical #{template} #{name}.
  class #{template}#{name} < #{template}
  @@building_type = \"#{name}\"
  register_standard (\"#{template_string}_\#{@@building_type}\")
  attr_accessor :prototype_database
  attr_accessor :prototype_input
  attr_accessor :lookup_building_type
  attr_accessor :space_type_map
  attr_accessor :geometry_file
  attr_accessor :building_story_map
  attr_accessor :system_to_space_map
  def initialize
    super()
    @instvarbuilding_type = @@building_type
    @prototype_input = self.standards_lookup_table_first(table_name: 'prototype_inputs',search_criteria: {'template' => @template,'building_type' => @@building_type })
    if @prototype_input.nil?
      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', \"Could not find prototype inputs for \#{{'template' => @template,'building_type' => @@building_type }}, cannot create model.\")
      raise(\"Could not find prototype inputs for #{template}#{name}, cannot create model.\")
      return false
    end
    @lookup_building_type = self.model_get_lookup_name(@@building_type)
    #ideally we should map the data required to a instance variable.
    @geometry_file = 'geometry/' + @prototype_input['geometry_osm']
    hvac_map_file =  'geometry/' + @prototype_input['hvac_json']
    @system_to_space_map = load_hvac_map(hvac_map_file)
    self.set_variables()
  end
  # This method is used to extend the class with building-type-specific
  # methods, as defined in Prototype.SomeBuildingType.rb.  Each building type
  # has its own set of methods that change things which are not
  # common across all prototype buildings, even within a given Standard.
  def set_variables()
    # Will be overwritten in class reopen file.
    # add all building methods for now.
    self.extend(#{name}) unless @template == 'NECB 2011'
  end
  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the space types
  # available for this particular Standard.
  def define_space_type_map(building_type, climate_zone)
    return @space_type_map
  end
  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the HVAC system that will
  # be applied to those spaces.
  def define_hvac_system_map(building_type, climate_zone)
    return @system_to_space_map
  end
  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the building story
  # that they are located on.
  def define_building_story_map(building_type, climate_zone)
     return @building_story_map
  end
  # Does nothing unless implmented by the specific standard
  def model_modify_oa_controller(model)
  end
  # Does nothing unless implmented by the specific standard
  def model_reset_or_room_vav_minimum_damper(prototype_input, model)
  end

  # update exhuast fan efficiency
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @return [Boolean] returns true if successful, false if not
  def model_update_exhaust_fan_efficiency(model)
    return true
  end

  # Does nothing unless implmented by the specific standard
  def model_update_fan_efficiency(model)
  end
  # Get the name of the building type used in lookups
  #
  # @param building_type [String] the building type
  # @return [String] returns the lookup name as a string
  # @todo Unify the lookup names and eliminate this method
  def model_get_lookup_name(building_type)
    lookup_name = building_type
    case building_type
      when 'SmallOffice'
        lookup_name = 'Office'
      when 'MediumOffice'
        lookup_name = 'Office'
      when 'LargeOffice'
        lookup_name = 'Office'
      when 'SmallOfficeDetailed'
        lookup_name = 'Office'
      when 'MediumOfficeDetailed'
        lookup_name = 'Office'
	  when 'LargeOfficeDetailed'
        lookup_name = 'Office'
      when 'RetailStandalone'
        lookup_name = 'Retail'
      when 'RetailStripmall'
        lookup_name = 'StripMall'
      when 'Office'
        lookup_name = 'Office'
    end
    return lookup_name
  end

  # daylighting adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_daylighting_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end
end
"
    end
  end

  ['NECB2011',
   'NECB2015',
   'NECB2017'].each do |template|
    # Create Prototype base class (May not be needed...)
    # Ex: class NECB2011_Prototype < NECB2011
    class_array << "
  class #{template}_Prototype < #{template}
  attr_reader :instvarbuilding_type
  def initialize
    super()
  end
end
"

    # Create Building Specific classes for each building.
    # Example class NECB2011Hospital
    prototype_buildings.each do |name|
      class_array << "
  # This class represents a prototypical #{template} #{name}.
  class #{template}#{name} < #{template}
    BUILDING_TYPE = \"#{name}\"
    TEMPLATE =  \"#{template}\"
    register_standard (\"\#{TEMPLATE}_\#{BUILDING_TYPE}\")
    attr_accessor :prototype_database
    attr_accessor :prototype_input
    attr_accessor :lookup_building_type
    attr_accessor :space_type_map
    attr_accessor :geometry_file
    attr_accessor :building_story_map
    attr_accessor :system_to_space_map

    def initialize
      super()
      @building_type = BUILDING_TYPE
      @template = TEMPLATE
      @instvarbuilding_type = @building_type
      @prototype_input = self.standards_lookup_table_first(table_name: 'prototype_inputs', search_criteria: {'template' => \"#{template}\",'building_type' => \"#{name}\" })
      if @prototype_input.nil?
        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', \"Could not find prototype inputs for \#{{'template' => \"#{template}\",'building_type' => \"#{name}\" }}, cannot create model.\")
        #puts JSON.pretty_generate(standards_data['prototype_inputs'])
        raise(\"Could not find prototype inputs for #{template} #{name}, cannot create model.\")
        return false
      end
      @lookup_building_type = self.model_get_lookup_name(@building_type)
      #ideally we should map the data required to a instance variable.
      @geometry_file = 'geometry/' + self.class.name + '.osm'
      hvac_map_file =  'geometry/' + self.class.name + '.hvac_map.json'
      # @system_to_space_map = load_hvac_map(hvac_map_file) # No HVAC map json files for NECB
      self.set_variables()
    end

  # This method is used to extend the class with building-type-specific
  # methods, as defined in Prototype.SomeBuildingType.rb.  Each building type
  # has its own set of methods that change things which are not
  # common across all prototype buildings, even within a given Standard.
    def set_variables()
    end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the space types
  # available for this particular Standard.
    def define_space_type_map(building_type, climate_zone)
      return @space_type_map
    end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the HVAC system that will
  # be applied to those spaces.
    def define_hvac_system_map(building_type, climate_zone)
      return @system_to_space_map
    end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the building story
  # that they are located on.
  def define_building_story_map(building_type, climate_zone)
     return @building_story_map
  end

  # Does nothing unless implmented by the specific standard
  def model_modify_oa_controller(model)
  end

  # Does nothing unless implmented by the specific standard
  def model_reset_or_room_vav_minimum_damper(prototype_input, model)
  end

  # update exhuast fan efficiency
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @return [Boolean] returns true if successful, false if not
  def model_update_exhaust_fan_efficiency(model)
    return true
  end

  # Does nothing unless implmented by the specific standard
  def model_update_fan_efficiency(model)
  end

end
"
    end
  end

  return class_array
end

#create_deer_class_array ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 290

def create_deer_class_array
  prototype_buildings = [
    'Asm',
    'ECC',
    'EPr',
    'ERC',
    'ESe',
    'EUn',
    'Gro',
    'Hsp',
    'Nrs',
    'Htl',
    'Mtl',
    'MBT',
    'MLI',
    'OfL',
    'OfS',
    'RFF',
    'RSD',
    'Rt3',
    'RtL',
    'RtS',
    'SCn',
    'SUn',
    'WRf',
    'GHs',
    'DMo',
    'MFm',
    'SFm'
  ]

  # Only a subset of building type and HVAC type combinations are valid
  building_to_hvac_systems = {
    'Asm' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'ECC' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'EPr' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'WLHP'
    ],
    'ERC' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'ESe' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'EUn' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG'
    ],
    'Gro' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'Hsp' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG'
    ],
    'Nrs' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'FPFC',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG'
    ],
    'Htl' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'Mtl' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'MBT' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'MFm' => [
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'MLI' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'OfL' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'OfS' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'RFF' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'RSD' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'Rt3' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF',
      'PVVE',
      'PVVG',
      'SVVE',
      'SVVG',
      'WLHP'
    ],
    'RtL' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'RtS' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'SCn' => [
      'DXEH',
      'DXGF',
      'DXHP',
      'NCEH',
      'NCGF'
    ],
    'SUn' => ['Unc'],
    'WRf' => ['DXGF']
  }

  templates = {
    'DEERPRE1975' => 'DEER Pre-1975',
    'DEER1985' => 'DEER 1985',
    'DEER1996' => 'DEER 1996',
    'DEER2003' => 'DEER 2003',
    'DEER2007' => 'DEER 2007',
    'DEER2011' => 'DEER 2011',
    'DEER2014' => 'DEER 2014',
    'DEER2015' => 'DEER 2015',
    'DEER2017' => 'DEER 2017'
  }

  class_array = []
  templates.each_pair do |template, template_string|
    # Create Prototype base class (May not be needed...)
    # Ex: class DEER_Prototype < DEER1985
    class_array << "
  class #{template}_Prototype < #{template}
  attr_reader :instvarbuilding_type
  def initialize
    super()
  end
end
"

    # Create Building Specific classes for each building.
    # Example class DEER1985AsmDXGF
    prototype_buildings.each do |building_type|
      next if building_to_hvac_systems[building_type].nil?

      building_to_hvac_systems[building_type].each do |hvac_system|
        class_array << "
  # This class represents a prototypical #{template} #{building_type} #{hvac_system}.
  class #{template}#{building_type}#{hvac_system} < #{template}
  @@building_type = \"#{building_type}\"
  @@hvac_system = \"#{hvac_system}\"
  register_standard (\"#{template_string}_\#{@@building_type}_\#{@@hvac_system}\")
  attr_accessor :prototype_database
  attr_accessor :prototype_input
  attr_accessor :lookup_building_type
  attr_accessor :space_type_map
  attr_accessor :geometry_file
  attr_accessor :building_story_map
  attr_accessor :system_to_space_map

  def initialize
    super()
    @instvarbuilding_type = @@building_type
    @prototype_input = self.standards_lookup_table_first(table_name: 'prototype_inputs', search_criteria: {'template' => @template,'building_type' => @@building_type, 'hvac_system' => @@hvac_system})
    if @prototype_input.nil?
      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', \"Could not find prototype inputs for \#{{'template' => @template,'building_type' => @@building_type, 'hvac' => @@hvac_system}}, cannot create model.\")
      raise(\"Could not find prototype inputs for #{template}#{building_type}#{hvac_system}, cannot create model.\")
      return false
    end
    @lookup_building_type = @@building_type
    #ideally we should map the data required to a instance variable.
    @geometry_file = 'geometry/' + @prototype_input['geometry_osm']
    hvac_map_file =  'geometry/' + @prototype_input['hvac_json']
    @system_to_space_map = load_hvac_map(hvac_map_file)
    self.set_variables()
  end

  # This method is used to extend the class with building-type-specific
  # methods, as defined in Prototype.SomeBuildingType.rb.  Each building type
  # has its own set of methods that change things which are not
  # common across all prototype buildings, even within a given Standard.
  def set_variables()
    # Will be overwritten in class reopen file.
    # add all building methods for now.
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the space types
  # available for this particular Standard.
  def define_space_type_map(building_type, climate_zone)
    return @space_type_map
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the HVAC system that will
  # be applied to those spaces.
  def define_hvac_system_map(building_type, climate_zone)
    return @system_to_space_map
  end

  # Returns the mapping between the names of the spaces
  # in the geometry .osm file and the building story
  # that they are located on.
  def define_building_story_map(building_type, climate_zone)
     return @building_story_map
  end

  # Does nothing unless implmented by the specific standard
  def model_modify_oa_controller(model)
  end

  # Does nothing unless implmented by the specific standard
  def model_reset_or_room_vav_minimum_damper(prototype_input, model)
  end

  # update exhuast fan efficiency
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @return [Boolean] returns true if successful, false if not
  def model_update_exhaust_fan_efficiency(model)
    return true
  end

  # Does nothing unless implmented by the specific standard
  def model_update_fan_efficiency(model)
  end

  # Get the name of the building type used in lookups.
  # For DEER, this is the building type.
  #
  # @param building_type [String] the building type
  # @return [String] returns the lookup name as a string
  def model_get_lookup_name(building_type)
    return building_type
  end

  # hvac adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_hvac_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # swh adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_swh_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # geometry adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_geometry_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end

  # daylighting adjustments specific to the prototype model
  #
  # @param model [OpenStudio::Model::Model] OpenStudio model object
  # @param building_type [String] the building type
  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
  # @param prototype_input [Hash] hash of prototype inputs
  # @return [Boolean] returns true if successful, false if not
  def model_custom_daylighting_tweaks(model, building_type, climate_zone, prototype_input)
    return true
  end
end
"
      end
    end
  end
  return class_array
end

#create_meta_classes ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 889

def create_meta_classes
  create_class_array.each { |item| eval(item) } # rubocop:disable Security/Eval
  create_deer_class_array.each { |item| eval(item) } # rubocop:disable Security/Eval
  create_cbes_class_array.each { |item| eval(item) } # rubocop:disable Security/Eval
end

#distance(loc1, loc2) ⇒ `Object`

# File 'lib/openstudio-standards/btap/utilities/necb_to_epw_map.rb', line 3

def distance(loc1, loc2)
  rad_per_deg = Math::PI / 180 # PI / 180
  rkm = 6371 # Earth radius in kilometers
  rm = rkm * 1000 # Radius in meters

  dlat_rad = (loc2[0] - loc1[0]) * rad_per_deg # Delta, converted to rad
  dlon_rad = (loc2[1] - loc1[1]) * rad_per_deg

  lat1_rad, lon1_rad = loc1.map { |i| i * rad_per_deg }
  lat2_rad, lon2_rad = loc2.map { |i| i * rad_per_deg }

  a = Math.sin(dlat_rad / 2)**2 + Math.cos(lat1_rad) * Math.cos(lat2_rad) * Math.sin(dlon_rad / 2)**2
  c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
  rm * c # Delta in meters
end

#get_additional_property_as_boolean(component, key, default = false) ⇒ `Boolean`

PRM get an additional property from an OpenStudio object as a boolean, if no such additional property, then return default value.

Parameters:

component (OpenStudio::Model:Component) —

the component to get the additional property from
key (String) —

key string
default (Boolean) (defaults to: false) —

the default to return when there is no matching key

Returns:

(Boolean) —

boolean value

# File 'lib/openstudio-standards/utilities/assertion.rb', line 67

def get_additional_property_as_boolean(component, key, default = false)
  value = default
  if component.additionalProperties.getFeatureAsBoolean(key).is_initialized
    value = component.additionalProperties.getFeatureAsBoolean(key).get
  else
    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.utilities', "Cannot find the #{key} in component: #{component.name.get}, default value #{default} is used.")
  end
  return value
end

#get_additional_property_as_double(component, key, default = 0.0) ⇒ `Double`

PRM get an additional property from an OpenStudio object as a double, if no such additional property, then return default value.

Parameters:

component (OpenStudio::Model::Component) —

the component to get the additional property from
key (String) —

key string
default (Double) (defaults to: 0.0) —

the default to return when there is no matching key

Returns:

(Double) —

Double value

# File 'lib/openstudio-standards/utilities/assertion.rb', line 99

def get_additional_property_as_double(component, key, default = 0.0)
  value = default
  if component.additionalProperties.getFeatureAsDouble(key).is_initialized
    value = component.additionalProperties.getFeatureAsDouble(key).get
  else
    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.utilities', "Cannot find the #{key} in component: #{component.name.get}, default value #{default} is used.")
  end
  return value
end

#get_additional_property_as_integer(component, key, default = 0.0) ⇒ `Integer`

PRM get an additional property from an OpenStudio object as a double, if no such additional property, then return default value.

Parameters:

component (OpenStudio::Model::Component) —

the component to get the additional property from
key (String) —

key string
default (Integer) (defaults to: 0.0) —

the default to return when there is no matching key

Returns:

(Integer) —

Integer value

# File 'lib/openstudio-standards/utilities/assertion.rb', line 83

def get_additional_property_as_integer(component, key, default = 0.0)
  value = default
  if component.additionalProperties.getFeatureAsInteger(key).is_initialized
    value = component.additionalProperties.getFeatureAsInteger(key).get
  else
    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.utilities', "Cannot find the #{key} in component: #{component.name.get}, default value #{default} is used.")
  end
  return value
end

#get_additional_property_as_string(component, key, default = '') ⇒ `String`

PRM get an additional property from an OpenStudio object as a string, if no such additional property, then return default value.

Parameters:

component (OpenStudio::Model::Component) —

the component to get the additional property from
key (String) —

key string
default (String) (defaults to: '') —

the default to return when there is no matching key

Returns:

(String) —

String value

# File 'lib/openstudio-standards/utilities/assertion.rb', line 115

def get_additional_property_as_string(component, key, default = '')
  value = default
  if component.additionalProperties.getFeatureAsString(key).is_initialized
    value = component.additionalProperties.getFeatureAsString(key).get
  else
    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.utilities', "Cannot find the #{key} in component: #{component.name.get}, default value #{default} is used.")
  end
  return value
end

#get_logs(log_type = OpenStudio::Error) ⇒ `Array<String>`

Get an array of all messages of a given type in the log

Parameters:

log_type (OpenStudio::Class) (defaults to: OpenStudio::Error) —

type of messages to return from the log, e.g. OpenStudio::Error

Returns:

(Array<String>) —

An array of strings

# File 'lib/openstudio-standards/utilities/logging.rb', line 138

def get_logs(log_type = OpenStudio::Error)
  errors = []

  $OPENSTUDIO_LOG.logMessages.each do |msg|
    if /openstudio.*/ =~ msg.logChannel
      # Skip certain messages that are irrelevant/misleading
      next if msg.logMessage.include?('UseWeatherFile') || # 'UseWeatherFile' is not yet a supported option for YearDescription
              msg.logMessage.include?('Skipping layer') || # Annoying/bogus "Skipping layer" warnings
              msg.logChannel.include?('runmanager') || # RunManager messages
              msg.logChannel.include?('setFileExtension') || # .ddy extension unexpected
              msg.logChannel.include?('Translator') || # Forward translator and geometry translator
              msg.logMessage.include?('Successive data points') || # Successive data points (2004-Jan-31 to 2001-Feb-01, ending on line 753) are greater than 1 day apart in EPW file
              msg.logMessage.include?('has multiple parents') || # Bogus errors about curves having multiple parents
              msg.logMessage.include?('does not have an Output') || # Warning from EMS translation
              msg.logMessage.include?('Prior to OpenStudio 2.6.2, this field was returning a double, it now returns an Optional double') # Warning about OS API change

      # Only fail on the errors
      if msg.logLevel == log_type
        errors << "[#{msg.logChannel}] #{msg.logMessage}"
      end
    end
  end

  return errors
end

#get_schedule_max_delta_t(model, surface) ⇒ `Object`

returns -999 if current surface does not have heating OR cooling schedule returns -997 if all adjacent surfaces does not have BOTH heating AND cooling returns nil if the surface does not have adjacent surface

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 59

def get_schedule_max_delta_t(model, surface)
  # find spaces that share that surface.
  # load the schedules for every day type of the year. for both spaces. If the space is does not have a heating schedule..assume the temperature is the -10C always for now.
  # iterate through every hour. and determine delta T
  # Store the max delta T.
  # end iteration
  # return max deltaT
  cur_space = nil
  delta_t = -998
  adjacent_surface_found = false
  atleast_one_adjacent_surface_has_schedule = false
  model.getSpaces.each do |space|
    if space == surface.space.get
      cur_space = space
    end
  end
  if cur_space.nil?
    raise "Surface: [#{surface.name}] does not belong to any space"
  end

  model.getSpaces.each do |space|
    if space == surface.space.get
      next
    end

    space.surfaces.each do |surf|
      unless surf.adjacentSurface.empty?
        adj_surface = surf.adjacentSurface.get
        if adj_surface == surface
          adjacent_surface_found = true
          unless space.thermalZone.empty?
            adj_surface_thermal_zone = space.thermalZone.get
            cur_surface_thermal_zone = cur_space.thermalZone.get
            unless adj_surface_thermal_zone.thermostatSetpointDualSetpoint.empty?
              adj_thermostat = adj_surface_thermal_zone.thermostatSetpointDualSetpoint.get
              cur_thermostat = cur_surface_thermal_zone.thermostatSetpointDualSetpoint.get
              # if current surface does not have a thermostat schedule, then it will return -999 instead of nil because nil is reserved for surfaces without adjacent surface
              if cur_thermostat.getHeatingSchedule.empty? || cur_thermostat.getCoolingSchedule.empty?
                return -999
              end
              # after this point current surface should have BOTH heating and cooling schedule
              # if adjacent surface does not have a heating OR cooling schedule it will be skipped
              if adj_thermostat.getHeatingSchedule.empty? || adj_thermostat.getCoolingSchedule.empty?
                next
              else
                atleast_one_adjacent_surface_has_schedule = true
              end

              startDate = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 1, 2009)
              endDate = OpenStudio::Date.new(OpenStudio::MonthOfYear.new(1), 7, 2009)

              adj_surface_heating_day_schedule_array = adj_thermostat.getHeatingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless adj_thermostat.getHeatingSchedule.empty?
              adj_surface_cooling_day_schedule_array = adj_thermostat.getCoolingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless adj_thermostat.getCoolingSchedule.empty?
              cur_surface_heating_day_schedule_array = cur_thermostat.getHeatingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless cur_thermostat.getHeatingSchedule.empty?
              cur_surface_cooling_day_schedule_array = cur_thermostat.getCoolingSchedule.get.to_ScheduleRuleset.get.getDaySchedules(startDate, endDate) unless cur_thermostat.getCoolingSchedule.empty?
              delta_t = -998
              heating_delta_t = []
              cooling_delta_t = []
              1.upto(7) do |i|
                puts 'mee mee mee'
                puts calculate_max_delta_t(adj_surface_heating_day_schedule_array[i - 1], cur_surface_heating_day_schedule_array[i - 1])
                heating_delta_t << calculate_max_delta_t(adj_surface_heating_day_schedule_array[i - 1], cur_surface_heating_day_schedule_array[i - 1])
                cooling_delta_t << calculate_max_delta_t(adj_surface_cooling_day_schedule_array[i - 1], cur_surface_cooling_day_schedule_array[i - 1])
              end
              delta_t = [heating_delta_t.max, cooling_delta_t.max].max
              puts "delta_t: #{delta_t}"
            end
          end
        end
      end
    end
  end
  # adjacent_surface_found ? (atleast_one_adjacent_surface_has_schedule ? (return delta_t) : (return -997)) : (return nil)
  if adjacent_surface_found
    if atleast_one_adjacent_surface_has_schedule
      return delta_t
    else
      return -997
    end
  else
    return nil
  end
end

#get_total_nominal_capacity(model) ⇒ `Object`

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

def get_total_nominal_capacity (model)
  total_nominal_capacity = 0
  model.getSpaces.sort.each do |space|
    unless space.thermalZone.empty?
      zone_name = space.thermalZone.get.name.get.upcase
      area = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Area' AND RowName='#{zone_name}'")
      area = validate_optional(area, model, -1)
      multiplier = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='Multipliers' AND RowName='#{zone_name}'")
      multiplier = validate_optional(multiplier, model, -1)
      area_per_person = model.sqlFile().get().execAndReturnFirstDouble("SELECT Value FROM TabularDataWithStrings WHERE ReportName='InputVerificationandResultsSummary' AND ReportForString='Entire Facility' AND TableName='Zone Summary' AND ColumnName='People' AND RowName='#{zone_name}'")
      area_per_person = validate_optional(area_per_person, model, -1)
      next if area_per_person == 0
      puts "area: #{area}  multiplier: #{multiplier}   area_per_person: #{area_per_person}"
      total_nominal_capacity += area*multiplier/area_per_person
    end
  end
  return total_nominal_capacity
end

#log_messages_to_file(file_path, debug = false) ⇒ `Array<String>`

Log the info, warning, and error messages to a file.

runner @param [file_path] The path to the log file debug @param [Boolean] If true, include the debug messages in the log

Returns:

(Array<String>) —

The array of messages, which can be used elsewhere.

# File 'lib/openstudio-standards/utilities/logging.rb', line 91

def log_messages_to_file(file_path, debug = false)
  messages = []

  File.open(file_path, 'w') do |file|
    $OPENSTUDIO_LOG.logMessages.each do |msg|
      # DLM: you can filter on log channel here for now
      if /openstudio.*/ =~ msg.logChannel # /openstudio\.model\..*/
        # Skip certain messages that are irrelevant/misleading
        next if msg.logMessage.include?('UseWeatherFile') || # 'UseWeatherFile' is not yet a supported option for YearDescription
                msg.logMessage.include?('Skipping layer') || # Annoying/bogus "Skipping layer" warnings
                msg.logChannel.include?('runmanager') || # RunManager messages
                msg.logChannel.include?('setFileExtension') || # .ddy extension unexpected
                msg.logChannel.include?('Translator') || # Forward translator and geometry translator
                msg.logMessage.include?('Successive data points') || # Successive data points (2004-Jan-31 to 2001-Feb-01, ending on line 753) are greater than 1 day apart in EPW file
                msg.logMessage.include?('has multiple parents') || # Bogus errors about curves having multiple parents
                msg.logMessage.include?('does not have an Output') || # Warning from EMS translation
                msg.logMessage.include?('Prior to OpenStudio 2.6.2, this field was returning a double, it now returns an Optional double') # Warning about OS API change

        # Report the message in the correct way
        if msg.logLevel == OpenStudio::Info
          s = "INFO  #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Warn
          s = "WARN  #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Error
          s = "ERROR #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Debug && debug
          s = "DEBUG #{msg.logMessage}"
          file.puts(s)
          messages << s
        end
      end
    end
  end

  return messages
end

#log_messages_to_file_prm(file_path, debug = false) ⇒ `Array`

A function to export log messages specific to PRM to a log file.

Parameters:

file_path (String) —

the file path to the log file
debug (Boolean) (defaults to: false) —

debug mode

Returns:

(Array) —

array of message strings

# File 'lib/openstudio-standards/utilities/logging.rb', line 55

def log_messages_to_file_prm(file_path, debug = false)
  messages = []

  File.open(file_path, 'w') do |file|
    $OPENSTUDIO_LOG.logMessages.each do |msg|
      # only apply to prm
      if msg.logChannel.casecmp? 'prm.log'
        # Report the message in the correct way
        if msg.logLevel == OpenStudio::Info
          s = "[#{msg.logChannel}] INFO  #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Warn
          s = "[#{msg.logChannel}] WARN  #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Error
          s = "[#{msg.logChannel}] ERROR #{msg.logMessage}"
          file.puts(s)
          messages << s
        elsif msg.logLevel == OpenStudio::Debug && debug
          s = "[#{msg.logChannel}] DEBUG #{msg.logMessage}"
          file.puts(s)
          messages << s
        end
      end
    end
  end
  return messages
end

#log_messages_to_runner(runner, debug = false) ⇒ `Runner`

Log the info, warning, and error messages to a runner.

runner @param [Runner] The Measure runner to add the messages to debug @param [Boolean] If true, include the debug messages in the log

Returns:

(Runner) —

The same Measure runner, with messages from the openstudio-standards library added

# File 'lib/openstudio-standards/utilities/logging.rb', line 10

def log_messages_to_runner(runner, debug = false)
  $OPENSTUDIO_LOG.logMessages.each do |msg|
    # DLM: you can filter on log channel here for now
    if /openstudio.*/ =~ msg.logChannel # /openstudio\.model\..*/
      # Skip certain messages that are irrelevant/misleading
      next if msg.logMessage.include?('UseWeatherFile') || # 'UseWeatherFile' is not yet a supported option for YearDescription
              msg.logMessage.include?('Skipping layer') || # Annoying/bogus "Skipping layer" warnings
              msg.logChannel.include?('runmanager') || # RunManager messages
              msg.logChannel.include?('setFileExtension') || # .ddy extension unexpected
              msg.logChannel.include?('Translator') || # Forward translator and geometry translator
              msg.logMessage.include?('Successive data points') || # Successive data points (2004-Jan-31 to 2001-Feb-01, ending on line 753) are greater than 1 day apart in EPW file
              msg.logMessage.include?('has multiple parents') || # Bogus errors about curves having multiple parents
              msg.logMessage.include?('does not have an Output') || # Warning from EMS translation
              msg.logMessage.include?('Prior to OpenStudio 2.6.2, this field was returning a double, it now returns an Optional double') # Warning about OS API change

      # Report the message in the correct way
      if msg.logLevel == OpenStudio::Info
        runner.registerInfo(msg.logMessage)
      elsif msg.logLevel == OpenStudio::Warn
        runner.registerWarning("[#{msg.logChannel}] #{msg.logMessage}")
      elsif msg.logLevel == OpenStudio::Error
        runner.registerError("[#{msg.logChannel}] #{msg.logMessage}")
      elsif msg.logLevel == OpenStudio::Debug && debug
        runner.registerInfo("DEBUG - #{msg.logMessage}")
      end
    end
  end
end

#look_up_csv_data(csv_fname, search_criteria) ⇒ `Object`

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

def look_up_csv_data(csv_fname, search_criteria)
  options = { :headers    => :first_row,
    :converters => [ :numeric ] }
  unless File.exist?(csv_fname)
    raise ("File: [#{csv_fname}] Does not exist")
  end
  # we'll save the matches here
  matches = nil
  # save a copy of the headers
  headers = nil
  CSV.open( csv_fname, "r", options ) do |csv|

    # Since CSV includes Enumerable we can use 'find_all'
    # which will return all the elements of the Enumerble for
    # which the block returns true

    matches = csv.find_all do |row|
      match = true
      search_criteria.keys.each do |key|
        match = match && ( row[key].strip == search_criteria[key].strip )
      end
      match
    end
    headers = csv.headers
  end
  #puts matches
  raise("More than one match") if matches.size > 1
  puts "Zero matches found for [#{search_criteria}]" if matches.size == 0
  #return matches[0]
  return matches[0]
end

#map_spacetypes ⇒ `Object`

# File 'lib/openstudio-standards/btap/utilities/space_type.rb', line 57

def map_spacetypes()

  map_list = CSV.open("cold_lake_map.csv", headers: :first_row).map(&:to_h)
  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
  Dir.glob(path) do |osm_file|
    model = BTAP::FileIO::load_osm(osm_file)
    model.getSpaceTypes.each do |st|
      map_item = map_list.select { |item| item["Original Spacetype Name"] == st.name.get }
      unless map_item.empty?
        new_name = map_item.first()['New-StandardsBuildingType'].to_s + '-'+map_item.first()['New-StandardSpaceType'].to_s
        st.setName(new_name)
        st.setStandardsBuildingType(map_item.first()["New-StandardsBuildingType"])
        st.setStandardsSpaceType(map_item.first()["New-StandardSpaceType"])
        puts st
      end
    end
    BTAP::FileIO::save_osm(model,File.join(__dir__,File.basename(osm_file)))
  end
end

#model_out_path(test_name) ⇒ `Object`



11
12
13

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 11

def model_out_path(test_name)
  "#{run_dir(test_name)}/ExampleModel.osm"
end

#necb_2011_qaqc(qaqc, model) ⇒ `Object`

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

def necb_2011_qaqc(qaqc, model)
  #Now perform basic QA/QC on items for NECB2011
  qaqc[:information] = []
  qaqc[:warnings] =[]
  qaqc[:errors] = []
  qaqc[:unique_errors]=[]


  #    #Padmassun's Code Start
  csv_file_name ="#{File.dirname(__FILE__)}/necb_2011_spacetype_info.csv"
  puts csv_file_name
  qaqc[:spaces].each do |space|
    building_type =""
    space_type =""
    if space[:space_type_name].include? 'Space Function '
      space_type = (space[:space_type_name].to_s.rpartition('Space Function '))[2].strip
      building_type = 'Space Function'
    elsif space[:space_type_name].include? ' WholeBuilding'
      space_type = (space[:space_type_name].to_s.rpartition(' WholeBuilding'))[0].strip
      building_type = 'WholeBuilding'
    end
    row = look_up_csv_data(csv_file_name,{2 => space_type, 1 => building_type})
    if row.nil?
      #raise ("space type of [#{space_type}] and/or building type of [#{building_type}] was not found in the excel sheet for space: [#{space[:name]}]")
      qaqc[:ruby_warnings] << "space type of [#{space_type}] and/or building type of [#{building_type}] was not found in the excel sheet for space: [#{space[:name]}]"
      puts "space type of [#{space_type}] and/or building type of [#{building_type}] was not found in the excel sheet for space: [#{space[:name]}]"
    else
      #correct the data from the csv file to include a multiplier of 0.9 for specific space types.

      reduceLPDSpaces = ["Classroom/lecture/training", "Conf./meet./multi-purpose", "Lounge/recreation",
        "Washroom-sch-A", "Washroom-sch-B", "Washroom-sch-C", "Washroom-sch-D", "Washroom-sch-E",
        "Washroom-sch-F", "Washroom-sch-G", "Washroom-sch-H", "Washroom-sch-I", "Dress./fitt. - performance arts",
        "Locker room", "Retail - dressing/fitting","Locker room-sch-A","Locker room-sch-B","Locker room-sch-C",
        "Locker room-sch-D","Locker room-sch-E","Locker room-sch-F","Locker room-sch-G","Locker room-sch-H",
        "Locker room-sch-I", "Office - open plan - occsens", "Office - enclosed - occsens", "Storage area - occsens",
        "Hospital - medical supply - occsens", "Storage area - refrigerated - occsens"]

      if reduceLPDSpaces.include?(space_type)
        row[3] = row[3]*0.9
        puts "\n============================\nspace_type: #{space_type}\n============================\n"
      end

      # Start of Space Compliance
      necb_section_name = "NECB2011-Section 8.4.3.6"
      data = {}
      data[:lighting_per_area] 		        = [ row[3],'==',space[:lighting_w_per_m2] , "Table 4.2.1.6"     ,1 ] unless space[:lighting_w_per_m2].nil?
      data[:occupancy_per_area]           = [ row[4],'==',space[:occ_per_m2]        , "Table A-8.4.3.3.1" ,3 ] unless space[:occ_per_m2].nil?
      data[:occupancy_schedule]           = [ row[5],'==',space[:occupancy_schedule], "Table A-8.4.3.3.1" ,nil ] unless space[:occupancy_schedule].nil?
      data[:electric_equipment_per_area]  = [ row[6],'==',space[:electric_w_per_m2] , "Table A-8.4.3.3.1" ,1 ] unless space[:electric_w_per_m2].nil?
      data.each do |key,value|
        #puts key
        necb_section_test(
          qaqc,
          value[0],
          value[1],
          value[2],
          value[3],
          "[SPACE][#{space[:name]}]-[TYPE:][#{space_type}]#{key}",
          value[4]
        )
      end
    end#space Compliance
  end
  #Padmassun's Code End


  # Envelope
  necb_section_name = "NECB2011-Section 3.2.1.4"
  #store hdd in short form
  hdd = qaqc[:geography][:hdd]
  #calculate fdwr based on hdd.
  fdwr = 0
  if hdd < 4000
    fdwr = 0.40
  elsif hdd >= 4000 and hdd <=7000
    fdwr = (2000-0.2 * hdd)/3000
  elsif hdd >7000
    fdwr = 0.20
  end
  #hardset srr to 0.05
  srr = 0.05
  #create table of expected values and results.
  data = {}
  data[:fenestration_to_door_and_window_percentage]  = [ fdwr * 100,qaqc[:envelope][:fdwr].round(3)]
  data[:skylight_to_roof_percentage]  = [  srr * 100,qaqc[:envelope][:srr].round(3)]
  #perform test. result must be less than or equal to.
  data.each {|key,value| necb_section_test(
      qaqc,
      value[0],
      '>=',
      value[1],
      necb_section_name,
      "[ENVELOPE]#{key}",
      1 #padmassun added tollerance
    )
  }

  #Infiltration
  necb_section_name = "NECB2011-Section 8.4.3.6"
  qaqc[:spaces].each do |spaceinfo|
    data = {}
    data[:infiltration_method] 		= [ "Flow/ExteriorArea", spaceinfo[:infiltration_method] , nil ]
    data[:infiltration_flow_per_m2] = [ 0.00025,			 spaceinfo[:infiltration_flow_per_m2], 5 ]
    data.each do |key,value|
      #puts key
      necb_section_test(
        qaqc,
        value[0],
        '==',
        value[1],
        necb_section_name,
        "[SPACE][#{spaceinfo[:name]}]-#{key}",
        value[2]
      )
    end
  end
  #Exterior Opaque
  necb_section_name = "NECB2011-Section 3.2.2.2"
  climate_index = NECB2011.new().get_climate_zone_index(qaqc[:geography][:hdd])
  result_value_index = 6
  round_precision = 3
  data = {}
  data[:ext_wall_conductances]        =  [0.315,0.278,0.247,0.210,0.210,0.183,qaqc[:envelope][:outdoor_walls_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:outdoor_walls_average_conductance_w_per_m2_k].nil?
  data[:ext_roof_conductances]        =  [0.227,0.183,0.183,0.162,0.162,0.142,qaqc[:envelope][:outdoor_roofs_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:outdoor_roofs_average_conductance_w_per_m2_k].nil?
  data[:ext_floor_conductances]       =  [0.227,0.183,0.183,0.162,0.162,0.142,qaqc[:envelope][:outdoor_floors_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:outdoor_floors_average_conductance_w_per_m2_k].nil?

  data.each {|key,value| necb_section_test(
      qaqc,
      value[result_value_index],
      '==',
      value[climate_index],
      necb_section_name,
      "[ENVELOPE]#{key}",
      round_precision
    )
  }
  #Exterior Fenestration
  necb_section_name = "NECB2011-Section 3.2.2.3"
  climate_index = NECB2011.new().get_climate_zone_index(qaqc[:geography][:hdd])
  result_value_index = 6
  round_precision = 3
  data = {}
  data[:ext_window_conductances]      =     [2.400,2.200,2.200,2.200,2.200,1.600,qaqc[:envelope][:windows_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:windows_average_conductance_w_per_m2_k].nil?
  data[:ext_door_conductances]        =     [2.400,2.200,2.200,2.200,2.200,1.600,qaqc[:envelope][:doors_average_conductance_w_per_m2_k]]   unless qaqc[:envelope][:doors_average_conductance_w_per_m2_k].nil?
  data[:ext_overhead_door_conductances] =   [2.400,2.200,2.200,2.200,2.200,1.600,qaqc[:envelope][:overhead_doors_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:overhead_doors_average_conductance_w_per_m2_k].nil?
  data[:ext_skylight_conductances]  =       [2.400,2.200,2.200,2.200,2.200,1.600,qaqc[:envelope][:skylights_average_conductance_w_per_m2_k]] unless qaqc[:envelope][:skylights_average_conductance_w_per_m2_k].nil?
  data.each do |key,value|

    #puts key
    necb_section_test(
      qaqc,
      value[result_value_index].round(round_precision),
      '==',
      value[climate_index].round(round_precision),
      necb_section_name,
      "[ENVELOPE]#{key}",
      round_precision
    )
  end
  #Exterior Ground surfaces
  necb_section_name = "NECB2011-Section 3.2.3.1"
  climate_index = NECB2011.new().get_climate_zone_index(qaqc[:geography][:hdd])
  result_value_index = 6
  round_precision = 3
  data = {}
  data[:ground_wall_conductances]  = [ 0.568,0.379,0.284,0.284,0.284,0.210, qaqc[:envelope][:ground_walls_average_conductance_w_per_m2_k] ]  unless qaqc[:envelope][:ground_walls_average_conductance_w_per_m2_k].nil?
  data[:ground_roof_conductances]  = [ 0.568,0.379,0.284,0.284,0.284,0.210, qaqc[:envelope][:ground_roofs_average_conductance_w_per_m2_k] ]  unless qaqc[:envelope][:ground_roofs_average_conductance_w_per_m2_k].nil?
  data[:ground_floor_conductances] = [ 0.757,0.757,0.757,0.757,0.757,0.379, qaqc[:envelope][:ground_floors_average_conductance_w_per_m2_k] ] unless qaqc[:envelope][:ground_floors_average_conductance_w_per_m2_k].nil?
  data.each {|key,value| necb_section_test(
      qaqc,
      value[result_value_index],
      '==',
      value[climate_index],
      necb_section_name,
      "[ENVELOPE]#{key}",
      round_precision
    )
  }
  #Zone Sizing and design supply temp tests
  necb_section_name = "NECB2011-?"
  qaqc[:thermal_zones].each do |zoneinfo|
    #    skipping undefined schedules
    if zoneinfo[:name].to_s.include?"- undefined -"
      next
    end
    data = {}
    data[:heating_sizing_factor] = [1.3 , zoneinfo[:heating_sizing_factor]]
    data[:cooling_sizing_factor] = [1.1 ,zoneinfo[:cooling_sizing_factor]]
    data[:heating_design_supply_air_temp] =   [43.0, zoneinfo[:zone_heating_design_supply_air_temperature] ] #unless zoneinfo[:zone_heating_design_supply_air_temperature].nil?
    data[:cooling_design_supply_temp] 	=   [13.0, zoneinfo[:zone_cooling_design_supply_air_temperature] ]
    data.each do |key,value|
      #puts key
      necb_section_test(
        qaqc,
        value[0],
        '==',
        value[1],
        necb_section_name,
        "[ZONE][#{zoneinfo[:name]}] #{key}",
        round_precision
      )
    end
  end
  #Air flow sizing check
  #determine correct economizer usage according to section 5.2.2.7 of NECB2011
  necb_section_name = "NECB2011-5.2.2.7"
  qaqc[:air_loops].each do |air_loop_info|
    #    air_loop_info[:name]
    #    air_loop_info[:thermal_zones]
    #    air_loop_info[:total_floor_area_served]
    #    air_loop_info[:cooling_coils][:dx_single_speed]
    #    air_loop_info[:cooling_coils][:dx_two_speed]
    #    air_loop_info[:supply_fan][:max_air_flow_rate]
    #
    #    air_loop_info[:heating_coils][:coil_heating_gas][:nominal_capacity]
    #    air_loop_info[:heating_coils][:coil_heating_electric][:nominal_capacity]
    #    air_loop_info[:heating_coils][:coil_heating_water][:nominal_capacity]
    #
    #    air_loop_info[:economizer][:control_type]

    capacity = -1.0

    if !air_loop_info[:cooling_coils][:dx_single_speed][0].nil?
      puts "air_loop_info[:heating_coils][:coil_heating_gas][0][:nominal_capacity]"
      capacity = air_loop_info[:cooling_coils][:dx_single_speed][0][:nominal_total_capacity_w]
    elsif !air_loop_info[:cooling_coils][:dx_two_speed][0].nil?
      puts "capacity = air_loop_info[:heating_coils][:coil_heating_electric]"
      capacity = air_loop_info[:cooling_coils][:dx_two_speed][0][:cop_high]
    end
    puts capacity
    if capacity == -1.0
      #This should not happen
      puts "air_loop_info[:heating_coils] does not have a capacity or the type is not gas/electric/water for #{air_loop_info[:name]}"
    else
      #check for correct economizer usage
      puts "air_loop_info[:supply_fan][:max_air_flow_rate]: #{air_loop_info[:supply_fan][:max_air_flow_rate]}"
      unless air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s] == -1.0
        #capacity should be in kW
        if capacity > 20000 or air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s]*1000 >1500
          #diff enth
          #puts "diff"
          necb_section_test(
            qaqc,
            "DifferentialEnthalpy",
            '==',
            air_loop_info[:economizer][:control_type],
            necb_section_name,
            "[AIR LOOP][#{air_loop_info[:name]}][:economizer][:control_type]"
          )
        else
          #no economizer
          #puts "no econ"
          necb_section_test(
            qaqc,
            'NoEconomizer',
            '==',
            air_loop_info[:economizer][:control_type],
            necb_section_name,
            "[AIR LOOP][#{air_loop_info[:name]}][:economizer][:control_type]"
          )
        end
      end
    end
  end

  # @todo ?
  necb_section_name = "NECB2011-5.2.10.1"
  qaqc[:air_loops].each do |air_loop_info|
    unless air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s] == -1.0
      weather_file_path = model.weatherFile.get.path.get.to_s
      stat_file_path = weather_file_path.gsub('.epw', '.stat')
      stat_file = OpenstudioStandards::Weather::StatFile.new(stat_file_path)
      db990 = stat_file.heating_design_info[2]
      hrv_calc = 0.00123 * air_loop_info[:outdoor_air_L_per_s] * (21 - db990) #=AP46*(21-O$1)
      hrv_reqd = hrv_calc > 150 ? true : false
      #qaqc[:information] << "[Info][TEST-PASS][#{necb_section_name}]:#{test_text} result value:#{result_value} #{bool_operator} expected value:#{expected_value}"
      hrv_present = false
      unless air_loop_info[:heat_exchanger].empty?
        hrv_present = true
      end
      necb_section_test(
        qaqc,
        hrv_reqd,
        '==',
        hrv_present,
        necb_section_name,
        "[AIR LOOP][:heat_exchanger] for [#{air_loop_info[:name]}] is present?"
      )

    end
  end

  necb_section_name = "NECB2011-5.2.3.3"
  qaqc[:air_loops].each do |air_loop_info|
    #necb_clg_cop = air_loop_info[:cooling_coils][:dx_single_speed][:cop] #*assuming that the cop is defined correctly*
    if air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s].nil?
      qaqc[:ruby_warnings] << "air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s] is nil"
      next
    end
    necb_supply_fan_w = (air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s]*1000*1.6).round(2)

    if air_loop_info[:name].include? "PSZ"
      necb_supply_fan_w = (air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s]*1000*1.6).round(2)
    elsif air_loop_info[:name].include? "VAV"
      necb_supply_fan_w = (air_loop_info[:supply_fan][:max_air_flow_rate_m3_per_s]*1000*2.65).round(2)
    end

    if air_loop_info[:supply_fan][:rated_electric_power_w].nil?
      qaqc[:ruby_warnings] << "air_loop_info[:supply_fan][:rated_electric_power_w] is nil"
      next
    end

    supply_fan_w = (air_loop_info[:supply_fan][:rated_electric_power_w]).round(3)
    absolute_diff = (necb_supply_fan_w - supply_fan_w).to_f.abs
    if absolute_diff < 10
      #This case should ALWAYS PASS
      necb_section_test(
        qaqc,
        10,
        '>=',
        absolute_diff,
        necb_section_name,
        "[AIR LOOP][#{air_loop_info[:name]}][:supply_fan][:rated_electric_power_w] [#{supply_fan_w}] Absolute Difference from NECB value [#{necb_supply_fan_w}]"
      )
      next
    else
      #The test should pass if and only if the percent difference is less than 10%
      percent_diff = ((necb_supply_fan_w - supply_fan_w).to_f.abs/necb_supply_fan_w * 100).round(3)
      necb_section_test(
        qaqc,
        10,
        '>=',
        percent_diff,
        necb_section_name,
        "[AIR LOOP][#{air_loop_info[:name]}][:supply_fan][:rated_electric_power_w] [#{supply_fan_w}] Percent Diff from NECB value [#{necb_supply_fan_w}]"
      )
    end
  end

  necb_section_name = "SANITY-??"
  qaqc[:plant_loops].each do |plant_loop_info|
    pump_head = plant_loop_info[:pumps][0][:head_pa]
    flow_rate = plant_loop_info[:pumps][0][:water_flow_m3_per_s]*1000
    hp_check = ((flow_rate*60*60)/1000*1000*9.81*pump_head*0.000101997)/3600000
    puts "\npump_head #{pump_head}"
    puts "name: #{qaqc[:building][:name]}"
    puts "name: #{plant_loop_info[:name]}"
    puts "flow_rate #{flow_rate}"
    puts "hp_check #{hp_check}\n"
    pump_power_hp = plant_loop_info[:pumps][0][:electric_power_w]/1000*0.746
    percent_diff = (hp_check - pump_power_hp).to_f.abs/hp_check * 100

    if percent_diff.nan?
      qaqc[:ruby_warnings] << "(hp_check - pump_power_hp).to_f.abs/hp_check * 100 for #{plant_loop_info[:name]} is NaN"
      next
    end

    necb_section_test(
      qaqc,
      20, #diff of 20%
      '>=',
      percent_diff,
      necb_section_name,
      "[PLANT LOOP][#{plant_loop_info[:name]}][:pumps][0][:electric_power_hp] [#{pump_power_hp}] Percent Diff from NECB value [#{hp_check}]"
    )

  end
end

#necb_section_test(qaqc, result_value, bool_operator, expected_value, necb_section_name, test_text, tolerance = nil) ⇒ `Object`

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

def necb_section_test(qaqc,result_value,bool_operator,expected_value,necb_section_name,test_text,tolerance = nil)
  test = "eval_failed"
  command = ''
  if tolerance.is_a?(Integer)
    command = "#{result_value}.round(#{tolerance}) #{bool_operator} #{expected_value}.round(#{tolerance})"
  elsif expected_value.is_a?(String) and result_value.is_a?(String)
    command = "'#{result_value}' #{bool_operator} '#{expected_value}'"
  else
    command = "#{result_value} #{bool_operator} #{expected_value}"
  end
  test = eval(command)
  test == 'true' ? true :false
  raise ("Eval command failed #{test}") if !!test != test
  if test
    qaqc[:information] << "[Info][TEST-PASS][#{necb_section_name}]:#{test_text} result value:#{result_value} #{bool_operator} expected value:#{expected_value}"
  else
    qaqc[:errors] << "[ERROR][TEST-FAIL][#{necb_section_name}]:#{test_text} expected value:#{expected_value} #{bool_operator} result value:#{result_value}"
    unless (expected_value == -1.0 or expected_value == 'N/A')
      qaqc[:unique_errors] << "[ERROR][TEST-FAIL][#{necb_section_name}]:#{test_text} expected value:#{expected_value} #{bool_operator} result value:#{result_value}"
    end
  end
end

#prm_get_component_name(component) ⇒ `String`

This is a PRM handler to get a name from an OpenStudio object instance If the object instance does not have a name, then it will return the object name.

Parameters:

component (OpenStudio::Model:Component) —

an OpenStudio object

Returns:

(String) —

the name of the instance or object name

# File 'lib/openstudio-standards/utilities/assertion.rb', line 51

def prm_get_component_name(component)
  return 'Model' if component.is_a?(OpenStudio::Model::Model)

  name = component.iddObjectType.valueName.to_s
  if component.name.is_initialized
    name = component.name.get
  end
  return name
end

#prm_get_optional_handler(component, log_dir, data_key, *remaining_keys) ⇒ `OpenStudio::Model::Component`

This is a PRM handler function handles the .get from an optional object The handler will try to access the OpenStudio Object data key And do it recursively until all the keys have been checked and final object get or raise exception for non_initialized objects.

Parameters:

component (OpenStudio::Model::Component) —

an OpenStudio object
log_dir (string) —

directory to save the log
data_key (string) —

The data key to retrieve the data from the OpenStudio object
remaining_keys (str) —

Any additional keys in the path

Returns:

(OpenStudio::Model::Component) —

the OpenStudio Object or exception raise

# File 'lib/openstudio-standards/utilities/assertion.rb', line 39

def prm_get_optional_handler(component, log_dir, data_key, *remaining_keys)
  target_data = component.send(data_key)
  prm_raise(target_data.is_initialized, log_dir, "Failed to retrieve data: #{data_key} from #{prm_get_component_name(component)}")
  target_data_get = target_data.get
  return remaining_keys.empty? ? target_data_get : prm_get_optional_handler(target_data_get, log_dir, remaining_keys[0], *remaining_keys[1...])
end

#prm_raise(bool, log_dir, err_msg) ⇒ `Object`

PRM assertion method Raise assertion if the test (bool) is failed

Before raise the exception, the method will generate the prm.log for debugging

Parameters:

bool (Boolean, Object) —

an object for truthy evaluation
log_dir (String) —

log file directory
err_msg (String) —

message raise the exception

# File 'lib/openstudio-standards/utilities/assertion.rb', line 12

def prm_raise(bool, log_dir, err_msg)
  unless bool
    # OpenStudio.logFree(OpenStudio::Debug, 'prm.log', log_msg)
    log_messages_to_file_prm("#{log_dir}/prm.log", true)
    raise PRMError, "#{err_msg} - Check debug log at #{log_dir}/prm.log for more information"
  end
end

#prm_read_user_data(user_data, key, default = nil) ⇒ `String`

PRM reading function reads user data from a hash map. Handles key existence, value is nil and value string is empty

Parameters:

user_data (Hash) —

a hash contains a user data
key (String) —

key string
default (Object) (defaults to: nil) —

values assigned if the data is not available.

Returns:

(String) —

a string



26
27
28

# File 'lib/openstudio-standards/utilities/assertion.rb', line 26

def prm_read_user_data(user_data, key, default = nil)
  return user_data.key?(key) && !user_data[key].nil? && !user_data[key].to_s.empty? ? user_data[key] : default
end

#read_space_types ⇒ `Object`

# File 'lib/openstudio-standards/btap/utilities/space_type.rb', line 13

def read_space_types()
  path = "/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/data/geometry/DND*.osm"
  spacetype_list = []
  Dir.glob(path) do |osm_file|
    model = BTAP::FileIO::load_osm(osm_file)
    standard = NECB2011.new()
    model.getSpaces.each do |space|
      unless space.spaceType.empty?
        name = space.spaceType.get.name.get
        bt = space.spaceType.get.standardsBuildingType.get unless space.spaceType.get.standardsBuildingType.empty?
        st = space.spaceType.get.standardsSpaceType.get unless space.spaceType.get.standardsSpaceType.empty?
        spacetype_list << {'name': name, 'Original-StandardsBuildingType': bt, 'Original-StandardSpaceType': st}

      end
    end

  end
  unique_list = spacetype_list.uniq.sort_by { |st| st[:name] }


  CSV.open("data.csv", "wb") do |csv|
    csv << unique_list.first.keys # adds the attributes name on the first line
    unique_list.each do |hash|
      csv << hash.values
    end
  end

  standard_space_type_list = Standard.build('NECB2011').standards_data['space_types'].map { |space_types| {'building_type': space_types['building_type'],
                                                                                                           'space_type': space_types['space_type'],
                                                                                                           "necb_hvac_system_selection_type": space_types['necb_hvac_system_selection_type'],
                                                                                                           "necb_schedule_type": space_types['necb_schedule_type']


  } }
  standards_space_type_list.s

  CSV.open("spacetypes.csv", "wb") do |csv|
    csv << standard_space_type_list.first.keys # adds the attributes name on the first line
    standard_space_type_list.each do |hash|
      csv << hash.values
    end
  end
end

#remove_meta_class_file ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 900

def remove_meta_class_file
  filepath = "#{File.dirname(__FILE__)}/do_not_edit_metaclasses.rb"
  FileUtils.rm(filepath)
end

#report_path(test_name) ⇒ `Object`



23
24
25

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 23

def report_path(test_name)
  "#{run_dir(test_name)}/report.html"
end

#reset_log ⇒ `Object`

resets the log



165
166
167

# File 'lib/openstudio-standards/utilities/logging.rb', line 165

def reset_log
  $OPENSTUDIO_LOG.resetStringStream
end

#run_dir(test_name) ⇒ `Object`

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 6

def run_dir(test_name)
  # always generate test output in specially named 'output' directory so result files are not made part of the measure
  "#{File.dirname(__FILE__)}/output/#{test_name}"
end

#sanity_check(qaqc) ⇒ `Object`

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

def sanity_check(qaqc)
  qaqc[:sanity_check] = {}
  qaqc[:sanity_check][:fail] = []
  qaqc[:sanity_check][:pass] = []
  #Padmassun's code for isConditioned start
  qaqc[:thermal_zones].each do |zoneinfo|
    zoneinfo[:spaces].each do |space|
      #skip plenums and undefined spaces/zones
      if zoneinfo[:name].to_s.include?"- undefined -"
        next
      end
      if zoneinfo[:space_type_name].to_s.include?"Space Function - undefined -"
        if zoneinfo[:is_conditioned].to_s == "No"
          qaqc[:sanity_check][:pass] << "[TEST-PASS][SANITY_CHECK-PASS] for [SPACE][#{space[:name]}] and [THERMAL ZONE] [#{zoneinfo[:name]}] where isConditioned is supposed to be [""No""] and found as #{zoneinfo[:is_conditioned]}"
        else
          qaqc[:sanity_check][:fail] << "[ERROR][SANITY_CHECK-FAIL] for [SPACE][#{space[:name]}] and [THERMAL ZONE] [#{zoneinfo[:name]}] where isConditioned is supposed to be [""No""] but found as #{zoneinfo[:is_conditioned]}"
        end
      else
        if zoneinfo[:is_conditioned].to_s == "Yes"
          qaqc[:sanity_check][:pass] << "[TEST-PASS][SANITY_CHECK-PASS] for [SPACE][#{space[:name]}] and [THERMAL ZONE] [#{zoneinfo[:name]}] where isConditioned is supposed to be [""Yes""] and found as #{zoneinfo[:is_conditioned]}"
        elsif zoneinfo[:name]
          qaqc[:sanity_check][:fail] << "[ERROR][SANITY_CHECK-FAIL] for [SPACE][#{space[:name]}] and [THERMAL ZONE] [#{zoneinfo[:name]}] where isConditioned is supposed to be [""Yes""] but found as #{zoneinfo[:is_conditioned]}"
        end
      end
    end
  end
  qaqc[:sanity_check][:fail] = qaqc[:sanity_check][:fail].sort
  qaqc[:sanity_check][:pass] = qaqc[:sanity_check][:pass].sort
  #Padmassun's code for isConditioned end
end

#save_meta_classes_to_file ⇒ `Object`

# File 'lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb', line 895

def save_meta_classes_to_file
  filepath = "#{File.dirname(__FILE__)}/do_not_edit_metaclasses.rb"
  File.open(filepath, 'w') { |f| create_class_array.each { |item| f << item } }
end

#sql_path(test_name) ⇒ `Object`



19
20
21

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 19

def sql_path(test_name)
  "#{run_dir(test_name)}/ModelToIdf/EnergyPlusPreProcess-0/EnergyPlus-0/eplusout.sql"
end

#terminate_prm_write_log(msg, log_path, debug = false) ⇒ `Object`

A function that writes error message to log file and stop the execution.

Parameters:

msg (String) —

error message
log_path (String) —

the log file directory
debug (Boolean) (defaults to: false) —

debug mode

# File 'lib/openstudio-standards/utilities/logging.rb', line 44

def terminate_prm_write_log(msg, log_path, debug = false)
  OpenStudio.logFree(OpenStudio::Error, 'prm.log', msg)
  log_messages_to_file_prm("#{log_path}/prm.log", debug)
  raise msg
end

#validate_optional(var, model, return_value = "N/A") ⇒ `Object`

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

def validate_optional (var, model, return_value = "N/A")
  if var.empty?
    return return_value
  else
    return var.get
  end
end

#workspace_path(test_name) ⇒ `Object`



15
16
17

# File 'lib/openstudio-standards/btap/utilities/convert_surfaces_to_adiabatic_necb_8426.rb', line 15

def workspace_path(test_name)
  "#{run_dir(test_name)}/ModelToIdf/in.idf"
end

Top Level Namespace

Defined Under Namespace

Instance Method Summary collapse

Instance Method Details

#calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule) ⇒ Object

#check_boolean_value(value, varname) ⇒ Object

#create_cbes_class_array ⇒ Object

#create_class_array ⇒ Object

#create_deer_class_array ⇒ Object

#create_meta_classes ⇒ Object

#distance(loc1, loc2) ⇒ Object

#get_additional_property_as_boolean(component, key, default = false) ⇒ Boolean

#get_additional_property_as_double(component, key, default = 0.0) ⇒ Double

#get_additional_property_as_integer(component, key, default = 0.0) ⇒ Integer

#get_additional_property_as_string(component, key, default = '') ⇒ String

#get_logs(log_type = OpenStudio::Error) ⇒ Array<String>

#get_schedule_max_delta_t(model, surface) ⇒ Object

#get_total_nominal_capacity(model) ⇒ Object

#log_messages_to_file(file_path, debug = false) ⇒ Array<String>

#log_messages_to_file_prm(file_path, debug = false) ⇒ Array

#log_messages_to_runner(runner, debug = false) ⇒ Runner

#look_up_csv_data(csv_fname, search_criteria) ⇒ Object

#map_spacetypes ⇒ Object

#model_out_path(test_name) ⇒ Object

#necb_2011_qaqc(qaqc, model) ⇒ Object

#necb_section_test(qaqc, result_value, bool_operator, expected_value, necb_section_name, test_text, tolerance = nil) ⇒ Object

#prm_get_component_name(component) ⇒ String

#prm_get_optional_handler(component, log_dir, data_key, *remaining_keys) ⇒ OpenStudio::Model::Component

#prm_raise(bool, log_dir, err_msg) ⇒ Object

#prm_read_user_data(user_data, key, default = nil) ⇒ String

#read_space_types ⇒ Object

#remove_meta_class_file ⇒ Object

#report_path(test_name) ⇒ Object

#reset_log ⇒ Object

#run_dir(test_name) ⇒ Object

#sanity_check(qaqc) ⇒ Object

#save_meta_classes_to_file ⇒ Object

#sql_path(test_name) ⇒ Object

#terminate_prm_write_log(msg, log_path, debug = false) ⇒ Object

#validate_optional(var, model, return_value = "N/A") ⇒ Object

#workspace_path(test_name) ⇒ Object

#calculate_max_delta_t(adj_DaySchedule, cur_DaySchedule) ⇒ `Object`

#check_boolean_value(value, varname) ⇒ `Object`

#create_cbes_class_array ⇒ `Object`

#create_class_array ⇒ `Object`

#create_deer_class_array ⇒ `Object`

#create_meta_classes ⇒ `Object`

#distance(loc1, loc2) ⇒ `Object`

#get_additional_property_as_boolean(component, key, default = false) ⇒ `Boolean`

#get_additional_property_as_double(component, key, default = 0.0) ⇒ `Double`

#get_additional_property_as_integer(component, key, default = 0.0) ⇒ `Integer`

#get_additional_property_as_string(component, key, default = '') ⇒ `String`

#get_logs(log_type = OpenStudio::Error) ⇒ `Array<String>`

#get_schedule_max_delta_t(model, surface) ⇒ `Object`

#get_total_nominal_capacity(model) ⇒ `Object`

#log_messages_to_file(file_path, debug = false) ⇒ `Array<String>`

#log_messages_to_file_prm(file_path, debug = false) ⇒ `Array`

#log_messages_to_runner(runner, debug = false) ⇒ `Runner`

#look_up_csv_data(csv_fname, search_criteria) ⇒ `Object`

#map_spacetypes ⇒ `Object`

#model_out_path(test_name) ⇒ `Object`

#necb_2011_qaqc(qaqc, model) ⇒ `Object`

#necb_section_test(qaqc, result_value, bool_operator, expected_value, necb_section_name, test_text, tolerance = nil) ⇒ `Object`

#prm_get_component_name(component) ⇒ `String`

#prm_get_optional_handler(component, log_dir, data_key, *remaining_keys) ⇒ `OpenStudio::Model::Component`

#prm_raise(bool, log_dir, err_msg) ⇒ `Object`

#prm_read_user_data(user_data, key, default = nil) ⇒ `String`

#read_space_types ⇒ `Object`

#remove_meta_class_file ⇒ `Object`

#report_path(test_name) ⇒ `Object`

#reset_log ⇒ `Object`

#run_dir(test_name) ⇒ `Object`

#sanity_check(qaqc) ⇒ `Object`

#save_meta_classes_to_file ⇒ `Object`

#sql_path(test_name) ⇒ `Object`

#terminate_prm_write_log(msg, log_path, debug = false) ⇒ `Object`

#validate_optional(var, model, return_value = "N/A") ⇒ `Object`

#workspace_path(test_name) ⇒ `Object`