openstudio-common-measures 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7224129b55bec16c8936b284e54c7609c53e53719a4b59f7c921e11aca617ad
-  data.tar.gz: 4140c02c5f41bf2d38f972478746dd7c72ce79b6cc903b2b3d70561ce534cc6f
+  metadata.gz: f60fd113283f7b1c0d89fdab58e3109a910142709dd9c8aaa7ef720a54471acd
+  data.tar.gz: d1830f530d2c60bd5db9bf654dd290885a9c9835dabc7d2b7b23e9ce4001280b
 SHA512:
-  metadata.gz: e02c60d2cc4625d290a2ac0d4208661138225ddca9ecd7aba333c07da3b05868d16ed32a666531dfd283563d353fa530a867787baf3acb5baab29cd9a1f3f09d
-  data.tar.gz: 95d672a0b439bf9e0caed02b78198af51f06b6a787d2a168906b223ead4e83109cdbccf927d6baa7733487e83f4ba44db4aeec22a9ecc5a942087cd874c3a74b
+  metadata.gz: 653ed7725cd73ca0c7664c07257772ed882d3391acdda0a99a87712b6824ec2a40098a864a461ee53bfcded6365635db86cc5d8571e3e7ff93fdc94666e2baf9
+  data.tar.gz: 67791080c2703b405dfdc257728bdb88216da3ebc60ebe7b59158934ebfcd5a7002df3cc34a6bcce9231c2c8c1e1862d053a158f4dec0b34d53719ab5b114863

data/.gitignore

@@ -12,6 +12,7 @@
 /test/
 /lib/measures/test_results
 /lib/measures/*/tests/output
+/lib/measures/staged
 
 .rubocop*s3*
 

data/CHANGELOG.md

@@ -1,7 +1,12 @@
 # OpenStudio Common Measures Gem
 
+## Version 0.3.0
+
+* Support for OpenStudio 3.1 (upgrade to extension gem 0.3.1)
+
 ## Version 0.2.1
-* Removes the following from lib/measures:
+
+* Removes the following from lib/measures and moves them to the OpenStudio-calibration-gem:
     * AddDaylightSensors
     * EnableDemandControlledVentilation
     * EnableEconomizerControl
@@ -42,8 +47,6 @@
 * Upgrade Bundler to 2.1.0
 * Upgrade openstudio-extension to 0.2.3
 
-
-
 ## Version 0.2.0
 
 * Support for OpenStudio 3.0

data/Rakefile

@@ -31,9 +31,6 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require 'rubocop/rake_task'
-RuboCop::RakeTask.new
-
 # Load in the rake tasks from the base extension gem
 require 'openstudio/extension/rake_task'
 require 'openstudio/common_measures'
@@ -44,3 +41,20 @@ require 'openstudio_measure_tester/rake_task'
 OpenStudioMeasureTester::RakeTask.new
 
 task default: :spec
+
+desc 'Delete measure test output'
+task :delete_measure_test_outputs do
+  require 'fileutils'
+
+  puts 'Deleting tests/output directory from measures.'
+
+  # get measures in repo
+  measures = Dir.glob('**/**/**/measure.rb')
+
+  #create unique list of parent directories for measures.
+  measures.each do |i|
+    FileUtils.rm_rf(i.gsub("measure.rb","tests/output"))
+  end
+  puts "Deleted test outputs"
+
+end

data/lib/measures/AddDaylightSensors/LICENSE.md

@@ -0,0 +1,27 @@
+OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted 
+provided that the following conditions are met:
+
+(1) Redistributions of source code must retain the above copyright notice, this list of conditions 
+and the following disclaimer.
+
+(2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions
+and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+(3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse 
+or promote products derived from this software without specific prior written permission from the 
+respective party.
+
+(4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other 
+derivative works may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar 
+designation without specific prior written permission from Alliance for Sustainable Energy, LLC.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER, THE UNITED STATES GOVERNMENT, 
+OR ANY CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/measures/AddDaylightSensors/README.md

@@ -0,0 +1,136 @@
+
+
+###### (Automatically generated documentation)
+
+# Add Daylight Sensor at the Center of Spaces with a Specified Space Type Assigned
+
+## Description
+This measure will add daylighting controls to spaces that that have space types assigned with names containing the string in the argument. You can also add a cost per space for sensors added to the model.
+
+## Modeler Description
+Make an array of the spaces that meet the criteria. Locate the sensor x and y values by averaging the min and max X and Y values from floor surfaces in the space. If a space already has a daylighting control, do not add a new one and leave the original in place. Warn the user if the space isn't assigned to a thermal zone, or if the space doesn't have any translucent surfaces. Note that the cost is added to the space not the sensor. If the sensor is removed at a later date, the cost will remain.
+
+## Measure Type
+ModelMeasure
+
+## Taxonomy
+
+
+## Arguments
+
+
+### Add Daylight Sensors to Spaces of This Space Type
+
+**Name:** space_type,
+**Type:** Choice,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Daylighting Setpoint
+
+**Name:** setpoint,
+**Type:** Double,
+**Units:** fc,
+**Required:** true,
+**Model Dependent:** false
+
+### Daylighting Control Type
+
+**Name:** control_type,
+**Type:** Choice,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Daylighting Minimum Input Power Fraction
+min = 0 max = 0.6
+**Name:** min_power_fraction,
+**Type:** Double,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Daylighting Minimum Light Output Fraction
+min = 0 max = 0.6
+**Name:** min_light_fraction,
+**Type:** Double,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Fraction of zone controlled by daylight sensors
+
+**Name:** fraction_zone_controlled,
+**Type:** Double,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Sensor Height
+
+**Name:** height,
+**Type:** Double,
+**Units:** inches,
+**Required:** true,
+**Model Dependent:** false
+
+### Material and Installation Costs per Space for Daylight Sensor
+
+**Name:** material_cost,
+**Type:** Double,
+**Units:** $,
+**Required:** true,
+**Model Dependent:** false
+
+### Demolition Costs per Space for Daylight Sensor
+
+**Name:** demolition_cost,
+**Type:** Double,
+**Units:** $,
+**Required:** true,
+**Model Dependent:** false
+
+### Years Until Costs Start
+
+**Name:** years_until_costs_start,
+**Type:** Integer,
+**Units:** whole years,
+**Required:** true,
+**Model Dependent:** false
+
+### Demolition Costs Occur During Initial Construction
+
+**Name:** demo_cost_initial_const,
+**Type:** Boolean,
+**Units:** ,
+**Required:** true,
+**Model Dependent:** false
+
+### Expected Life
+
+**Name:** expected_life,
+**Type:** Integer,
+**Units:** whole years,
+**Required:** true,
+**Model Dependent:** false
+
+### O & M Costs per Space for Daylight Sensor
+
+**Name:** om_cost,
+**Type:** Double,
+**Units:** $,
+**Required:** true,
+**Model Dependent:** false
+
+### O & M Frequency
+
+**Name:** om_frequency,
+**Type:** Integer,
+**Units:** whole years,
+**Required:** true,
+**Model Dependent:** false
+
+
+
+

data/lib/measures/AddDaylightSensors/README.md.erb

@@ -0,0 +1,42 @@
+<%#= README.md.erb is used to auto-generate README.md. %>
+<%#= To manually maintain README.md throw away README.md.erb and manually edit README.md %>
+###### (Automatically generated documentation)
+
+# <%= name %>
+
+## Description
+<%= description %>
+
+## Modeler Description
+<%= modelerDescription %>
+
+## Measure Type
+<%= measureType %>
+
+## Taxonomy
+<%= taxonomy %>
+
+## Arguments
+
+<% arguments.each do |argument| %>
+### <%= argument[:display_name] %>
+<%= argument[:description] %>
+**Name:** <%= argument[:name] %>,
+**Type:** <%= argument[:type] %>,
+**Units:** <%= argument[:units] %>,
+**Required:** <%= argument[:required] %>,
+**Model Dependent:** <%= argument[:model_dependent] %>
+<% end %>
+
+<% if arguments.size == 0 %>
+<%= "This measure does not have any user arguments" %>
+<% end %>
+
+<% if outputs.size > 0 %>
+## Outputs
+<% output_names = [] %>
+<% outputs.each do |output| %>
+<% output_names << output[:display_name] %>
+<% end %>
+<%= output_names.join(", ") %>
+<% end %>

data/lib/measures/AddDaylightSensors/measure.rb

@@ -0,0 +1,521 @@
+# *******************************************************************************
+# OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC.
+# All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# (4) Other than as required in clauses (1) and (2), distributions in any form
+# of modifications or other derivative works may not use the "OpenStudio"
+# trademark, "OS", "os", or any other confusingly similar designation without
+# specific prior written permission from Alliance for Sustainable Energy, LLC.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+# start the measure
+class AddDaylightSensors < OpenStudio::Measure::ModelMeasure
+  # define the name that a user will see
+  def name
+    return 'Add Daylight Sensor at the Center of Spaces with a Specified Space Type Assigned'
+  end
+
+  # human readable description
+  def description
+    return 'This measure will add daylighting controls to spaces that that have space types assigned with names containing the string in the argument. You can also add a cost per space for sensors added to the model.'
+  end
+
+  # human readable description of modeling approach
+  def modeler_description
+    return "Make an array of the spaces that meet the criteria. Locate the sensor x and y values by averaging the min and max X and Y values from floor surfaces in the space. If a space already has a daylighting control, do not add a new one and leave the original in place. Warn the user if the space isn't assigned to a thermal zone, or if the space doesn't have any translucent surfaces. Note that the cost is added to the space not the sensor. If the sensor is removed at a later date, the cost will remain."
+  end
+
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Measure::OSArgumentVector.new
+
+    # make a choice argument for model objects
+    space_type_handles = OpenStudio::StringVector.new
+    space_type_display_names = OpenStudio::StringVector.new
+
+    # putting model object and names into hash
+    space_type_args = model.getSpaceTypes
+    space_type_args_hash = {}
+    space_type_args.each do |space_type_arg|
+      space_type_args_hash[space_type_arg.name.to_s] = space_type_arg
+    end
+
+    # looping through sorted hash of model objects
+    space_type_args_hash.sort.map do |key, value|
+      # only include if space type is used in the model
+      if !value.spaces.empty?
+        space_type_handles << value.handle.to_s
+        space_type_display_names << key
+      end
+    end
+
+    # make a choice argument for space type
+    space_type = OpenStudio::Measure::OSArgument.makeChoiceArgument('space_type', space_type_handles, space_type_display_names, true)
+    space_type.setDisplayName('Add Daylight Sensors to Spaces of This Space Type')
+    args << space_type
+
+    # make an argument for setpoint
+    setpoint = OpenStudio::Measure::OSArgument.makeDoubleArgument('setpoint', true)
+    setpoint.setDisplayName('Daylighting Setpoint')
+    setpoint.setUnits('fc')
+    setpoint.setDefaultValue(45.0)
+    args << setpoint
+
+    # make an argument for control_type
+    chs = OpenStudio::StringVector.new
+    chs << 'None'
+    chs << 'Continuous'
+    chs << 'Stepped'
+    chs << 'Continuous/Off'
+    control_type = OpenStudio::Measure::OSArgument.makeChoiceArgument('control_type', chs)
+    control_type.setDisplayName('Daylighting Control Type')
+    control_type.setDefaultValue('Continuous/Off')
+    args << control_type
+
+    # make an argument for min_power_fraction
+    min_power_fraction = OpenStudio::Measure::OSArgument.makeDoubleArgument('min_power_fraction', true)
+    min_power_fraction.setDisplayName('Daylighting Minimum Input Power Fraction')
+    min_power_fraction.setDescription('min = 0 max = 0.6')
+    min_power_fraction.setDefaultValue(0.3)
+    args << min_power_fraction
+
+    # make an argument for min_light_fraction
+    min_light_fraction = OpenStudio::Measure::OSArgument.makeDoubleArgument('min_light_fraction', true)
+    min_light_fraction.setDisplayName('Daylighting Minimum Light Output Fraction')
+    min_light_fraction.setDescription('min = 0 max = 0.6')
+    min_light_fraction.setDefaultValue(0.2)
+    args << min_light_fraction
+
+    # make an argument for fraction_zone_controlled
+    fraction_zone_controlled = OpenStudio::Measure::OSArgument.makeDoubleArgument('fraction_zone_controlled', true)
+    fraction_zone_controlled.setDisplayName('Fraction of zone controlled by daylight sensors')
+    fraction_zone_controlled.setDefaultValue(1.0)
+    args << fraction_zone_controlled
+
+    # make an argument for height
+    height = OpenStudio::Measure::OSArgument.makeDoubleArgument('height', true)
+    height.setDisplayName('Sensor Height')
+    height.setUnits('inches')
+    height.setDefaultValue(30.0)
+    args << height
+
+    # make an argument for material and installation cost
+    material_cost = OpenStudio::Measure::OSArgument.makeDoubleArgument('material_cost', true)
+    material_cost.setDisplayName('Material and Installation Costs per Space for Daylight Sensor')
+    material_cost.setUnits('$')
+    material_cost.setDefaultValue(0.0)
+    args << material_cost
+
+    # make an argument for demolition cost
+    demolition_cost = OpenStudio::Measure::OSArgument.makeDoubleArgument('demolition_cost', true)
+    demolition_cost.setDisplayName('Demolition Costs per Space for Daylight Sensor')
+    demolition_cost.setUnits('$')
+    demolition_cost.setDefaultValue(0.0)
+    args << demolition_cost
+
+    # make an argument for duration in years until costs start
+    years_until_costs_start = OpenStudio::Measure::OSArgument.makeIntegerArgument('years_until_costs_start', true)
+    years_until_costs_start.setDisplayName('Years Until Costs Start')
+    years_until_costs_start.setUnits('whole years')
+    years_until_costs_start.setDefaultValue(0)
+    args << years_until_costs_start
+
+    # make an argument to determine if demolition costs should be included in initial construction
+    demo_cost_initial_const = OpenStudio::Measure::OSArgument.makeBoolArgument('demo_cost_initial_const', true)
+    demo_cost_initial_const.setDisplayName('Demolition Costs Occur During Initial Construction')
+    demo_cost_initial_const.setDefaultValue(false)
+    args << demo_cost_initial_const
+
+    # make an argument for expected life
+    expected_life = OpenStudio::Measure::OSArgument.makeIntegerArgument('expected_life', true)
+    expected_life.setDisplayName('Expected Life')
+    expected_life.setUnits('whole years')
+    expected_life.setDefaultValue(20)
+    args << expected_life
+
+    # make an argument for o&m cost
+    om_cost = OpenStudio::Measure::OSArgument.makeDoubleArgument('om_cost', true)
+    om_cost.setDisplayName('O & M Costs per Space for Daylight Sensor')
+    om_cost.setUnits('$')
+    om_cost.setDefaultValue(0.0)
+    args << om_cost
+
+    # make an argument for o&m frequency
+    om_frequency = OpenStudio::Measure::OSArgument.makeIntegerArgument('om_frequency', true)
+    om_frequency.setDisplayName('O & M Frequency')
+    om_frequency.setUnits('whole years')
+    om_frequency.setDefaultValue(1)
+    args << om_frequency
+
+    return args
+  end
+
+  # define what happens when the measure is run
+  def run(model, runner, user_arguments)
+    super(model, runner, user_arguments)
+
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      return false
+    end
+
+    # assign the user inputs to variables
+    space_type = runner.getOptionalWorkspaceObjectChoiceValue('space_type', user_arguments, model)
+    setpoint = runner.getDoubleArgumentValue('setpoint', user_arguments)
+    control_type = runner.getStringArgumentValue('control_type', user_arguments)
+    min_power_fraction = runner.getDoubleArgumentValue('min_power_fraction', user_arguments)
+    min_light_fraction = runner.getDoubleArgumentValue('min_light_fraction', user_arguments)
+    fraction_zone_controlled = runner.getDoubleArgumentValue('fraction_zone_controlled', user_arguments)
+    height = runner.getDoubleArgumentValue('height', user_arguments)
+    material_cost = runner.getDoubleArgumentValue('material_cost', user_arguments)
+    demolition_cost = runner.getDoubleArgumentValue('demolition_cost', user_arguments)
+    years_until_costs_start = runner.getIntegerArgumentValue('years_until_costs_start', user_arguments)
+    demo_cost_initial_const = runner.getBoolArgumentValue('demo_cost_initial_const', user_arguments)
+    expected_life = runner.getIntegerArgumentValue('expected_life', user_arguments)
+    om_cost = runner.getDoubleArgumentValue('om_cost', user_arguments)
+    om_frequency = runner.getIntegerArgumentValue('om_frequency', user_arguments)
+
+    # check the space_type for reasonableness
+    if space_type.empty?
+      handle = runner.getStringArgumentValue('space_type', user_arguments)
+      if handle.empty?
+        runner.registerError('No SpaceType was chosen.')
+      else
+        runner.registerError("The selected space type with handle '#{handle}' was not found in the model. It may have been removed by another measure.")
+      end
+      return false
+    else
+      if !space_type.get.to_SpaceType.empty?
+        space_type = space_type.get.to_SpaceType.get
+      else
+        runner.registerError('Script Error - argument not showing up as space type.')
+        return false
+      end
+    end
+
+    # check the setpoint for reasonableness
+    if (setpoint < 0) || (setpoint > 9999) # dfg need input on good value
+      runner.registerError("A setpoint of #{setpoint} foot-candles is outside the measure limit.")
+      return false
+    elsif setpoint > 999
+      runner.registerWarning("A setpoint of #{setpoint} foot-candles is abnormally high.") # dfg need input on good value
+    end
+
+    # check the min_power_fraction for reasonableness
+    if (min_power_fraction < 0.0) || (min_power_fraction > 0.6)
+      runner.registerError("The requested minimum input power fraction of #{min_power_fraction} for continuous dimming control is outside the acceptable range of 0 to 0.6.")
+      return false
+    end
+
+    # check the min_light_fraction for reasonableness
+    if (min_light_fraction < 0.0) || (min_light_fraction > 0.6)
+      runner.registerError("The requested minimum light output fraction of #{min_light_fraction} for continuous dimming control is outside the acceptable range of 0 to 0.6.")
+      return false
+    end
+
+    # check the height for reasonableness
+    if (height < -360) || (height > 360) # neg ok because space origin may not be floor
+      runner.registerError("A setpoint of #{height} inches is outside the measure limit.")
+      return false
+    elsif height > 72
+      runner.registerWarning("A setpoint of #{height} inches is abnormally high.")
+      elseif height < 0
+      runner.registerWarning('Typically the sensor height should be a positive number, however if your space origin is above the floor then a negative sensor height may be approriate.')
+    end
+
+    # set flags to use later
+    costs_requested = false
+    warning_cost_assign_to_space = false
+
+    # check costs for reasonableness
+    if material_cost.abs + demolition_cost.abs + om_cost.abs == 0
+      runner.registerInfo('No costs were requested for Daylight Sensors.')
+    else
+      costs_requested = true
+    end
+
+    # check lifecycle arguments for reasonableness
+    if (years_until_costs_start < 0) && (years_until_costs_start > expected_life)
+      runner.registerError('Years until costs start should be a non-negative integer less than Expected Life.')
+    end
+    if (expected_life < 1) && (expected_life > 100)
+      runner.registerError('Choose an integer greater than 0 and less than or equal to 100 for Expected Life.')
+    end
+    if om_frequency < 1
+      runner.registerError('Choose an integer greater than 0 for O & M Frequency.')
+    end
+
+    # short def to make numbers pretty (converts 4125001.25641 to 4,125,001.26 or 4,125,001). The definition be called through this measure
+    def neat_numbers(number, roundto = 2) # round to 0 or 2)
+      if roundto == 2
+        number = format '%.2f', number
+      else
+        number = number.round
+      end
+      # regex to add commas
+      number.to_s.reverse.gsub(/([0-9]{3}(?=([0-9])))/, '\\1,').reverse
+    end
+
+    # helper that loops through lifecycle costs getting total costs under "Construction" or "Salvage" category and add to counter if occurs during year 0
+    def get_total_costs_for_objects(objects)
+      counter = 0
+      objects.each do |object|
+        object_LCCs = object.lifeCycleCosts
+        object_LCCs.each do |object_LCC|
+          if (object_LCC.category == 'Construction') || (object_LCC.category == 'Salvage')
+            if object_LCC.yearsFromStart == 0
+              counter += object_LCC.totalCost
+            end
+          end
+        end
+      end
+      return counter
+    end
+
+    # unit conversion from IP units to SI units
+    setpoint_si = OpenStudio.convert(setpoint, 'fc', 'lux').get
+    height_si = OpenStudio.convert(height, 'in', 'm').get
+
+    # variable to tally the area to which the overall measure is applied
+    area = 0
+    # variables to aggregate the number of sensors installed and the area affected
+    sensor_count = 0
+    sensor_area = 0
+    spaces_using_space_type = space_type.spaces
+    # array with subset of spaces
+    spaces_using_space_type_in_zones_without_sensors = []
+    affected_zones = []
+    affected_zone_names = []
+    # hash to hold sensor objects
+    new_sensor_objects = {}
+
+    # reporting initial condition of model
+    starting_spaces = model.getSpaces
+    runner.registerInitialCondition("#{spaces_using_space_type.size} spaces are assigned to space type '#{space_type.name}'.")
+
+    # get starting costs for spaces
+    yr0_capital_totalCosts = -1 * get_total_costs_for_objects(spaces_using_space_type)
+
+    # test that there is no sensor already in the space, and that zone object doesn't already have sensors assigned.
+    spaces_using_space_type.each do |space_using_space_type|
+      if space_using_space_type.daylightingControls.empty?
+        space_zone = space_using_space_type.thermalZone
+        if !space_zone.empty?
+          space_zone = space_zone.get
+          if space_zone.primaryDaylightingControl.empty? && space_zone.secondaryDaylightingControl.empty?
+            spaces_using_space_type_in_zones_without_sensors << space_using_space_type
+          elsif
+            runner.registerWarning("Thermal zone '#{space_zone.name}' which includes space '#{space_using_space_type.name}' already had a daylighting sensor. No sensor was added to space '#{space_using_space_type.name}'.")
+          end
+        else
+          runner.registerWarning("Space '#{space_using_space_type.name}' is not associated with a thermal zone. It won't be part of the EnergyPlus simulation.")
+        end
+      else
+        runner.registerWarning("Space '#{space_using_space_type.name}' already has a daylighting sensor. No sensor was added.")
+      end
+    end
+
+    # loop through all spaces,
+    # and add a daylighting sensor with dimming to each
+    space_count = 0
+    spaces_using_space_type_in_zones_without_sensors.each do |space|
+      space_count += 1
+      area += space.floorArea
+
+      # eliminate spaces that don't have exterior natural lighting
+      has_ext_nat_light = false
+      space.surfaces.each do |surface|
+        next if surface.outsideBoundaryCondition != 'Outdoors'
+        surface.subSurfaces.each do |sub_surface|
+          next if sub_surface.subSurfaceType == 'Door'
+          next if sub_surface.subSurfaceType == 'OverheadDoor'
+          has_ext_nat_light = true
+        end
+      end
+      if has_ext_nat_light == false
+        runner.registerWarning("Space '#{space.name}' has no exterior natural lighting. No sensor will be added.")
+        next
+      end
+
+      # find floors
+      floors = []
+      space.surfaces.each do |surface|
+        next if surface.surfaceType != 'Floor'
+        floors << surface
+      end
+
+      # this method only works for flat (non-inclined) floors
+      boundingBox = OpenStudio::BoundingBox.new
+      floors.each do |floor|
+        boundingBox.addPoints(floor.vertices)
+      end
+      xmin = boundingBox.minX.get
+      ymin = boundingBox.minY.get
+      zmin = boundingBox.minZ.get
+      xmax = boundingBox.maxX.get
+      ymax = boundingBox.maxY.get
+
+      # create a new sensor and put at the center of the space
+      sensor = OpenStudio::Model::DaylightingControl.new(model)
+      sensor.setName("#{space.name} daylighting control")
+      x_pos = (xmin + xmax) / 2
+      y_pos = (ymin + ymax) / 2
+      z_pos = zmin + height_si # put it 1 meter above the floor
+      new_point = OpenStudio::Point3d.new(x_pos, y_pos, z_pos)
+      sensor.setPosition(new_point)
+      sensor.setIlluminanceSetpoint(setpoint_si)
+      sensor.setLightingControlType(control_type)
+      sensor.setMinimumInputPowerFractionforContinuousDimmingControl(min_power_fraction)
+      sensor.setMinimumLightOutputFractionforContinuousDimmingControl(min_light_fraction)
+      sensor.setSpace(space)
+      puts sensor
+
+      # add lifeCycleCost objects if there is a non-zero value in one of the cost arguments
+      if costs_requested == true
+
+        starting_lcc_counter = space.lifeCycleCosts.size
+
+        # adding new cost items
+        lcc_mat = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{sensor.name}", space, material_cost, 'CostPerEach', 'Construction', expected_life, years_until_costs_start)
+        if demo_cost_initial_const
+          lcc_demo = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Demo - #{sensor.name}", space, demolition_cost, 'CostPerEach', 'Salvage', expected_life, years_until_costs_start)
+        else
+          lcc_demo = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Demo - #{sensor.name}", space, demolition_cost, 'CostPerEach', 'Salvage', expected_life, years_until_costs_start + expected_life)
+        end
+        lcc_om = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_OM - #{sensor.name}", space, om_cost, 'CostPerEach', 'Maintenance', om_frequency, 0)
+
+        if space.lifeCycleCosts.size - starting_lcc_counter == 3
+          if !warning_cost_assign_to_space
+            runner.registerInfo('Cost for daylight sensors was added to spaces. The cost will remain in the model unless the space is removed. Removing only the sensor will not remove the cost.')
+            warning_cost_assign_to_space = true
+          end
+        else
+          runner.registerWarning("The measure did not function as expected. #{space.lifeCycleCosts.size - starting_lcc_counter} LifeCycleCost objects were made, 3 were expected.")
+        end
+
+      end
+
+      # push unique zones to array for use later in measure
+      temp_zone = space.thermalZone.get
+      if affected_zone_names.include?(temp_zone.name.to_s) == false
+        affected_zones << temp_zone
+        affected_zone_names << temp_zone.name.to_s
+      end
+
+      # push sensor object into hash with space name
+      new_sensor_objects[space.name.to_s] = sensor
+
+      # add floor area to the daylighting area tally
+      sensor_area += space.floorArea
+
+      # add to sensor count for reporting
+      sensor_count += 1
+    end
+
+    if (sensor_count == 0) && (costs_requested == false)
+      runner.registerAsNotApplicable("No spaces that currently don't have sensor required a new sensor, and no lifecycle costs objects were requested.")
+      return true
+    end
+
+    # loop through thermal Zones for spaces with daylighting controls added
+    affected_zones.each do |zone|
+      zone_spaces = zone.spaces
+      zone_spaces_with_new_sensors = []
+      zone_spaces.each do |zone_space|
+        if !zone_space.daylightingControls.empty? && (zone_space.spaceType.get == space_type)
+          zone_spaces_with_new_sensors << zone_space
+        end
+      end
+
+      if !zone_spaces_with_new_sensors.empty?
+        # need to identify the two largest spaces
+        primary_area = 0
+        secondary_area = 0
+        primary_space = nil
+        secondary_space = nil
+        three_or_more_sensors = false
+
+        # dfg temp - need to add another if statement so only get spaces with sensors
+        zone_spaces_with_new_sensors.each do |zone_space|
+          zone_space_area = zone_space.floorArea
+          if zone_space_area > primary_area
+            primary_area = zone_space_area
+            primary_space = zone_space
+          elsif zone_space_area > secondary_area
+            secondary_area = zone_space_area
+            secondary_space = zone_space
+          else
+            # setup flag to warn user that more than 2 sensors can't be added to a space
+            three_or_more_sensors = true
+          end
+        end
+
+        if primary_space
+          # setup primary sensor
+          sensor_primary = new_sensor_objects[primary_space.name.to_s]
+          zone.setPrimaryDaylightingControl(sensor_primary)
+          zone.setFractionofZoneControlledbyPrimaryDaylightingControl(fraction_zone_controlled * primary_area / (primary_area + secondary_area))
+        end
+
+        if secondary_space
+          # setup secondary sensor
+          sensor_secondary = new_sensor_objects[secondary_space.name.to_s]
+          zone.setSecondaryDaylightingControl(sensor_secondary)
+          zone.setFractionofZoneControlledbySecondaryDaylightingControl(fraction_zone_controlled * secondary_area / (primary_area + secondary_area))
+        end
+
+        # warn that additional sensors were not used
+        if three_or_more_sensors == true
+          runner.registerWarning("Thermal zone '#{zone.name}' had more than two spaces with sensors. Only two sensors were associated with the thermal zone.")
+        end
+
+      end
+    end
+
+    # setup OpenStudio units that we will need
+    unit_area_ip = OpenStudio.createUnit('ft^2').get
+    unit_area_si = OpenStudio.createUnit('m^2').get
+
+    # define starting units
+    area_si = OpenStudio::Quantity.new(sensor_area, unit_area_si)
+
+    # unit conversion from IP units to SI units
+    area_ip = OpenStudio.convert(area_si, unit_area_ip).get
+
+    # get final costs for spaces
+    yr0_capital_totalCosts = get_total_costs_for_objects(spaces_using_space_type)
+
+    # reporting final condition of model
+    runner.registerFinalCondition("Added daylighting controls to #{sensor_count} spaces, covering #{area_ip}. Initial year costs associated with the daylighting controls is $#{neat_numbers(yr0_capital_totalCosts, 0)}.")
+
+    return true
+  end
+end
+
+# this allows the measure to be used by the application
+AddDaylightSensors.new.registerWithApplication