openstudio-standards 0.2.12 → 0.2.13.rc3

data/lib/openstudio-standards/utilities/simulation.rb

@@ -25,6 +25,7 @@ Standard.class_eval do
     if epw_path.empty?
       return false
     end
+
     epw_path = epw_path.get
 
     # close current sql file
@@ -84,7 +85,7 @@ Standard.class_eval do
       epw_name = 'in.epw'
       begin
         FileUtils.copy(epw_path.to_s, "#{run_dir}/#{epw_name}")
-      rescue
+      rescue StandardError
         OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Due to limitations on Windows file path lengths, this measure won't work unless your project is located in a directory whose filepath is less than 90 characters long, including slashes.")
         return false
       end
@@ -95,7 +96,7 @@ Standard.class_eval do
 
       cli_path = OpenStudio.getOpenStudioCLI
       cmd = "\"#{cli_path}\" run -w \"#{osw_path}\""
-      #cmd = "\"#{cli_path}\" --verbose run -w \"#{osw_path}\""
+      # cmd = "\"#{cli_path}\" --verbose run -w \"#{osw_path}\""
       puts cmd
 
       # Run the sizing run
@@ -155,7 +156,7 @@ Standard.class_eval do
       endstring = File.read(end_file_stringpath)
     end
 
-    if not endstring.include?("EnergyPlus Completed Successfully")
+    if !endstring.include?('EnergyPlus Completed Successfully')
       OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "The run did not finish and had following errors: #{errs.join('\n')}")
       return false
     end
@@ -182,6 +183,7 @@ Standard.class_eval do
 
     # check that all zones have surfaces.
     raise 'Error: Sizing Run Failed. Thermal Zones with no surfaces exist.' unless model_do_all_zones_have_surfaces?(model)
+
     # Run the sizing run
     success = model_run_simulation_and_log_errors(model, sizing_run_dir)
 

data/lib/openstudio-standards/utilities/speacetype_map_converter.rb

@@ -1,16 +1,15 @@
 require 'json'
 map = []
-File.open("../../../lib/openstudio-standards/standards/necb/NECB2015/data/space_type_upgrade_map.csv").each do |line|
-  necb2011_building_type, necb2011_space_type, necb2015_building_type, necb2015_space_type = line.split(",")
-  next if necb2011_building_type.nil? or necb2011_building_type.strip == ''
+File.open('../../../lib/openstudio-standards/standards/necb/NECB2015/data/space_type_upgrade_map.csv').each do |line|
+  necb2011_building_type, necb2011_space_type, necb2015_building_type, necb2015_space_type = line.split(',')
+  next if necb2011_building_type.nil? || (necb2011_building_type.strip == '')
 
-
-  map << {'NECB2011_building_type' => necb2011_building_type.strip,
-          'NECB2011_space_type' => necb2011_space_type.strip,
-          'NECB2015_building_type' => necb2015_building_type.strip,
-          'NECB2015_space_type' => necb2015_space_type.strip,
-          'NECB2017_building_type' => necb2015_building_type.strip,
-          'NECB2017_space_type' => necb2015_space_type.strip }
+  map << { 'NECB2011_building_type' => necb2011_building_type.strip,
+           'NECB2011_space_type' => necb2011_space_type.strip,
+           'NECB2015_building_type' => necb2015_building_type.strip,
+           'NECB2015_space_type' => necb2015_space_type.strip,
+           'NECB2017_building_type' => necb2015_building_type.strip,
+           'NECB2017_space_type' => necb2015_space_type.strip }
 end
 
-puts JSON.pretty_generate(map)
+puts JSON.pretty_generate(map)

data/lib/openstudio-standards/utilities/sqlfile.rb

@@ -1,5 +1,4 @@
 Standard.class_eval do
-
   # Gets the sql file for the model, erroring if not found
   # @todo candidate for C++
   def model_sql_file(model)
@@ -26,6 +25,7 @@ Standard.class_eval do
     sql.availableEnvPeriods.each do |env_pd|
       env_type = sql.environmentType(env_pd)
       next unless env_type.is_initialized
+
       if env_type.get == OpenStudio::EnvironmentType.new('WeatherRunPeriod')
         ann_env_pd = env_pd
       end
@@ -362,7 +362,6 @@ Standard.class_eval do
 
   # Gets the annual occupied unmet hours from the sql file
   def model_annual_occupied_unmet_hours(model)
-
     heating_setpoint_unmet = model_annual_occupied_unmet_heating_hours(model)
     cooling_setpoint_unmet = model_annual_occupied_unmet_cooling_hours(model)
 
@@ -487,7 +486,7 @@ Standard.class_eval do
     fuel_types = ['Electricity', 'Natural Gas', 'Additional Fuel', 'District Cooling', 'District Heating', 'Water']
 
     # List of all end uses
-    end_uses = ['Heating', 'Cooling', 'Interior Lighting', 'Exterior Lighting', 'Interior Equipment', 'Exterior Equipment', 'Fans', 'Pumps', 'Heat Rejection','Humidification', 'Heat Recovery', 'Water Systems', 'Refrigeration', 'Generators']
+    end_uses = ['Heating', 'Cooling', 'Interior Lighting', 'Exterior Lighting', 'Interior Equipment', 'Exterior Equipment', 'Fans', 'Pumps', 'Heat Rejection', 'Humidification', 'Heat Recovery', 'Water Systems', 'Refrigeration', 'Generators']
 
     # Get the value for each end use/ fuel type combination
     end_uses.each do |end_use|
@@ -498,17 +497,17 @@ Standard.class_eval do
 
     return energy_values
   end
-  
+
   def model_dd_results_by_end_use_and_fuel_type(model)
     energy_values = {}
 
     # List of all fuel types, based on Table 5.1 of EnergyPlus' Input Output Reference manual
     fuel_types = ['Electricity', 'Gas', 'Gasoline', 'Diesel', 'Coal', 'FuelOilNo1', 'FuelOilNo2', 'Propane', 'OtherFuel1', 'OtherFuel2', 'Water', 'Steam', 'DistrictCooling',
-    'DistrictHeating', 'ElectricityPurchased', 'ElectricitySurplusSold', 'ElectricityNet']
+                  'DistrictHeating', 'ElectricityPurchased', 'ElectricitySurplusSold', 'ElectricityNet']
 
     # List of all end uses, based on Table 5.3 of EnergyPlus' Input Output Reference manual
-    end_uses = ['InteriorLights', 'ExteriorLights', 'InteriorEquipment', 'ExteriorEquipment', 'Fans', 'Pumps', 'Heating', 'Cooling', 'HeatRejection', 'Humidifier', 
-    'HeatRecovery', 'DHW', 'Cogeneration', 'Refrigeration', 'WaterSystems']
+    end_uses = ['InteriorLights', 'ExteriorLights', 'InteriorEquipment', 'ExteriorEquipment', 'Fans', 'Pumps', 'Heating', 'Cooling', 'HeatRejection', 'Humidifier',
+                'HeatRecovery', 'DHW', 'Cogeneration', 'Refrigeration', 'WaterSystems']
 
     # Get the value for each end use/ fuel type combination
     end_uses.each do |end_use|
@@ -522,7 +521,6 @@ Standard.class_eval do
 
   # Gets annual eui by fuel and end use from the sql file
   def model_annual_eui_kbtu_per_ft2_by_fuel_and_enduse(model, fuel_type, end_use)
-
     energy_gj = model_annual_energy_by_fuel_and_enduse(model, fuel_type, end_use)
     energy_kbtu = OpenStudio.convert(energy_gj, 'GJ', 'kBtu').get
 

data/lib/openstudio-standards/utilities/template_measure/measure.rb

@@ -0,0 +1,108 @@
+# see the URL below for information on how to write OpenStudio measures
+# http://nrel.github.io/OpenStudio-user-documentation/reference/measure_writing_guide/
+require_relative 'resources/BTAPMeasureHelper'
+
+# start the measure
+class BTAPModelMeasure < OpenStudio::Measure::ModelMeasure
+  attr_accessor :use_json_package, :use_string_double
+  # Adds helper functions to make life a bit easier and consistent.
+  include(BTAPMeasureHelper)
+  # human readable name
+  def name
+    # BEFORE YOU DO anything.. please generate a new <uid>224561f4-8ccc-4f60-8118-34b85359d6f7</uid> and add this to the measure.xml file
+    # You can generate a new UUID using the ruby command
+    # ruby -e 'require "securerandom";  puts SecureRandom.uuid '
+    return 'BTAPTemplateMeasure'
+  end
+
+  # human readable description
+  def description
+    return 'This template measure is used to ensure consistency in detailed BTAP measures.'
+  end
+
+  # human readable description of modeling approach
+  def modeler_description
+    return 'This template measure is used to ensure consistency in BTAP measures.'
+  end
+
+  # Use the constructor to set global variables
+  def initialize
+    super()
+    # Set to true if you want to package the arguments as json.
+    @use_json_package = false
+    # Set to true if you want to want to allow strings and doubles in stringdouble types. Set to false to force to use doubles. The latter is used for certain
+    # continuous optimization algorithms. You may have to re-examine your input in PAT as this fundamentally changes the measure.
+    @use_string_double = true
+
+    # Put in this array of hashes all the input variables that you need in your measure. Your choice of types are Sting, Double,
+    # StringDouble, and Choice. Optional fields are valid strings, max_double_value, and min_double_value. This will
+    # create all the variables, validate the ranges and types you need,  and make them available in the 'run' method as a hash after
+    # you run 'arguments = validate_and_get_arguments_in_hash(model, runner, user_arguments)'
+    @measure_interface_detailed = [
+      {
+        'name' => 'a_string_argument',
+        'type' => 'String',
+        'display_name' => 'A String Argument (string)',
+        'default_value' => 'The Default Value',
+        'is_required' => true
+      },
+      {
+        'name' => 'a_double_argument',
+        'type' => 'Double',
+        'display_name' => 'A Double numeric Argument (double)',
+        'default_value' => 0,
+        'max_double_value' => 100.0,
+        'min_double_value' => 0.0,
+        'is_required' => true
+      },
+      {
+        'name' => 'a_string_double_argument',
+        'type' => 'StringDouble',
+        'display_name' => 'A String Double numeric Argument (double)',
+        'default_value' => 23.0,
+        'max_double_value' => 100.0,
+        'min_double_value' => 0.0,
+        'valid_strings' => ['Baseline', 'NA'],
+        'is_required' => true
+      },
+      {
+        'name' => 'a_choice_argument',
+        'type' => 'Choice',
+        'display_name' => 'A Choice String Argument ',
+        'default_value' => 'choice_1',
+        'choices' => ['choice_1', 'choice_2'],
+        'is_required' => true
+      },
+      {
+        'name' => 'a_bool_argument',
+        'type' => 'Bool',
+        'display_name' => 'A Boolean Argument ',
+        'default_value' => false,
+        'is_required' => true
+      }
+    ]
+  end
+
+  # define what happens when the measure is run
+  def run(model, runner, user_arguments)
+    # Runs parent run method.
+    super(model, runner, user_arguments)
+    # Gets arguments from interfaced and puts them in a hash with there display name. This also does a check on ranges to
+    # ensure that the values inputted are valid based on your @measure_interface array of hashes.
+    arguments = validate_and_get_arguments_in_hash(model, runner, user_arguments)
+    # puts JSON.pretty_generate(arguments)
+    return false if arguments == false
+
+    # You can now access the input argument by the name.
+    # arguments['a_string_argument']
+    # arguments['a_double_argument']
+    # etc......
+    # So write your measure code here!
+
+    # Do something.
+    return true
+  end
+end
+
+# register the measure to be used by the application
+BTAPModelMeasure.new.registerWithApplication

data/lib/openstudio-standards/utilities/template_measure/measure.xml

@@ -0,0 +1,162 @@
+<measure>
+  <schema_version>3.0</schema_version>
+  <name>btap_model_measure</name>
+  <uid>224561f4-8ccc-4f60-8118-34b85359d6f7</uid>
+  <version_id>f73a0c59-ff93-4645-b8a4-dfaa6c16b114</version_id>
+  <version_modified>20180516T161828Z</version_modified>
+  <xml_checksum>2609226D</xml_checksum>
+  <class_name>BTAPModelMeasure</class_name>
+  <display_name>BTAPTemplateMeasure</display_name>
+  <description>This template measure is used to ensure consistency in detailed BTAP measures.</description>
+  <modeler_description>This template measure is used to ensure consistency in BTAP measures.</modeler_description>
+  <arguments>
+    <argument>
+      <name>a_string_argument</name>
+      <display_name>A String Argument (string)</display_name>
+      <type>String</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>The Default Value</default_value>
+    </argument>
+    <argument>
+      <name>a_double_argument</name>
+      <display_name>A Double numeric Argument (double)</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0</default_value>
+    </argument>
+    <argument>
+      <name>a_string_double_argument</name>
+      <display_name>A String Double numeric Argument (double)</display_name>
+      <type>String</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>23.0</default_value>
+    </argument>
+    <argument>
+      <name>a_choice_argument</name>
+      <display_name>A Choice String Argument </display_name>
+      <type>Choice</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>choice_1</default_value>
+      <choices>
+        <choice>
+          <value>choice_1</value>
+          <display_name>choice_1</display_name>
+        </choice>
+        <choice>
+          <value>choice_2</value>
+          <display_name>choice_2</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>a_bool_argument</name>
+      <display_name>A Boolean Argument </display_name>
+      <type>Boolean</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>false</default_value>
+      <choices>
+        <choice>
+          <value>true</value>
+          <display_name>true</display_name>
+        </choice>
+        <choice>
+          <value>false</value>
+          <display_name>false</display_name>
+        </choice>
+      </choices>
+    </argument>
+  </arguments>
+  <outputs/>
+  <provenances/>
+  <tags>
+    <tag>Envelope.Opaque</tag>
+  </tags>
+  <attributes>
+    <attribute>
+      <name>Measure Type</name>
+      <value>ModelMeasure</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Apply Measure Now</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>OpenStudio Application</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Parametric Analysis Tool</value>
+      <datatype>string</datatype>
+    </attribute>
+  </attributes>
+  <files>
+    <file>
+      <filename>BTAPTemplateModelMeasure_test.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>test</usage_type>
+      <checksum>5E7EBF34</checksum>
+    </file>
+    <file>
+      <filename>BTAPMeasureHelper.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>3D94B7AC</checksum>
+    </file>
+    <file>
+      <version>
+        <software_program>OpenStudio</software_program>
+        <identifier>2.3.0</identifier>
+        <min_compatible>2.3.0</min_compatible>
+      </version>
+      <filename>measure.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>script</usage_type>
+      <checksum>B821DA93</checksum>
+    </file>
+    <file>
+      <filename>fileio.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>55494222</checksum>
+    </file>
+    <file>
+      <filename>Standards.Construction.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>9C6C6E51</checksum>
+    </file>
+    <file>
+      <filename>git_revision</filename>
+      <filetype></filetype>
+      <usage_type>resource</usage_type>
+      <checksum>DAE275A8</checksum>
+    </file>
+    <file>
+      <filename>Standards.Model.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>46874C01</checksum>
+    </file>
+    <file>
+      <filename>btap_additions.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>6DC45CBD</checksum>
+    </file>
+    <file>
+      <filename>building_envelope.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>resource</usage_type>
+      <checksum>6ED0F4FE</checksum>
+    </file>
+  </files>
+</measure>

data/lib/openstudio-standards/utilities/template_measure/resources/BTAPMeasureHelper.rb

@@ -0,0 +1,448 @@
+module BTAPMeasureHelper
+  # ##################Helper functions
+
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Measure::OSArgumentVector.new
+
+    if @use_json_package == true
+      # Set up package version of input.
+      json_default = {}
+      @measure_interface_detailed.each do |argument|
+        json_default[argument['name']] = argument['default_value']
+      end
+      default = JSON.pretty_generate(json_default)
+      arg = OpenStudio::Ruleset::OSArgument.makeStringArgument('json_input', true)
+      arg.setDisplayName('Contains a json version of the input as a single package.')
+      arg.setDefaultValue(default)
+      args << arg
+    else
+      # Conductances for all surfaces and subsurfaces.
+      @measure_interface_detailed.each do |argument|
+        arg = nil
+        statement = nil
+        case argument['type']
+          when 'String'
+            arg = OpenStudio::Ruleset::OSArgument.makeStringArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'].to_s)
+
+          when 'Double'
+            arg = OpenStudio::Ruleset::OSArgument.makeDoubleArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName((argument['display_name']).to_s)
+            arg.setDefaultValue((argument['default_value']).to_s.to_f)
+
+          when 'Integer'
+            arg = OpenStudio::Ruleset::OSArgument.makeIntegerArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName((argument['display_name']).to_s)
+            arg.setDefaultValue((argument['default_value']).to_s.to_i)
+
+          when 'Choice'
+            arg = OpenStudio::Measure::OSArgument.makeChoiceArgument(argument['name'], argument['choices'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'].to_s)
+            puts arg.defaultValueAsString
+
+          when 'Bool'
+            arg = OpenStudio::Measure::OSArgument.makeBoolArgument(argument['name'], argument['is_required'])
+            arg.setDisplayName(argument['display_name'])
+            arg.setDefaultValue(argument['default_value'])
+
+          when 'StringDouble'
+            if @use_string_double == false
+              arg = OpenStudio::Ruleset::OSArgument.makeDoubleArgument(argument['name'], argument['is_required'])
+              arg.setDefaultValue(argument['default_value'].to_f)
+            else
+              arg = OpenStudio::Ruleset::OSArgument.makeStringArgument(argument['name'], argument['is_required'])
+              arg.setDefaultValue(argument['default_value'].to_s)
+            end
+            arg.setDisplayName(argument['display_name'])
+        end
+        args << arg
+      end
+    end
+    return args
+  end
+
+  # returns a hash of the user inputs for you to use in your measure.
+  def get_hash_of_arguments(user_arguments, runner)
+    values = {}
+    if @use_json_package
+      return JSON.parse(runner.getStringArgumentValue('json_input', user_arguments))
+    else
+
+      @measure_interface_detailed.each do |argument|
+        case argument['type']
+          when 'String', 'Choice'
+            values[argument['name']] = runner.getStringArgumentValue(argument['name'], user_arguments)
+          when 'Double'
+            values[argument['name']] = runner.getDoubleArgumentValue(argument['name'], user_arguments)
+          when 'Integer'
+            values[argument['name']] = runner.getIntegerArgumentValue(argument['name'], user_arguments)
+          when 'Bool'
+            values[argument['name']] = runner.getBoolArgumentValue(argument['name'], user_arguments)
+          when 'StringDouble'
+            value = nil
+            if @use_string_double == false
+              value = runner.getDoubleArgumentValue(argument['name'], user_arguments).to_f
+            else
+              value = runner.getStringArgumentValue(argument['name'], user_arguments)
+              if valid_float?(value)
+                value = value.to_f
+              end
+            end
+            values[argument['name']] = value
+        end
+      end
+    end
+
+    return values
+  end
+
+  # boilerplate that validated ranges of inputs.
+  def validate_and_get_arguments_in_hash(model, runner, user_arguments)
+    return_value = true
+    values = get_hash_of_arguments(user_arguments, runner)
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      runner_register(runner, 'Error', 'validateUserArguments failed... Check the argument definition for errors.')
+      return_value = false
+    end
+
+    # Validate arguments
+    errors = ''
+    @measure_interface_detailed.each do |argument|
+      case argument['type']
+        when 'Double'
+          value = values[argument['name']]
+          if (!argument['max_double_value'].nil? && (value.to_f > argument['max_double_value'].to_f)) ||
+             (!argument['min_double_value'].nil? && (value.to_f < argument['min_double_value'].to_f))
+            error = "#{argument['name']} must be between #{argument['min_double_value']} and #{argument['max_double_value']}. You entered #{value.to_f} for this #{argument['name']}.\n Please enter a value withing the expected range.\n"
+            errors << error
+          end
+
+        when 'Integer'
+          value = values[argument['name']]
+          if (!argument['max_integer_value'].nil? && (value.to_i > argument['max_integer_value'].to_i)) ||
+             (!argument['min_integer_value'].nil? && (value.to_i < argument['min_integer_value'].to_i))
+            error = "#{argument['name']} must be between #{argument['min_integer_value']} and #{argument['max_integer_value']}. You entered #{value.to_i} for this #{argument['name']}.\n Please enter a value withing the expected range.\n"
+            errors << error
+          end
+
+        when 'StringDouble'
+          value = values[argument['name']]
+          if !argument['valid_strings'].include?(value) && !valid_float?(value)
+            error = "#{argument['name']} must be a string that can be converted to a float, or one of these #{argument['valid_strings']}. You have entered #{value}\n"
+            errors << error
+          elsif (!argument['max_double_value'].nil? && (value.to_f > argument['max_double_value'])) ||
+                (!argument['min_double_value'].nil? && (value.to_f < argument['min_double_value']))
+            error = "#{argument['name']} must be between #{argument['min_double_value']} and #{argument['max_double_value']}. You entered #{value} for #{argument['name']}. Please enter a stringdouble value in the expected range.\n"
+            errors << error
+          end
+      end
+    end
+    # If any errors return false, else return the hash of argument values for user to use in measure.
+    if errors != ''
+      runner.registerError(errors)
+      return false
+    end
+    return values
+  end
+
+  # Helper method to see if str is a valid float.
+  def valid_float?(str)
+    !!Float(str)
+  rescue StandardError
+    false
+  end
+end
+
+module BTAPMeasureTestHelper
+  ##### Helper methods Do notouch unless you know the consequences.
+
+  # Boiler plate to default values and number of arguments against what is in your test's setup method.
+  def test_arguments_and_defaults
+    [true, false].each do |json_input|
+      [true, false].each do |string_double|
+        @use_json_package = json_input
+        @use_string_double = string_double
+
+        # Create an instance of the measure
+        measure = get_measure_object
+        measure.use_json_package = @use_json_package
+        measure.use_string_double = @use_string_double
+        model = OpenStudio::Model::Model.new
+
+        # Create an instance of a runner
+        runner = OpenStudio::Measure::OSRunner.new(OpenStudio::WorkflowJSON.new)
+
+        # Test arguments and defaults
+        arguments = measure.arguments(model)
+        # convert whatever the input was into a hash. Then test.
+
+        # check number of arguments.
+        if @use_json_package
+          assert_equal(@measure_interface_detailed.size, JSON.parse(arguments[0].defaultValueAsString).size, "The measure should have #{@measure_interface_detailed.size} but actually has #{arguments.size}. Here the the arguement expected #{JSON.pretty_generate(@measure_interface_detailed)} /n and this is the actual /n #{JSON.pretty_generate(arguments[0])}")
+        else
+          assert_equal(@measure_interface_detailed.size, arguments.size, "The measure should have #{@measure_interface_detailed.size} but actually has #{arguments.size}. Here the the arguement expected #{@measure_interface_detailed} and this is the actual #{arguments}")
+          @measure_interface_detailed.each_with_index do |argument_expected, index|
+            assert_equal(argument_expected['name'], arguments[index].name, "Measure argument name of #{argument_expected['name']} was expected, but got #{arguments[index].name} instead.")
+            assert_equal(argument_expected['display_name'], arguments[index].displayName, "Display name for argument #{argument_expected['name']} was expected to be #{argument_expected['display_name']}, but got #{arguments[index].displayName} instead.")
+            case argument_type(arguments[index])
+              when 'String', 'Choice'
+                assert_equal(argument_expected['default_value'].to_s, arguments[index].defaultValueAsString, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+              when 'Double'
+                assert_equal(argument_expected['default_value'].to_f, arguments[index].defaultValueAsDouble.to_f, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+              when 'Integer'
+                assert_equal(argument_expected['default_value'].to_i, arguments[index].defaultValueAsInteger.to_i, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+              when 'Bool'
+                assert_equal(argument_expected['default_value'], arguments[index].defaultValueAsBool, "The default value for argument #{argument_expected['name']} was #{argument_expected['default_value']}, but actual was #{arguments[index].defaultValueAsString}")
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Test argument ranges.
+  def test_argument_ranges
+    model = OpenStudio::Model::Model.new
+    standard = Standard.build('NECB2015')
+    standard.model_add_design_days_and_weather_file(model, nil, 'CAN_AB_Edmonton.Intl.AP.711230_CWEC2016.epw')
+
+    [true, false].each do |json_input|
+      [true, false].each do |string_double|
+        @use_json_package = json_input
+        @use_string_double = string_double
+        @measure_interface_detailed.each do |argument|
+          ##########################
+          if argument['type'] == 'Integer'
+            puts "Testing range for #{argument['name']}".blue
+            # Check over max
+
+            if !argument['max_integer_value'].nil?
+              puts 'Testing max limit'
+              input_arguments = @good_input_arguments.clone
+              over_max_value = argument['max_integer_value'].to_i + 1
+              input_arguments[argument['name']] = over_max_value
+              puts "Testing argument #{argument['name']} max limit of #{argument['max_integer_value']}".light_blue
+              input_arguments = { 'json_input' => JSON.pretty_generate(input_arguments) } if @use_json_package
+              run_measure(input_arguments, model)
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_max_value} for #{argument['name']}")
+              puts "Success: Testing argument #{argument['name']} max limit of #{argument['max_integer_value']}".green
+            end
+            # Check over max
+            if !argument['min_integer_value'].nil?
+              puts 'Testing min limit'
+              input_arguments = @good_input_arguments.clone
+              over_min_value = argument['min_integer_value'].to_i - 1
+              input_arguments[argument['name']] = over_min_value
+              puts "Testing argument #{argument['name']} min limit of #{argument['min_integer_value']}".light_blue
+              input_arguments = { 'json_input' => JSON.pretty_generate(input_arguments) } if @use_json_package
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_min_value} for #{argument['name']}")
+              puts "Success:Testing argument #{argument['name']} min limit of #{argument['min_integer_value']}".green
+            end
+
+          end
+          ###########################
+
+          if (argument['type'] == 'Double') || (argument['type'] == 'StringDouble')
+            puts "Testing range for #{argument['name']} ".blue
+            # Check over max
+
+            if !argument['max_double_value'].nil?
+              puts 'Testing max limit'
+              input_arguments = @good_input_arguments.clone
+              over_max_value = argument['max_double_value'].to_f + 1.0
+              over_max_value = over_max_value.to_s if argument['type'].downcase == 'StringDouble'.downcase
+              input_arguments[argument['name']] = over_max_value
+              puts "Testing argument #{argument['name']} max limit of #{argument['max_double_value']}".light_blue
+              input_arguments = { 'json_input' => JSON.pretty_generate(input_arguments) } if @use_json_package
+              run_measure(input_arguments, model)
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_max_value} for #{argument['name']}")
+              puts "Success: Testing argument #{argument['name']} max limit of #{argument['max_double_value']}".green
+            end
+            # Check over max
+            if !argument['min_double_value'].nil?
+              puts 'Testing min limit'
+              input_arguments = @good_input_arguments.clone
+              over_min_value = argument['min_double_value'].to_f - 1.0
+              over_min_value = over_max_value.to_s if argument['type'].downcase == 'StringDouble'.downcase
+              input_arguments[argument['name']] = over_min_value
+              puts "Testing argument #{argument['name']} min limit of #{argument['min_double_value']}".light_blue
+              input_arguments = { 'json_input' => JSON.pretty_generate(input_arguments) } if @use_json_package
+              runner = run_measure(input_arguments, model)
+              assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_min_value} for #{argument['name']}")
+              puts "Success:Testing argument #{argument['name']} min limit of #{argument['min_double_value']}".green
+            end
+
+          end
+
+          if (argument['type'] == 'StringDouble') && !argument['valid_strings'].nil? && @use_string_double
+            input_arguments = @good_input_arguments.clone
+            input_arguments[argument['name']] = SecureRandom.uuid.to_s
+            puts "Testing argument #{argument['name']} min limit of #{argument['min_double_value']}".light_blue
+            input_arguments = { 'json_input' => JSON.pretty_generate(input_arguments) } if @use_json_package
+            runner = run_measure(input_arguments, model)
+            assert(runner.result.value.valueName != 'Success', "Checks did not stop a lower than limit value of #{over_min_value} for #{argument['name']}")
+          end
+        end
+      end
+    end
+  end
+
+  # helper method to create necb archetype as a starting point for testing.
+  def create_necb_protype_model(building_type, climate_zone, epw_file, template)
+    osm_directory = "#{Dir.pwd}/output/#{building_type}-#{template}-#{climate_zone}-#{epw_file}"
+    FileUtils.mkdir_p osm_directory unless Dir.exist?(osm_directory)
+    # Get Weather climate zone from lookup
+    weather = BTAP::Environment::WeatherFile.new(epw_file)
+    # create model
+    building_name = "#{template}_#{building_type}"
+
+    prototype_creator = Standard.build(building_name)
+    model = prototype_creator.model_create_prototype_model(climate_zone,
+                                                           epw_file,
+                                                           osm_directory,
+                                                           @debug,
+                                                           model)
+    # set weather file to epw_file passed to model.
+    weather.set_weather_file(model)
+    return model
+  end
+
+  # Custom way to run the measure in the test.
+  def run_measure(input_arguments, model)
+    # This will create a instance of the measure you wish to test. It does this based on the test class name.
+    measure = get_measure_object
+    measure.use_json_package = @use_json_package
+    measure.use_string_double = @use_string_double
+    # Return false if can't
+    return false if measure == false
+
+    arguments = measure.arguments(model)
+    argument_map = OpenStudio::Measure.convertOSArgumentVectorToMap(arguments)
+    runner = OpenStudio::Measure::OSRunner.new(OpenStudio::WorkflowJSON.new)
+    # Check if
+
+    # Set the arguements in the argument map use json or real arguments.
+    if @use_json_package
+      argument = arguments[0].clone
+      assert(argument.setValue(input_arguments['json_input']), "Could not set value for 'json_input' to #{input_arguments['json_input']}")
+      argument_map['json_input'] = argument
+    else
+      input_arguments.each_with_index do |(key, value), index|
+        argument = arguments[index].clone
+        if argument_type(argument) == 'Double'
+          # forces it to a double if it is a double.
+          assert(argument.setValue(value.to_f), "Could not set value for #{key} to #{value}")
+        else
+          assert(argument.setValue(value.to_s), "Could not set value for #{key} to #{value}")
+        end
+        argument_map[key] = argument
+      end
+    end
+    # run the measure
+    measure.run(model, runner, argument_map)
+    runner.result
+    return runner
+  end
+
+  # Fancy way of getting the measure object automatically.
+  def get_measure_object
+    measure_class_name = self.class.name.to_s.match(/(BTAP.*)(\_Test)/i).captures[0]
+    measure = nil
+    eval "measure = #{measure_class_name}.new"
+    if measure.nil?
+      puts "Measure class #{measure_class_name} is invalid. Please ensure the test class name is of the form 'BTAPMeasureName_Test' (Note: BTAP is case sensitive.) ".red
+      return false
+    end
+    return measure
+  end
+
+  # Determines the OS argument type dynamically.
+  def argument_type(argument)
+    case argument.type.value
+      when 0
+        return 'Bool'
+      when 1 # Double
+        return 'Double'
+      when 2 # Quantity
+        return 'Quantity'
+      when 3 # Integer
+        return 'Integer'
+      when 4
+        return 'String'
+      when 5 # Choice
+        return 'Choice'
+      when 6 # Path
+        return 'Path'
+      when 7 # Separator
+        return 'Separator'
+      else
+        return 'Blah'
+    end
+  end
+
+  # Valid float helper.
+  def valid_float?(str)
+    !!Float(str)
+  rescue StandardError
+    false
+  end
+
+  # Method does a deep copy of a model.
+  def copy_model(model)
+    copy_model = OpenStudio::Model::Model.new
+    # remove existing objects from model
+    handles = OpenStudio::UUIDVector.new
+    copy_model.objects.each do |obj|
+      handles << obj.handle
+    end
+    copy_model.removeObjects(handles)
+    # put contents of new_model into model_to_replace
+    copy_model.addObjects(model.toIdfFile.objects)
+    return copy_model
+  end
+end
+
+# Add colourisation functionality to strings. Makes following test output easier.
+class String
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  # Use for error messages
+  def red
+    colorize(31)
+  end
+
+  # Use for success messages
+  def green
+    colorize(32)
+  end
+
+  # Use for warning messages
+  def yellow
+    colorize(33)
+  end
+
+  # Use for start of tests/sections
+  def blue
+    colorize(34)
+  end
+
+  # Use for argument value reporting
+  def light_blue
+    colorize(36)
+  end
+
+  # Use for larger text dumps (e.g. whole files)
+  def pink
+    colorize(35)
+  end
+end