Class: ZEDGK12FenestrationAndDaylightingControls

Inherits:

OpenStudio::Measure::ModelMeasure

Object
OpenStudio::Measure::ModelMeasure
ZEDGK12FenestrationAndDaylightingControls

show all

Defined in:: lib/measures/zedgk_12_fenestration_and_daylighting_controls/measure.rb

Overview

start the measure

Instance Method Summary collapse

#arguments(model) ⇒ Object

define the arguments that the user will input.
#name ⇒ Object

define the name that a user will see, this method may be deprecated as the display name in PAT comes from the name field in measure.xml.
#run(model, runner, user_arguments) ⇒ Object

define what happens when the measure is run.

Instance Method Details

#arguments(model) ⇒ `Object`

define the arguments that the user will input

# File 'lib/measures/zedgk_12_fenestration_and_daylighting_controls/measure.rb', line 36

def arguments(model)
  args = OpenStudio::Measure::OSArgumentVector.new

  # make an argument for cost of cost_daylight_glazing
  cost_daylight_glazing = OpenStudio::Measure::OSArgument.makeDoubleArgument('cost_daylight_glazing', true)
  cost_daylight_glazing.setDisplayName('Cost per Area for Proposed Daylighting Window Constructions ($/ft^2).')
  cost_daylight_glazing.setDefaultValue(0.0)
  args << cost_daylight_glazing

  # make an argument for cost of cost_view_glazing
  cost_view_glazing = OpenStudio::Measure::OSArgument.makeDoubleArgument('cost_view_glazing', true)
  cost_view_glazing.setDisplayName('Cost per Area for Proposed View Window Constructions ($/ft^2).')
  cost_view_glazing.setDefaultValue(0.0)
  args << cost_view_glazing

  # make an argument for cost of cost_shading_surface (todo - later would be nice to change to linear)
  cost_shading_surface = OpenStudio::Measure::OSArgument.makeDoubleArgument('cost_shading_surface', true)
  cost_shading_surface.setDisplayName('Cost per Area for Proposed Exterior Shading Surface Construction ($/ft^2).')
  cost_shading_surface.setDefaultValue(0.0)
  args << cost_shading_surface

  # make an argument for cost of cost_light_shelf (todo - later would be nice to change to linear)
  cost_light_shelf = OpenStudio::Measure::OSArgument.makeDoubleArgument('cost_light_shelf', true)
  cost_light_shelf.setDisplayName('Cost per Area for Proposed Light Shelf Construction ($/ft^2).')
  cost_light_shelf.setDefaultValue(0.0)
  args << cost_light_shelf

  return args
end

#name ⇒ `Object`

define the name that a user will see, this method may be deprecated as the display name in PAT comes from the name field in measure.xml



31
32
33

# File 'lib/measures/zedgk_12_fenestration_and_daylighting_controls/measure.rb', line 31

def name
  return 'ZEDG K12 - Fenestration and Daylighting Controls'
end

#run(model, runner, user_arguments) ⇒ `Object`

define what happens when the measure is run

# File 'lib/measures/zedgk_12_fenestration_and_daylighting_controls/measure.rb', line 67

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
  cost_daylight_glazing = runner.getDoubleArgumentValue('cost_daylight_glazing', user_arguments)
  cost_view_glazing = runner.getDoubleArgumentValue('cost_daylight_glazing', user_arguments)
  cost_shading_surface = runner.getDoubleArgumentValue('cost_shading_surface', user_arguments)
  cost_light_shelf = runner.getDoubleArgumentValue('cost_light_shelf', user_arguments)

  non_neg_args = ['cost_daylight_glazing', 'cost_view_glazing', 'cost_shading_surface', 'cost_light_shelf']
  non_neg = OsLib_HelperMethods.checkDoubleAndIntegerArguments(runner, user_arguments, 'min' => 0.0, 'max' => nil, 'min_eq_bool' => true, 'max_eq_bool' => false, 'arg_array' => non_neg_args)
  if !non_neg then return false end

  # get climate zone
  climateZoneNumber = OsLib_AedgMeasures.getClimateZoneNumber(model, runner)

  # add message if climate zone can't be found
  if climateZoneNumber == false
    return false
  end

  # customized Ufactor and SHGC for ZEDG (same vales regardless of framing)
  viewFenestrationRules = [] # climate zone, framing material, Ufactor(ip), SHGC-N, SHGC-S, SHGC-EW, VT-NSEW, FFR-NS, FFR-EW, overhang-S
  viewFenestrationRules << ['0', 'NonmetalFraming', 0.50, 0.21, 0.21, 0.21, 0.3, 0.07, 0.05, 0.5] # measure not setup to use cz 0
  viewFenestrationRules << ['1', 'NonmetalFraming', 0.50, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['2', 'NonmetalFraming', 0.50, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5] # higher conductance than 50% AEDG
  viewFenestrationRules << ['3', 'NonmetalFraming', 0.45, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5] # higher conductance than 50% AEDG
  viewFenestrationRules << ['4', 'NonmetalFraming', 0.36, 0.34, 0.34, 0.34, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['5', 'NonmetalFraming', 0.36, 0.36, 0.36, 0.36, 0.3, 0.07, 0.05, 0.5] # higher conductance than 50% AEDG
  viewFenestrationRules << ['6', 'NonmetalFraming', 0.34, 0.38, 0.38, 0.38, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['7', 'NonmetalFraming', 0.31, 0.43, 0.43, 0.43, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['8', 'NonmetalFraming', 0.28, 0.43, 0.43, 0.43, 0.3, 0.07, 0.05, 0.5] # higher conductance than 50% AEDG
  viewFenestrationRules << ['0', 'MetalFraming', 0.50, 0.21, 0.21, 0.21, 0.3, 0.07, 0.05, 0.5] # measure not setup to use cz 0
  viewFenestrationRules << ['1', 'MetalFraming', 0.50, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['2', 'MetalFraming', 0.50, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['3', 'MetalFraming', 0.45, 0.24, 0.24, 0.24, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['4', 'MetalFraming', 0.36, 0.34, 0.34, 0.34, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['5', 'MetalFraming', 0.36, 0.36, 0.36, 0.36, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['6', 'MetalFraming', 0.34, 0.38, 0.38, 0.38, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['7', 'MetalFraming', 0.31, 0.43, 0.43, 0.43, 0.3, 0.07, 0.05, 0.5]
  viewFenestrationRules << ['8', 'MetalFraming', 0.28, 0.43, 0.43, 0.43, 0.3, 0.07, 0.05, 0.5]

  # make rule hash for cleaner code
  viewFenestrationRulesHash = {}
  viewFenestrationRules.each do |rule|
    viewFenestrationRulesHash["#{rule[0]} #{rule[1]}"] = { 'uFactor' => rule[2], 'sHGC-N' => rule[3], 'sHGC-S' => rule[4], 'sHGC-EW' => rule[5], 'vT-NSEW' => rule[6], 'fFR-NS' => rule[7], 'fFR-EW' => rule[8], 'overhang-S' => rule[9] }
  end

  # setup rules daylighting fenestration and skylights (from Table 5-5)
  daylightFenestrationRules = [] # climate zone, Ufactor(ip), SHGC-NS, VT-NS,DFRmin, DFRmix (not sure if use min, max, or avg. U value and SHGC came from Table 3-30 of TSD)
  # 03/23/17 - changing U factor for vertical daylight glazing to match view windows vs. 0.97
  daylightFenestrationRules << ['1', 'LightShelf', 0.50, 0.58, 0.8, 0.06, 0.05]
  daylightFenestrationRules << ['2', 'LightShelf', 0.50, 0.58, 0.8, 0.06, 0.09]
  daylightFenestrationRules << ['3', 'LightShelf', 0.45, 0.58, 0.8, 0.07, 0.10]
  daylightFenestrationRules << ['4', 'LightShelf', 0.36, 0.58, 0.8, 0.07, 0.10]
  daylightFenestrationRules << ['5', 'LightShelf', 0.36, 0.58, 0.8, 0.07, 0.10]
  daylightFenestrationRules << ['6', 'LightShelf', 0.34, 0.58, 0.8, 0.08, 0.11]
  daylightFenestrationRules << ['7', 'LightShelf', 0.31, 0.58, 0.8, 0.10, 0.13]
  daylightFenestrationRules << ['8', 'LightShelf', 0.28, 0.58, 0.8, 0.10, 0.13]
  daylightFenestrationRules << ['1', 'NorthHigh', 0.50, 0.58, 0.8, 0.09, 0.12]
  daylightFenestrationRules << ['2', 'NorthHigh', 0.50, 0.58, 0.8, 0.09, 0.12]
  daylightFenestrationRules << ['3', 'NorthHigh', 0.45, 0.58, 0.8, 0.10, 0.13]
  daylightFenestrationRules << ['4', 'NorthHigh', 0.36, 0.58, 0.8, 0.10, 0.13]
  daylightFenestrationRules << ['5', 'NorthHigh', 0.36, 0.58, 0.8, 0.10, 0.13]
  daylightFenestrationRules << ['6', 'NorthHigh', 0.34, 0.58, 0.8, 0.11, 0.14]
  daylightFenestrationRules << ['7', 'NorthHigh', 0.31, 0.58, 0.8, 0.13, 0.16]
  daylightFenestrationRules << ['8', 'NorthHigh', 0.28, 0.58, 0.8, 0.13, 0.16]
  # skylight not used for zedg
  daylightFenestrationRules << ['1', 'Skylight', 0.97, 0.18, 0.2, 0.02, 0.05]
  daylightFenestrationRules << ['2', 'Skylight', 0.97, 0.18, 0.2, 0.02, 0.05]
  daylightFenestrationRules << ['3', 'Skylight', 0.97, 0.18, 0.2, 0.03, 0.05]
  daylightFenestrationRules << ['4', 'Skylight', 0.97, 0.18, 0.2, 0.03, 0.05]
  daylightFenestrationRules << ['5', 'Skylight', 0.97, 0.18, 0.2, 0.03, 0.05]
  daylightFenestrationRules << ['6', 'Skylight', 0.97, 0.18, 0.2, 0.04, 0.05]
  daylightFenestrationRules << ['7', 'Skylight', 0.97, 0.18, 0.2, 0.04, 0.05]
  daylightFenestrationRules << ['8', 'Skylight', 0.97, 0.18, 0.2, 0.04, 0.05]

  # added to support climate zone 0 run, using values from climate zone 1
  daylightFenestrationRules << ['0', 'LightShelf', 0.50, 0.58, 0.8, 0.06, 0.05]
  daylightFenestrationRules << ['0', 'NorthHigh', 0.50, 0.58, 0.8, 0.09, 0.12]
  daylightFenestrationRules << ['0', 'Skylight', 0.50, 0.18, 0.2, 0.02, 0.05]

  # make rule hash for cleaner code
  daylightFenestrationRulesHash = {}
  daylightFenestrationRules.each do |rule|
    daylightFenestrationRulesHash["#{rule[0]} #{rule[1]}"] = { 'uFactor' => rule[2], 'sHGC' => rule[3], 'vT' => rule[4], 'dFRmin' => rule[5], 'dFRmax' => rule[6] }
  end

  # misc variables (some could become user arguments)
  southRangeStart = 150.0
  southRangeEnd = 210.0
  northRangeStart = 330.0
  northRangeEnd = 30.0
  sill = OpenStudio.convert(2.5, 'ft', 'm').get
  header = OpenStudio.convert(1.0, 'ft', 'm').get
  shadingProjectionFactor = 0.5
  lightShelfProjectionFactor = 1.0
  skylightSize = OpenStudio.convert(6.0, 'ft', 'm').get
  daylightSensorHeight = OpenStudio.convert(3.0, 'ft', 'm').get
  daylightMinOppositeWallClearance = OpenStudio.convert(2.0, 'ft', 'm').get
  targetFcGeneralInstruction = OpenStudio.convert(40.0, 'fc', 'lux').get # range is 45-50 fc. There is lower 30-50 range for on the teaching wall
  viewWindowFramingType = 'MetalFraming'
  daylightingControlType = 'Continuous'
  expected_life = 25
  years_until_costs_start = 0
  uFactorIpToSiConversion = OpenStudio.convert(1.0, 'Btu/ft^2*h*R', 'W/m^2*K').get

  # create new constructions
  options = { 'constructionName' => 'ZEDG-K12 View Glazing North',
              'materialName' => 'ZEDG-K12 View Glazing North-mat',
              'uFactor' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['uFactor'] * uFactorIpToSiConversion,
              'solarHeatGainCoef' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['sHGC-N'],
              'visibleTransmittance' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['vT-NSEW'] }
  viewConstructionNorth = OsLib_Constructions.createConstructionWithSimpleGlazing(model, runner, options)

  options = { 'constructionName' => 'ZEDG-K12 View Glazing South',
              'materialName' => 'ZEDG-K12 View Glazing South-mat',
              'uFactor' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['uFactor'] * uFactorIpToSiConversion,
              'solarHeatGainCoef' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['sHGC-S'],
              'visibleTransmittance' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['vT-NSEW'] }
  viewConstructionSouth = OsLib_Constructions.createConstructionWithSimpleGlazing(model, runner, options)

  options = { 'constructionName' => 'ZEDG-K12 View Glazing EastWest',
              'materialName' => 'ZEDG-K12 View Glazing EastWest-mat',
              'uFactor' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['uFactor'] * uFactorIpToSiConversion,
              'solarHeatGainCoef' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['sHGC-EW'],
              'visibleTransmittance' => viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['vT-NSEW'] }
  viewConstructionEastWest = OsLib_Constructions.createConstructionWithSimpleGlazing(model, runner, options)

  options = { 'constructionName' => 'ZEDG-K12 Daylight Glazing South',
              'materialName' => 'ZEDG-K12 Daylight Glazing South-mat',
              'uFactor' => daylightFenestrationRulesHash["#{climateZoneNumber} LightShelf"]['uFactor'] * uFactorIpToSiConversion,
              'solarHeatGainCoef' => daylightFenestrationRulesHash["#{climateZoneNumber} LightShelf"]['sHGC'],
              'visibleTransmittance' => daylightFenestrationRulesHash["#{climateZoneNumber} LightShelf"]['vT'] }
  daylightConstructionSouth = OsLib_Constructions.createConstructionWithSimpleGlazing(model, runner, options)

  options = { 'constructionName' => 'ZEDG-K12 Daylight Glazing North',
              'materialName' => 'ZEDG-K12 Daylight Glazing North-mat',
              'uFactor' => daylightFenestrationRulesHash["#{climateZoneNumber} NorthHigh"]['uFactor'] * uFactorIpToSiConversion,
              'solarHeatGainCoef' => daylightFenestrationRulesHash["#{climateZoneNumber} NorthHigh"]['sHGC'],
              'visibleTransmittance' => daylightFenestrationRulesHash["#{climateZoneNumber} NorthHigh"]['vT'] }
  daylightConstructionNorth = OsLib_Constructions.createConstructionWithSimpleGlazing(model, runner, options)

  # light shelf construction
  lightShelfMaterial = OpenStudio::Model::StandardOpaqueMaterial.new(model)
  lightShelfMaterial.setName('ZEDG-K12 LightShelf-mat')
  lightShelfMaterial.setThermalAbsorptance(0.4)
  lightShelfMaterial.setSolarAbsorptance(0.4)
  lightShelfMaterial.setVisibleAbsorptance(0.3)
  lightShelfMaterial.setRoughness('MediumSmooth')
  lightShelfMaterial.setSpecificHeat(100.0)
  lightShelfConstruction = OpenStudio::Model::Construction.new(model)
  lightShelfConstruction.setName('ZEDG-K12 LightShelf')
  lightShelfConstruction.insertLayer(0, lightShelfMaterial)
  runner.registerInfo("Created #{lightShelfConstruction.name} construction for light shelves. Visible absorptance is #{lightShelfMaterial.visibleAbsorptance}.")

  # exterior shading surface construction
  exteriorShadeMaterial = OpenStudio::Model::StandardOpaqueMaterial.new(model)
  exteriorShadeMaterial.setName('ZEDG-K12 ExteriorShade-mat')
  exteriorShadeMaterial.setSpecificHeat(100.0)
  exteriorShadeConstruction = OpenStudio::Model::Construction.new(model)
  exteriorShadeConstruction.setName('ZEDG-K12 ExteriorShade')
  exteriorShadeConstruction.insertLayer(0, exteriorShadeMaterial)
  runner.registerInfo("Created #{exteriorShadeConstruction.name} construction for exterior shading surfaces.")

  # add cost to new constructions
  lcc_mat_view_north = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{viewConstructionNorth.name}", viewConstructionNorth, OpenStudio.convert(cost_view_glazing, 'ft^2', 'm^2').get, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
  lcc_mat_view_south = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{viewConstructionSouth.name}", viewConstructionSouth, OpenStudio.convert(cost_view_glazing, 'ft^2', 'm^2').get, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
  lcc_mat_view_eastWest = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{viewConstructionEastWest.name}", viewConstructionEastWest, OpenStudio.convert(cost_view_glazing, 'ft^2', 'm^2').get, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
  lcc_mat_daylight_glazing_north = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{daylightConstructionNorth.name}", daylightConstructionNorth, OpenStudio.convert(cost_daylight_glazing, 'ft^2', 'm^2').get, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
  lcc_mat_daylight_glazing_south = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat - #{daylightConstructionSouth.name}", daylightConstructionSouth, OpenStudio.convert(cost_daylight_glazing, 'ft^2', 'm^2').get, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)

  # create blind material
  shadingMaterial = OpenStudio::Model::Blind.new(model)

  # create shading control object
  shadingControl = OpenStudio::Model::ShadingControl.new(shadingMaterial)
  runner.registerInfo('Adding shading control object to connect to east and west view windows.')

  # array of space standards types for various daylighting conditions
  daylightingPerimeterOnly = ['Office'] # 15' (not currently using this for anything)
  daylightingCandidate = ['Auditorium', 'Cafeteria', 'Classroom', 'Corridor', 'Gym', 'Kitchen', 'Library', 'Lobby', 'Office', 'Restroom', 'Artroom'] # only "Mechanical" is excluded
  viewGlazingCandidate = ['Auditorium', 'Cafeteria', 'Classroom', 'Corridor', 'Gym', 'Library', 'Lobby', 'Office', 'Artroom'] # only "Mechanical","Kitchen","Restroom" are excluded
  # originally I listed only space not to receive view and daylighting windows, but reversed it to address attics and plenums. I could change it back to this approach, but then only add fenestration to surfaces that are part of the building area.
  topLightingCandidate = ['Gym', 'Library', 'Cafeteria']
  topLightingIfNoSideLighting = ['Lobby', 'Corridor', 'Classroom', 'Office'] # not currently using this

  # get window to wall ratio for initial condition
  initialGrossWWR = OsLib_Geometry.getExteriorWindowToWallRatio(model.getSpaces)
  spacesPartOfFloorArea = []
  model.getSpaces.each do |space|
    if space.partofTotalFloorArea
      spacesPartOfFloorArea << space
    end
  end
  initialNetWWR = OsLib_Geometry.getExteriorWindowToWallRatio(spacesPartOfFloorArea)

  # store original cost of construction objects for use in final condition.
  initialEnvelopeCost = OsLib_Constructions.getTotalCostOfSelectedConstructions(model.getConstructions)

  # initial condition of model
  if spacesPartOfFloorArea.size < model.getSpaces.size
    runner.registerInitialCondition("The building started with a gross window to wall ratio of #{OpenStudio.toNeatString(initialGrossWWR, 2, true)}, and a net window to wall ratio (including only spaces counted in building area) of  #{OpenStudio.toNeatString(initialNetWWR, 2, true)}.")
  else
    runner.registerInitialCondition("The building started with a window to wall ratio of #{OpenStudio.toNeatString(initialGrossWWR, 2, true)}.")
  end

  # remove all fenestration in the model except for opaque doors
  runner.registerInfo('Removing existing translucent exterior surfaces.')
  model.getSubSurfaces.each do |subSurface|
    unless (subSurface.subSurfaceType == 'Door') || (subSurface.subSurfaceType == 'OverheadDoor')
      next if subSurface.outsideBoundaryCondition != 'Outdoors' # don't need to mess with interior fenestration
      subSurface.remove
    end
  end

  # remove existing daylight control objects
  if !model.getDaylightingControls.empty?
    runner.registerInfo("Removing #{model.getDaylightingControls.size} existing daylight control objects.")
    model.getDaylightingControls.each(&:remove)
  end

  # split doors to their own base surfaces
  model.getSurfaces.each do |surface|
    subSurfaces = surface.splitSurfaceForSubSurfaces
  end

  # put cap on wwr to prevent odd windows at deep spaces with little exterior exposure.
  wwrCapValue = 0.45
  wwrCapFlag = 0

  # info messages
  runner.registerInfo('Adding new fenestration.')
  runner.registerInfo('Adding new daylighting control objects.')

  # loop through spaces adding appropriate fenestration
  # this will contain a sub loop through surfaces. in that sub loop test for non full height walls, add only daylight windows there.
  model.getThermalZones.each do |thermalZone|
    # hash of spaces with data necessary to place daylighting control points and to. [floor area, north exterior wall area, south exterior wall area, north daylight wwr, south daylight wwr, skylight ratio]
    zoneSpacesHash = {}

    thermalZone.spaces.each do |space|
      # create array of z values for floor
      floorArray = []
      space.surfaces.each do |surface|
        next unless surface.surfaceType == 'Floor'
        floorArray << surface
      end

      # run helper method to get array of z values for floors
      floorSurfacesZValueArray = OsLib_Geometry.getSurfaceZValues(floorArray)

      # create array of z values for floor
      ceilingArray = []
      space.surfaces.each do |surface|
        next unless surface.surfaceType == 'RoofCeiling'
        ceilingArray << surface
      end

      # run helper method to get array of z values for ceilings
      ceilingSurfacesZValueArray = OsLib_Geometry.getSurfaceZValues(ceilingArray)

      # misc space counters and
      floorArea = space.floorArea
      exteriorWallAreaEW = 0 # exterior walls that only get view windows
      exteriorWallAreaNSView = 0 # exterior walls view only
      exteriorWallAreaNDaylight = 0 # exterior walls that receive daylighting
      exteriorWallAreaSDaylight = 0 # exterior walls that receive daylighting

      # flag for skylights
      addSkylights = false

      # first of two loops through space surfaces. This one is just to get floor and north or south exterior wall area.
      space.surfaces.each do |surface|
        # stop of not exterior wall
        next if surface.surfaceType != 'Wall'
        next if surface.outsideBoundaryCondition != 'Outdoors'

        # get the absoluteAzimuth for the surface so we can categorize it
        absoluteAzimuth = OpenStudio.convert(surface.azimuth, 'rad', 'deg').get + surface.space.get.directionofRelativeNorth + model.getBuilding.northAxis
        absoluteAzimuth -= 360.0 until absoluteAzimuth < 360.0

        # flag to see if surface not to ground
        surfaceToFloor = false
        surfaceToCeiling = false

        # check if surface goes to floor or ceiling (if false then don't add view windows)
        minSurfaceZValue = OsLib_Geometry.getSurfaceZValues([surface]).sort.first # this expects an array of surfaces
        if floorSurfacesZValueArray.include? minSurfaceZValue # not sure if will hit rounding issue
          surfaceToFloor = true
        end
        maxSurfaceZValue = OsLib_Geometry.getSurfaceZValues([surface]).sort.last # this expects an array of surfaces
        if ceilingSurfacesZValueArray.include? maxSurfaceZValue # not sure if will hit rounding issue
          surfaceToCeiling = true
        end

        # add to exterior wall counter if north or south
        if (northRangeEnd < absoluteAzimuth) && (absoluteAzimuth < southRangeStart) # East exterior walls
          if surfaceToFloor then exteriorWallAreaEW += surface.grossArea end
        elsif (southRangeStart <= absoluteAzimuth) && (absoluteAzimuth <= southRangeEnd) # South exterior walls
          if surfaceToFloor then exteriorWallAreaNSView += surface.grossArea end
          if surfaceToCeiling then exteriorWallAreaSDaylight += surface.grossArea end
        elsif (southRangeEnd < absoluteAzimuth) && (absoluteAzimuth < northRangeStart) # West exterior walls
          if surfaceToFloor then exteriorWallAreaEW += surface.grossArea end
        else # North exterior walls
          if surfaceToFloor then exteriorWallAreaNSView += surface.grossArea end
          if surfaceToCeiling then exteriorWallAreaNDaylight += surface.grossArea end
        end
      end

      # get ffr and dfr values from rules
      ffrNS = viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['fFR-NS']
      ffrEW = viewFenestrationRulesHash["#{climateZoneNumber} #{viewWindowFramingType}"]['fFR-EW']
      dfrNorth = (daylightFenestrationRulesHash["#{climateZoneNumber} NorthHigh"]['dFRmin'] * 0.5 + daylightFenestrationRulesHash["#{climateZoneNumber} NorthHigh"]['dFRmax'] * 0.5)
      dfrSouth = (daylightFenestrationRulesHash["#{climateZoneNumber} LightShelf"]['dFRmin'] * 0.5 + daylightFenestrationRulesHash["#{climateZoneNumber} LightShelf"]['dFRmax'] * 0.5)

      # add north and south dayilght areas together
      exteriorWallAreaNSDaylight = exteriorWallAreaNDaylight + exteriorWallAreaSDaylight

      # calculate target WWR rations needed to meet rules for FFR and DFR from rules
      exteriorWallAreaEW > 0.0 ? (viewWwrEW = floorArea * ffrNS / exteriorWallAreaEW) : (viewWwrEW = 0.0)
      exteriorWallAreaNSView > 0.0 ? (viewWwrNS = floorArea * ffrEW / exteriorWallAreaNSView) : (viewWwrNS = 0.0)
      exteriorWallAreaNSDaylight > 0.0 ? (daylightWwrN = floorArea * dfrNorth / exteriorWallAreaNSDaylight) : (daylightWwrN = 0.0)
      exteriorWallAreaNSDaylight > 0.0 ? (daylightWwrS = floorArea * dfrSouth / exteriorWallAreaNSDaylight) : (daylightWwrS = 0.0)

      if (exteriorWallAreaNSView == 0.0) && (exteriorWallAreaEW > 0.0) # only add east and west view windows when no south or north options exist
        if viewWwrEW > wwrCapValue
          viewWwrEW = wwrCapValue
          wwrCapFlag += 1
        end
      else
        viewWwrEW = 0.0
      end
      if viewWwrNS > wwrCapValue
        viewWwrNS = wwrCapValue
        wwrCapFlag += 1
      end
      if daylightWwrN > wwrCapValue
        daylightWwrN = wwrCapValue
        wwrCapFlag += 1
      end
      if daylightWwrS > wwrCapValue
        daylightWwrS = wwrCapValue
        wwrCapFlag += 1
      end

      # get standards space type
      if space.spaceType.empty? || space.spaceType.get.standardsSpaceType.empty?
        standardsSpaceType = nil
      else
        standardsSpaceType = space.spaceType.get.standardsSpaceType.get
      end

      # hash to hold daylight windows for use in placing sensor
      daylightNorthHash = {}
      daylightSouthHash = {}

      # second loop through surfaces to create fenestration
      space.surfaces.each do |surface|
        # only care about exterior surfaces
        next if surface.outsideBoundaryCondition != 'Outdoors'

        if surface.surfaceType == 'Wall'

          # flag to see if surface not to ground
          surfaceToFloor = false
          surfaceToCeiling = false

          # check if surface goes to floor or ceiling (if false then don't add view windows)
          minSurfaceZValue = OsLib_Geometry.getSurfaceZValues([surface]).sort.first # this expects an array of surfaces
          if floorSurfacesZValueArray.include? minSurfaceZValue # not sure if will hit rounding issue
            surfaceToFloor = true
          end
          maxSurfaceZValue = OsLib_Geometry.getSurfaceZValues([surface]).sort.last # this expects an array of surfaces
          if ceilingSurfacesZValueArray.include? maxSurfaceZValue # not sure if will hit rounding issue
            surfaceToCeiling = true
          end

          # don't add any windows if this surface doesn't touch floor or ceiling
          # next if surfaceToFloor == false and surfaceToCeiling == false

          # get the absoluteAzimuth for the surface so we can categorize it
          absoluteAzimuth = OpenStudio.convert(surface.azimuth, 'rad', 'deg').get + surface.space.get.directionofRelativeNorth + model.getBuilding.northAxis

          # flags to add view or daylight glazing. This is affected by the space type or the surface properties
          addViewGlazing = true
          addDaylightGlazing = true

          # geometry based tests
          if surfaceToFloor == false
            addViewGlazing = false
          end
          if surfaceToCeiling == false
            addDaylightGlazing = false
          end

          # space type tests
          if !daylightingCandidate.include? standardsSpaceType
            addDaylightGlazing = false
          end
          if !viewGlazingCandidate.include? standardsSpaceType
            addViewGlazing = false
          end

          # adjust method variables based on flags
          if addViewGlazing == false
            viewWwrEW_s = 0.0
            viewWwrNS_s = 0.0
          else
            viewWwrEW_s = viewWwrEW
            viewWwrNS_s = viewWwrNS
          end
          if addDaylightGlazing == false
            daylightWwrS_s = 0.0
            daylightWwrN_s = 0.0
          else
            daylightWwrS_s = daylightWwrS
            daylightWwrN_s = daylightWwrN
          end

          # see if surface has any subSurfaces. this is to eliminate warning on surface with door, as those have been split and a window isn't expected
          noDoorInSurface = true
          if !surface.subSurfaces.empty? then noDoorInSurface = false end

          # apply wwr based on surface orientation category and other inputs
          # applyViewAndDaylightingGlassRatios(viewGlassToWallRatio,daylightingGlassToWallRatio,desiredViewGlassSillHeight,desiredDaylightingGlassHeaderHeight,exteriorShadingProjectionFactor,interiorShelfProjectionFactor,viewGlassConstruction,daylightingGlassConstruction)
          if (northRangeEnd < absoluteAzimuth) && (absoluteAzimuth < southRangeStart) # East exterior walls
            vector = surface.applyViewAndDaylightingGlassRatios(viewWwrEW_s, 0.0, sill, header, 0.0, 0.0, viewConstructionEastWest.to_ConstructionBase, OpenStudio::Model::OptionalConstructionBase.new) # use OpenStudio::Model::OptionalConstructionBase.new  when you don't want to pass in a construction
            if !vector[0].nil?
              vector[0].setShadingControl(shadingControl)
            elsif (viewWwrEW_s > 0) && noDoorInSurface
              runner.registerWarning("The requested view window to wall ratio of #{OpenStudio.toNeatString(viewWwrEW_s, 2, true)} could not be set for #{surface.name}.")
            end
          elsif (southRangeStart <= absoluteAzimuth) && (absoluteAzimuth <= southRangeEnd) # South exterior walls
            vector = surface.applyViewAndDaylightingGlassRatios(viewWwrNS_s, daylightWwrS_s, sill, header, shadingProjectionFactor, lightShelfProjectionFactor, viewConstructionSouth.to_ConstructionBase, daylightConstructionSouth.to_ConstructionBase)
            if vector[0].nil? && noDoorInSurface && ((viewWwrNS_s > 0) || (daylightWwrS_s > 0))
              runner.registerWarning("The requested view and daylight window to wall ratio of #{OpenStudio.toNeatString(viewWwrNS_s, 2, true)} and #{OpenStudio.toNeatString(daylightWwrS_s, 2, true)} could not be set for #{surface.name}.")
            end
            vector.each do |subSurface|
              if subSurface.construction.get == viewConstructionSouth
                subSurface.shadingSurfaceGroups[0].shadingSurfaces[0].setConstruction(exteriorShadeConstruction) # setting shading surface construction
              elsif subSurface.construction.get == daylightConstructionSouth
                subSurface.daylightingDeviceShelf.get.insideShelf.get.setConstruction(lightShelfConstruction) # setting light shelf construction
                daylightSouthHash[vector.last] = vector.last.grossArea # push the daylight window to array for use later on
              end
            end
          elsif (southRangeEnd < absoluteAzimuth) && (absoluteAzimuth < northRangeStart) # West exterior walls
            vector = surface.applyViewAndDaylightingGlassRatios(viewWwrEW_s, 0.0, sill, header, 0.0, 0.0, viewConstructionEastWest.to_ConstructionBase, OpenStudio::Model::OptionalConstructionBase.new) # use OpenStudio::Model::OptionalConstructionBase.new  when you don't want to pass in a construction
            if !vector[0].nil?
              vector[0].setShadingControl(shadingControl)

            elsif (viewWwrEW_s > 0) && noDoorInSurface
              runner.registerWarning("The requested view window to wall ratio of #{OpenStudio.toNeatString(viewWwrEW_s, 2, true)} could not be set for #{surface.name}.")
            end
          else # North exterior walls
            vector = surface.applyViewAndDaylightingGlassRatios(viewWwrNS_s, daylightWwrN_s, sill, header, 0.0, 0.0, viewConstructionNorth.to_ConstructionBase, daylightConstructionNorth.to_ConstructionBase)
            if vector[0].nil? && noDoorInSurface && ((viewWwrNS_s > 0) || (daylightWwrS_s > 0))
              runner.registerWarning("The requested view and daylight window to wall ratio of #{OpenStudio.toNeatString(viewWwrNS_s, 2, true)} and #{OpenStudio.toNeatString(daylightWwrS_s, 2, true)} could not be set for #{surface.name}.")
            end
            vector.each do |subSurface|
              if subSurface.construction.get == viewConstructionNorth
              elsif subSurface.construction.get == daylightConstructionNorth
                daylightNorthHash[vector.last] = vector.last.grossArea # push the daylight window to array for use later on
              end
            end
          end

        elsif surface.surfaceType == 'RoofCeiling'

          # check for topLightingCandidate and topLightingIfNoSideLighting
          if topLightingCandidate.include? standardsSpaceType
            addSkylights = true
          end
          if topLightingIfNoSideLighting.include?(standardsSpaceType) && (exteriorWallAreaNSDaylight == 0)
            # (if this is uncommented it will add skylights to some other spaces if they don't have other daylighting windows)
            # addSkylights = true
          end

        end
      end

      # add skylights if required
      addSkylights = false # added this for Net Zero measure to avoid adding skylights
      if addSkylights

        # making vector to create pattern
        spaces = OpenStudio::Model::SpaceVector.new
        spaces << space

        # making pattern

        # TODO: - in the future only want pattern to cover section of space not included in side lighting daylit area

        ratio = daylightFenestrationRulesHash["#{climateZoneNumber} Skylight"]['dFRmin']
        pattern = OpenStudio::Model.generateSkylightPattern(spaces, spaces[0].directionofRelativeNorth, ratio, skylightSize, skylightSize) # ratio, x value, y value

        # applying skylight pattern
        skylights = OpenStudio::Model.applySkylightPattern(pattern, spaces, OpenStudio::Model::OptionalConstructionBase.new)
        runner.registerInfo("Adding #{skylights.size} skylights to #{space.name}")

        # create construction set for space if it doesn't exist, and add skylight construction.
        defaultSubSurfaceConstructions = OpenStudio::Model::DefaultSubSurfaceConstructions.new(model)
        defaultSubSurfaceConstructions.setSkylightConstruction(skylightConstruction)
        if space.defaultConstructionSet.empty?
          defaultConstructionSet = OpenStudio::Model::DefaultConstructionSet.new(model)
          defaultConstructionSet.setDefaultExteriorSubSurfaceConstructions(defaultSubSurfaceConstructions)
          space.setDefaultConstructionSet(defaultConstructionSet)
        else
          defaultConstructionSet = space.defaultConstructionSet.get
          defaultConstructionSet.setDefaultExteriorSubSurfaceConstructions(defaultSubSurfaceConstructions)
        end

      end

      # dont' add to hash if no daylighting in space
      next if (addSkylights == false) && (exteriorWallAreaNDaylight == 0) && (exteriorWallAreaSDaylight == 0)

      # go back and get north and south interior walls for spaces that also have exterior walls with daylight windows
      # this is specifically to address internal clerestory spaces like hallways
      space.surfaces.each do |surface|
        next if surface.surfaceType != 'Wall'
        next if surface.outsideBoundaryCondition == 'Outdoors' # these have already been counted

        # get the absoluteAzimuth for the surface so we can categorize it
        absoluteAzimuth = OpenStudio.convert(surface.azimuth, 'rad', 'deg').get + surface.space.get.directionofRelativeNorth + model.getBuilding.northAxis
        absoluteAzimuth -= 360.0 until absoluteAzimuth < 360.0

        # add to proper are if necessary
        if (northRangeEnd < absoluteAzimuth) && (absoluteAzimuth < southRangeStart) # East exterior walls
          # do nothing
        elsif (southRangeStart <= absoluteAzimuth) && (absoluteAzimuth <= southRangeEnd) # South exterior walls
          if exteriorWallAreaSDaylight > 0 # only add interior surfaces if the starting value is greater than 0
            exteriorWallAreaSDaylight += surface.grossArea
          end
        elsif (southRangeEnd < absoluteAzimuth) && (absoluteAzimuth < northRangeStart) # West exterior walls
          # do nothing
        else # North exterior walls
          if exteriorWallAreaNDaylight > 0 # only add interior surfaces if the starting value is greater than 0
            exteriorWallAreaNDaylight += surface.grossArea
          end
        end
      end

      # populate space hash, and then
      spaceHash = {}
      spaceHash['floorArea'] = floorArea
      spaceHash['exteriorWallAreaNDaylight'] = exteriorWallAreaNDaylight
      spaceHash['exteriorWallAreaSDaylight'] = exteriorWallAreaSDaylight
      spaceHash['skylight'] = addSkylights # bool for this space if skylights should be added. Is only true if right space and if there is exterior roof
      spaceHash['thermalZone'] = space.thermalZone.get # thermal zone not nil, because spaces are in a loop of thermal zones
      spaceHash['lightingPower'] = space.lightingPower # (W) not sure if it has luminaires, but I would expect it would
      spaceHash['daylightNorthHash'] = daylightNorthHash
      spaceHash['daylightSouthHash'] = daylightSouthHash
      spaceHash['spaceHeight'] = ceilingSurfacesZValueArray.max - floorSurfacesZValueArray.min

      # add spaceHash to zoneSpacesHash with space object as key
      zoneSpacesHash[space] = spaceHash
    end

    zoneFloorArea = 0
    zoneDaylightWallArea = 0
    zoneSpaceDaylightFractionHash = {}
    zoneSkylightHash = {}

    # loop through space hash
    zoneSpacesHash.each do |space, hash|
      # populate sensor method default hash
      defaults = {
        'name' => "#{space.name} sensor",
        'space' => space,
        'position' => nil,
        'phiRotationAroundZAxis' => nil,
        'illuminanceSetpoint' => targetFcGeneralInstruction,
        'lightingControlType' => '1', # 1 = Continuous
        'minInputPowerFractionContinuous' => nil,
        'minOutputPowerFractionContinuous' => nil
      }

      # calculate sensor position
      if hash['skylight']
        # find center of space and add sensor
        position = OsLib_Geometry.createPointAtCenterOfFloor(model, space, daylightSensorHeight)

        # customize default sensor values as needed
        options = defaults
        options['position'] = position

        # add sensor
        if !position.nil?
          pri_light_sensor = OsLib_LightingAndEquipment.addDaylightSensor(model, options)
        else
          runner.registerWarning("Couldn't find good Sensor Location for #{space.name}. Did not add daylight sensor.")
        end
      else
        # grab a floor surface to use in createPointInFromSubSurfaceAtSpecifiedHeight. (doesn't address sloped or stepped floor)
        referenceFloor = nil
        space.surfaces.each do |surface|
          if surface.surfaceType == 'Floor'
            referenceFloor = surface # just grabbing the first floor I find. Just want it to use as a plane.
          end
        end

        # add sensor for largest south window if it exists
        if !hash['daylightSouthHash'].empty?
          referenceWindow = hash['daylightSouthHash'].sort_by { |a| a[1] }.last

          # check for spaces taller than wide and adjust inputs as necessary
          estimatedRoomLength = hash['exteriorWallAreaSDaylight'] / hash['spaceHeight']
          estimatedRoomWidth = hash['floorArea'] / estimatedRoomLength
          if hash['spaceHeight'] > estimatedRoomWidth
            distanceFromWindow = estimatedRoomWidth - daylightMinOppositeWallClearance
          else
            if hash['spaceHeight'] < estimatedRoomWidth - daylightMinOppositeWallClearance
              distanceFromWindow = hash['spaceHeight']
            else
              distanceFromWindow = estimatedRoomWidth - daylightMinOppositeWallClearance
            end
          end

          position = OsLib_Geometry.createPointInFromSubSurfaceAtSpecifiedHeight(model, referenceWindow[0], referenceFloor, distanceFromWindow, daylightSensorHeight)

          # customize default sensor values as needed
          options = defaults
          options['position'] = position
          options['phiRotationAroundZAxis'] = OpenStudio.convert(referenceWindow[0].azimuth, 'rad', 'deg').get

          # add sensor
          if !position.nil?
            pri_light_sensor = OsLib_LightingAndEquipment.addDaylightSensor(model, options)
          else
            runner.registerWarning("Couldn't find good Sensor Location for #{space.name}. Did not add daylight sensor.")
          end

        end

        # add sensor for largest north window if it exists
        if !hash['daylightNorthHash'].empty?
          referenceWindow = hash['daylightNorthHash'].sort_by { |a| a[1] }.last

          # check for spaces taller than wide and adjust inputs as necessary
          estimatedRoomLength = hash['exteriorWallAreaNDaylight'] / hash['spaceHeight']
          estimatedRoomWidth = hash['floorArea'] / estimatedRoomLength
          if hash['spaceHeight'] > estimatedRoomWidth
            distanceFromWindow = estimatedRoomWidth - daylightMinOppositeWallClearance
          else
            if hash['spaceHeight'] < estimatedRoomWidth - daylightMinOppositeWallClearance
              distanceFromWindow = hash['spaceHeight']
            else
              distanceFromWindow = estimatedRoomWidth - daylightMinOppositeWallClearance
            end
          end

          position = OsLib_Geometry.createPointInFromSubSurfaceAtSpecifiedHeight(model, referenceWindow[0], referenceFloor, distanceFromWindow, daylightSensorHeight)

          # customize default sensor values as needed
          options = defaults
          options['position'] = position
          options['phiRotationAroundZAxis'] = OpenStudio.convert(referenceWindow[0].azimuth, 'rad', 'deg').get

          # add sensor
          if !position.nil?
            pri_light_sensor = OsLib_LightingAndEquipment.addDaylightSensor(model, options)
          else
            runner.registerWarning("Couldn't find good Sensor Location for #{space.name}. Did not add daylight sensor.")
          end

        end

      end

      # update floor area and wall area numbers
      zoneFloorArea += hash['floorArea']
      if hash['skylight']
        zoneDaylightWallArea_space = hash['floorArea'] # if the space has skylights then included the full floor area in daylit area
      else
        if hash['exteriorWallAreaNDaylight'] + hash['exteriorWallAreaSDaylight'] < hash['floorArea']
          zoneDaylightWallArea_space = hash['exteriorWallAreaNDaylight'] + hash['exteriorWallAreaSDaylight']
        else
          zoneDaylightWallArea_space = hash['floorArea'] # don't add more than floor area. This would occur on small room with tall wall, or with both north and south exposure
        end
      end

      # add space zone wall area to zone counter
      zoneDaylightWallArea += zoneDaylightWallArea_space

      # push each spaces fraction daylight to hash. This is to look for outliers. May also want to check for mixed side and top lighting
      zoneSpaceDaylightFractionHash[space] = zoneDaylightWallArea_space / hash['floorArea']
      zoneSkylightHash[space] = hash['skylight']
    end

    # identify which space to hook sensors to zone from
    maxLightingPower = 0
    spaceToHookToZone = nil
    zoneSpacesHash.each do |space, hash|
      if maxLightingPower < hash['lightingPower']
        maxLightingPower = hash['lightingPower']
        spaceToHookToZone = space
      end
    end

    if !spaceToHookToZone.nil?

      # get fractional value
      zoneDaylightFraction = zoneDaylightWallArea / zoneFloorArea

      # connect daylighting controls
      if spaceToHookToZone.daylightingControls.size > 1
        thermalZone.setPrimaryDaylightingControl(spaceToHookToZone.daylightingControls[0])
        thermalZone.setSecondaryDaylightingControl(spaceToHookToZone.daylightingControls[1])
        thermalZone.setFractionofZoneControlledbyPrimaryDaylightingControl(0.5 * zoneDaylightFraction)
        thermalZone.setFractionofZoneControlledbySecondaryDaylightingControl(0.5 * zoneDaylightFraction)
      elsif !spaceToHookToZone.daylightingControls.empty?
        thermalZone.setPrimaryDaylightingControl(spaceToHookToZone.daylightingControls[0])
        thermalZone.setFractionofZoneControlledbyPrimaryDaylightingControl(zoneDaylightFraction)
      end
    end
  end

  # issue a info if cap has to be set manually above
  if wwrCapFlag > 0
    runner.registerInfo("#{wwrCapFlag} surfaces had the window to wall ratio capped at #{wwrCapValue}. This may be due to a deep space or a space with limited exterior exposure.")
  end

  # warn user if any spaces were not in thermal zones. Those spaces are not looked at by this measure.
  orphanSpaces = false
  model.getSpaces.each do |space|
    if space.thermalZone.empty?
      runner.registerInfo('One or more spaces in the model are not associated with thermal zones. Existing translucent exterior fenestration was removed, but no new fenestration was added. Note that untill you add these spaces to thermal zones they will not be part of the simulation and may create boundary condition issues in adjacent spaces.')
      orphanSpaces == true
      break
    end
  end

  # get window to wall ratio for initial condition
  finalGrossWWR = OsLib_Geometry.getExteriorWindowToWallRatio(model.getSpaces)
  finalNetWWR = OsLib_Geometry.getExteriorWindowToWallRatio(spacesPartOfFloorArea)

  # store original cost of construction objects for use in final condition.
  finalEnvelopeCost = OsLib_Constructions.getTotalCostOfSelectedConstructions(model.getConstructions)

  # reporting final condition of model
  if spacesPartOfFloorArea.size < model.getSpaces.size
    runner.registerFinalCondition("The building has a final gross window to wall ratio of #{OpenStudio.toNeatString(finalGrossWWR, 2, true)} and a final net window to wall ratio of #{OpenStudio.toNeatString(finalNetWWR, 2, true)}. Cost increase due to this measure is $#{OpenStudio.toNeatString(finalEnvelopeCost - initialEnvelopeCost, 0, true)}.")
  else
    runner.registerFinalCondition("The building has a final window to wall ratio of #{OpenStudio.toNeatString(finalGrossWWR, 2, true)}. Cost increase due to this measure is $#{OpenStudio.toNeatString(finalEnvelopeCost - initialEnvelopeCost, 0, true)}.")
  end

  return true
end