Class: ZEDGK12RoofConstruction

Inherits:

OpenStudio::Measure::ModelMeasure

Object
OpenStudio::Measure::ModelMeasure
ZEDGK12RoofConstruction

show all

Includes:: OsLib_AedgMeasures, OsLib_Constructions

Defined in:: lib/measures/zedgk_12_roof_construction/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.

Methods included from OsLib_AedgMeasures

getClimateZoneNumber, getK12Tips, getLongHowToTips, getSmMdOffTips

Instance Method Details

#arguments(model) ⇒ `Object`

define the arguments that the user will input

# File 'lib/measures/zedgk_12_roof_construction/measure.rb', line 34

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

  # make an argument for material and installation cost
  material_cost_insulation_increase_ip = OpenStudio::Measure::OSArgument.makeDoubleArgument('material_cost_insulation_increase_ip', true)
  material_cost_insulation_increase_ip.setDisplayName('Increase Cost per Area of Construction Where Insulation was Improved ($/ft^2).')
  material_cost_insulation_increase_ip.setDefaultValue(0.0)
  args << material_cost_insulation_increase_ip

  # make an argument for material and installation cost
  material_cost_sri_increase_ip = OpenStudio::Measure::OSArgument.makeDoubleArgument('material_cost_sri_increase_ip', true)
  material_cost_sri_increase_ip.setDisplayName('Increase Cost per Area of Construction Where Solar Reflectance Index (SRI) was Improved. ($/ft^2).')
  material_cost_sri_increase_ip.setDefaultValue(0.0)
  args << material_cost_sri_increase_ip

  # make an argument to alter_sri
  alter_sri = OpenStudio::Measure::OSArgument.makeBoolArgument('alter_sri', true)
  alter_sri.setDisplayName('Alter SRI?')
  alter_sri.setDefaultValue(true)
  args << alter_sri

  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



29
30
31

# File 'lib/measures/zedgk_12_roof_construction/measure.rb', line 29

def name
  return 'ZEDG K12 RoofConstruction'
end

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

define what happens when the measure is run

# File 'lib/measures/zedgk_12_roof_construction/measure.rb', line 59

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
  material_cost_insulation_increase_ip = runner.getDoubleArgumentValue('material_cost_insulation_increase_ip', user_arguments)
  material_cost_sri_increase_ip = runner.getDoubleArgumentValue('material_cost_sri_increase_ip', user_arguments)
  alter_sri = runner.getBoolArgumentValue('alter_sri', user_arguments)

  # no validation needed for cost inputs, negative values are fine, however negative would be odd choice since this measure only improves vs. decreases insulation and SRI performance

  # global variables for costs
  expected_life = 25
  years_until_costs_start = 0
  material_cost_insulation_increase_si = OpenStudio.convert(material_cost_insulation_increase_ip, '1/ft^2', '1/m^2').get
  material_cost_sri_increase_si = OpenStudio.convert(material_cost_sri_increase_ip, '1/ft^2', '1/m^2').get
  running_cost_insulation = 0
  running_cost_sri = 0

  # prepare rule hash
  rules = [] # climate zone, roof type, thermal transmittance (Btu/h·ft2·°F), SRI

  # zedg doesn't have wall type lookup like aedg, altert user of this
  runner.registerInfo('Roof insulation values based on IEAD roof.')

  rules << ['0', 'IEAD', 0.039, 78.0] # measure setup to use only for this target and roof type
  rules << ['1', 'IEAD', 0.048, 78.0]
  rules << ['2', 'IEAD', 0.039, 78.0]
  rules << ['3', 'IEAD', 0.039, 78.0]
  rules << ['4', 'IEAD', 0.030, 0]
  rules << ['5', 'IEAD', 0.030, 0]
  rules << ['6', 'IEAD', 0.030, 0]
  rules << ['7', 'IEAD', 0.027, 0]
  rules << ['8', 'IEAD', 0.027, 0]

  # make rule hash for cleaner code
  rulesHash = {}
  rules.each do |rule|
    rulesHash["#{rule[0]} #{rule[1]}"] = { 'conductivity_ip' => rule[2], 'sri' => rule[3] }
  end

  # get climate zone
  climateZoneNumber = OsLib_AedgMeasures.getClimateZoneNumber(model, runner)
  # climateZoneNumber = "4" # this is just in for quick testing of different climate zones

  # add message for climate zones 4-8 about SRI
  if climateZoneNumber == false
    return false
  elsif climateZoneNumber.to_f > 3
    runner.registerInfo("For Climate Zone #{climateZoneNumber} Solar Reflectance Index (SRI) should comply with Standard 90.1.")
  end

  # get starting r-value and SRI ranges
  startingRvaluesExtRoof = []
  startingRvaluesAtticInterior = []
  startingSriExtRoof = []

  # flag for roof surface type for tips
  ieadFlag = false
  metalFlag = false
  atticFlag = false

  # affected area counter
  insulation_affected_area = 0
  sri_affected_area = 0

  # construction hashes  (construction is key, value is array [thermal transmittance (Btu/h·ft2·°F), SRI,rule thermal transmittance (Btu/h·ft2·°F), rule SRI,classification string)
  ieadConstructions = {}
  metalConstructions = {}
  atticConstructions = {} # will initially load all constructions used in model, and will delete later if passes test

  # this contains constructions that should not have exterior roofs assigned
  otherConstructions = []

  # make array for spaces that have a surface with at least one exterior attic surface
  atticSpaces = []

  # loop through constructions
  constructions = model.getConstructions
  constructions.each do |construction|
    # skip if not used
    next if construction.getNetArea <= 0

    # skip if not opaque
    next if !construction.isOpaque

    # get construction and standard
    constructionStandard = construction.standardsInformation

    # get roof type
    intendedSurfaceType = constructionStandard.intendedSurfaceType

    # because it is assumed to be IEAD, hard code vs. inspecting construction
    # constructionType = constructionStandard.standardsConstructionType
    constructionType = 'IEAD'

    # get conductivity
    conductivity_si = construction.thermalConductance.get
    r_value_ip = OpenStudio.convert(1 / conductivity_si, 'm^2*K/W', 'ft^2*h*R/Btu').get

    # get SRI (only need of climate zones 1-3)
    sri = OsLib_Constructions.getConstructionSRI(construction)

    # flags for construction loop
    ruleRvalueFlag = true
    ruleSriFlag = true

    # IEAD and Metal roofs should have intendedSurfaceType of ExteriorRoof
    if intendedSurfaceType.to_s == 'ExteriorRoof'

      if constructionType.to_s == 'IEAD'

        # store starting values
        startingRvaluesExtRoof << r_value_ip
        startingSriExtRoof << sri
        ieadFlag = true

        # test construction against rules
        ruleSet = rulesHash["#{climateZoneNumber} IEAD"]
        if 1 / r_value_ip > ruleSet['conductivity_ip']
          ruleRvalueFlag = false
        end
        if sri < ruleSet['sri']
          ruleSriFlag = false
        end
        if !ruleRvalueFlag || !ruleSriFlag
          ieadConstructions[construction] = { 'conductivity_ip' => 1 / r_value_ip, 'sri' => sri, 'transmittance_ip_rule' => ruleSet['conductivity_ip'], 'sri_rule' => ruleSet['sri'], 'classification' => 'ieadConstructions' }
        end

      elsif constructionType.to_s == 'Metal'

        # store starting values
        startingRvaluesExtRoof << r_value_ip
        startingSriExtRoof << sri
        metalFlag = true

        # test construction against rules
        ruleSet = rulesHash["#{climateZoneNumber} Metal"]
        if 1 / r_value_ip > ruleSet['conductivity_ip']
          ruleRvalueFlag = false
        end
        if sri < ruleSet['sri']
          ruleSriFlag = false
        end
        if !ruleRvalueFlag || !ruleSriFlag
          metalConstructions[construction] = { 'conductivity_ip' => 1 / r_value_ip, 'sri' => sri, 'transmittance_ip_rule' => ruleSet['conductivity_ip'], 'sri_rule' => ruleSet['sri'], 'classification' => 'metalConstructions' }
        end

      else
        # create warning if a construction passing through here is used on a roofCeiling surface with a boundary condition of "Outdoors"
        otherConstructions << construction
      end

    elsif (intendedSurfaceType.to_s == 'AtticRoof') || (intendedSurfaceType.to_s == 'AtticWall') || (intendedSurfaceType.to_s == 'AtticFloor')

      # store starting values
      atticFlag = true

      atticConstructions[construction] = { 'conductivity_ip' => 1 / r_value_ip, 'sri' => sri } # will extend this hash later

    else
      # create warning if a construction passing through here is used on a roofCeiling surface with a boundary condition of "Outdoors"
      otherConstructions << construction

    end
  end

  # create warning if construction used on exterior roof doesn't have a surface type of "ExteriorRoof", or if constructions tagged to be used as roof, are used on other surface types
  otherConstructionsWarned = []
  atticSurfaces = [] # to test against attic spaces later on
  surfaces = model.getSurfaces
  surfaces.each do |surface|
    if !surface.construction.empty?
      construction = surface.construction.get

      # populate attic spaces
      if (surface.outsideBoundaryCondition == 'Outdoors') && atticConstructions.include?(construction)
        if !surface.space.empty?
          if !atticSpaces.include? surface.space.get
            atticSpaces << surface.space.get
          end
        end
      elsif atticConstructions.include? construction
        atticSurfaces << surface
      end

      if (surface.outsideBoundaryCondition == 'Outdoors') && (surface.surfaceType == 'RoofCeiling')

        if otherConstructions.include?(construction) && (!otherConstructionsWarned.include? construction)
          runner.registerWarning("#{construction.name} is used on one or more exterior roof surfaces but has an intended surface type or construction type not recognized by this measure. As we can not infer the proper performance target, this construction will not be altered.")
          otherConstructionsWarned << construction
        end

      else

        if ieadConstructions.include?(construction) || metalConstructions.include?(construction)
          runner.registerWarning("#{surface.name} uses #{construction.name} as a construction that this measure expects to be used for exterior roofs. This surface has a type of #{surface.surfaceType} and a a boundary condition of #{surface.outsideBoundaryCondition}. This may result in unexpected changes to your model.")
        end

      end

    end
  end

  # hashes to hold classification of attic surfaces
  atticSurfacesInterior = {} # this will include paris of matched surfaces
  atticSurfacesExteriorExposed = {}
  atticSurfacesExteriorExposedNonRoof = {}
  atticSurfacesOtherAtticDemising = {}

  # look for attic surfaces that are not in attic space or matched to them.
  atticSpaceWarning = false
  atticSurfaces.each do |surface|
    if !surface.space.empty?
      space = surface.space.get
      if !atticSpaces.include? space
        if surface.outsideBoundaryCondition == 'Surface'
          # get space of matched surface and see if it is also an attic
          next if surface.adjacentSurface.empty?
          adjacentSurface = surface.adjacentSurface.get
          next if adjacentSurface.space.empty?
          adjacentSurfaceSpace = adjacentSurface.space.get
          if !atticSpaces.include? adjacentSurfaceSpace
            atticSpaceWarning = true
          end
        else
          atticSpaceWarning = true
        end
      end
    end
  end
  if atticSpaceWarning
    runner.registerWarning("#{surface.name} uses #{construction.name} as a construction that this measure expects to be used for attics. This surface has a type of #{surface.surfaceType} and a a boundary condition of #{surface.outsideBoundaryCondition}. This may result in unexpected changes to your model.")
  end

  # flag for testing
  interiorAtticSurfaceInSpace = false

  # loop through attic spaces to classify surfaces with attic intended surface type
  atticSpaces.each do |atticSpace|
    atticSurfaces = atticSpace.surfaces

    # array for surfaces that don't use an attic construction
    surfacesWithNonAtticConstructions = []

    # loop through attic surfaces
    atticSurfaces.each do |atticSurface|
      next if atticSurface.construction.empty?
      construction = atticSurface.construction.get
      if atticConstructions.include? construction
        conductivity_ip = atticConstructions[construction]['conductivity_ip']
        r_value_ip = 1 / conductivity_ip
        sri = atticConstructions[construction]['sri']
      else
        surfacesWithNonAtticConstructions << atticSurface.name
        next
      end

      # warn if any exterior exposed roof surfaces are not attic.
      if atticSurface.outsideBoundaryCondition == 'Outdoors'

        # only want to change SRI if it is a roof
        if atticSurface.surfaceType == 'RoofCeiling'

          # store starting value for SRI
          startingSriExtRoof << sri
          atticSurfacesExteriorExposed[atticSurface] = construction
        else
          atticSurfacesExteriorExposedNonRoof[atticSurface] = construction
        end

      elsif atticSurface.outsideBoundaryCondition == 'Surface'

        # get space of matched surface and see if it is also an attic
        next if atticSurface.adjacentSurface.empty?
        adjacentSurface = atticSurface.adjacentSurface.get
        next if adjacentSurface.space.empty?
        adjacentSurfaceSpace =  adjacentSurface.space.get

        if atticSpaces.include?(adjacentSurfaceSpace) && atticSpaces.include?(atticSpace)
          atticSurfacesOtherAtticDemising[atticSurface] = construction
        else
          # store starting values
          startingRvaluesAtticInterior << r_value_ip
          atticSurfacesInterior[atticSurface] = construction
          interiorAtticSurfaceInSpace = true # this is to confirm that space has at least one interior surface flagged as an attic
        end

      else
        runner.registerWarning("Can't infer use case for attic surface with an outside boundary condition of #{atticSurface.outsideBoundaryCondition}.")
      end
    end

    # warning message for each space that has mix of attic and non attic constructions
    runner.registerWarning("#{atticSpace.name} has surfaces with a mix of attic and non attic constructions which may produce unexpected results. The following surfaces use constructions not tagged as attic and will not be altered: #{surfacesWithNonAtticConstructions.sort.join(',')}.")

    # confirm that all spaces have at least one or more surface of both exterior attic and interior attic
    if !interiorAtticSurfaceInSpace
      runner.registerWarning("#{atticSpace.name} has at least one exterior attic surface but does not have an interior attic surface. Please confirm that this space is intended to be an attic and update the constructions used.")
    end

    # see if attic is part of floor area and/or if it has people in it
    if atticSpace.partofTotalFloorArea
      runner.registerWarning("#{atticSpace.name} is part of the floor area. That is not typical for an attic.")
    end
    if !atticSpace.people.empty?
      runner.registerWarning("#{atticSpace.name} has people. That is not typical for an attic.")
    end
  end

  # removed aedg code that looks for classification conflicts in attic constructions

  # alter constructions and add lcc
  constructionsToChange = ieadConstructions.sort + metalConstructions.sort + atticConstructions.sort
  constructionsToChange.each do |construction, hash|
    # gather insulation inputs
    if hash['transmittance_ip_rule'] != 'NA'

      # gather target decrease in conductivity
      conductivity_ip_starting = hash['conductivity_ip']
      conductivity_si_starting = OpenStudio.convert(conductivity_ip_starting, 'Btu/ft^2*h*R', 'W/m^2*K').get
      r_value_ip_starting = 1 / conductivity_ip_starting # ft^2*h*R/Btu
      r_value_si_starting = 1 / conductivity_si_starting # m^2*K/W
      conductivity_ip_target = hash['transmittance_ip_rule'].to_f
      conductivity_si_target = OpenStudio.convert(conductivity_ip_target, 'Btu/ft^2*h*R', 'W/m^2*K').get
      r_value_ip_target = 1 / conductivity_ip_target # ft^2*h*R/Btu
      r_value_si_target = 1 / conductivity_si_target # m^2*K/W

      # infer insulation material to get input for target thickness
      minThermalResistance = OpenStudio.convert(1, 'ft^2*h*R/Btu', 'm^2*K/W').get
      inferredInsulationLayer = OsLib_Constructions.inferInsulationLayer(construction, minThermalResistance)
      rvalue_si_deficiency = r_value_si_target - r_value_si_starting

      # add lcc for insulation
      lcc_mat_insulation = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat_Insulation - #{construction.name}", construction, material_cost_insulation_increase_si, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
      lcc_mat_insulation_value = lcc_mat_insulation.get.totalCost
      running_cost_insulation += lcc_mat_insulation_value

      # adjust existing material or add new one
      if inferredInsulationLayer['insulationFound'] # if insulation layer was found

        # gather inputs for method
        target_material_rvalue_si = inferredInsulationLayer['construction_thermal_resistance'] + rvalue_si_deficiency

        # run method to change insulation layer thickness in cloned material (material,starting_r_value_si,target_r_value_si, model)
        new_material = OsLib_Constructions.setMaterialThermalResistance(inferredInsulationLayer['construction_layer'], target_material_rvalue_si)

        # connect new material to original construction
        construction.eraseLayer(inferredInsulationLayer['layer_index'])
        construction.insertLayer(inferredInsulationLayer['layer_index'], new_material)

        # get conductivity
        final_conductivity_si = construction.thermalConductance.get
        final_r_value_ip = OpenStudio.convert(1 / final_conductivity_si, 'm^2*K/W', 'ft^2*h*R/Btu').get

        # report on edited material
        runner.registerInfo("The R-value of #{construction.name} has been increased from #{OpenStudio.toNeatString(r_value_ip_starting, 2, true)} to #{OpenStudio.toNeatString(final_r_value_ip, 2, true)}(ft^2*h*R/Btu) at a cost of $#{OpenStudio.toNeatString(lcc_mat_insulation_value, 2, true)}. Increased performance was accomplished by adjusting thermal resistance of #{new_material.name}.")

      else

        # inputs to pass to method
        conductivity = 0.045 # W/m*K
        thickness = rvalue_si_deficiency * conductivity # meters

        addNewLayerToConstruction_Inputs = {
          'roughness' => 'MediumRough',
          'thickness' => thickness, # meters,
          'conductivity' => conductivity, # W/m*K
          'density' => 265.0,
          'specificHeat' => 836.8,
          'thermalAbsorptance' => 0.9,
          'solarAbsorptance' => 0.7,
          'visibleAbsorptance' => 0.7
        }

        # create new material if can't infer insulation material (construction,thickness, conductivity, density, specificHeat, roughness,thermalAbsorptance, solarAbsorptance,visibleAbsorptance,model)
        newMaterialLayer = OsLib_Constructions.addNewLayerToConstruction(construction, addNewLayerToConstruction_Inputs)

        # get conductivity
        final_conductivity_si = construction.thermalConductance.get
        final_r_value_ip = OpenStudio.convert(1 / final_conductivity_si, 'm^2*K/W', 'ft^2*h*R/Btu').get

        # report on edited material
        runner.registerInfo("The R-value of #{construction.name} has been increased from #{OpenStudio.toNeatString(r_value_ip_starting, 2, true)} to #{OpenStudio.toNeatString(final_r_value_ip, 2, true)}(ft^2*h*R/Btu) at a cost of $#{OpenStudio.toNeatString(lcc_mat_insulation_value, 2, true)}. Increased performance was accomplished by adding a new material layer to the outside of #{construction.name}.")

      end

      # add to area counter
      insulation_affected_area += construction.getNetArea # OpenStudio handles matched surfaces so they are not counted twice.

    end

    # gather sri inputs
    if (hash['sri_rule'] == 78.0) && (hash['sri_rule'] > hash['sri']) && alter_sri

      # hard assign material properies that will result in an SRI of 78
      setConstructionSurfaceProperties_Inputs = {
        'thermalAbsorptance' => 0.86,
        'solarAbsorptance' => 1 - 0.65
      }

      # alter surface properties (construction,roughness,thermalAbsorptance, solarAbsorptance,visibleAbsorptance)
      surfaceProperties = OsLib_Constructions.setConstructionSurfaceProperties(construction, setConstructionSurfaceProperties_Inputs)
      sri = OsLib_Constructions.getConstructionSRI(construction)

      # add lcc for SRI
      lcc_mat_sri = OpenStudio::Model::LifeCycleCost.createLifeCycleCost("LCC_Mat_SRI - #{construction.name}", construction, material_cost_sri_increase_si, 'CostPerArea', 'Construction', expected_life, years_until_costs_start)
      lcc_mat_sri_value = lcc_mat_sri.get.totalCost
      running_cost_sri += lcc_mat_sri_value

      # add to area counter
      sri_affected_area += construction.getNetArea

      # report performance and cost change for material, or area
      runner.registerInfo("The Solar Reflectance Index (SRI) of #{construction.name} has been increased from #{OpenStudio.toNeatString(hash['sri'], 0, true)} to #{OpenStudio.toNeatString(sri, 0, true)} for a cost of $#{OpenStudio.toNeatString(lcc_mat_sri_value, 0, true)}. Affected area is #{OpenStudio.toNeatString(OpenStudio.convert(construction.getNetArea, 'm^2', 'ft^2').get, 0, true)} (ft^2)")

    end
  end

  # reporting initial condition of model
  startingRvalue = startingRvaluesExtRoof + startingRvaluesAtticInterior # adding non attic and attic values together

  runner.registerInitialCondition("Starting R-values for constructions intended for insulated roof surfaces range from #{OpenStudio.toNeatString(startingRvalue.min, 2, true)} to #{OpenStudio.toNeatString(startingRvalue.max, 2, true)}(ft^2*h*R/Btu). Starting Solar Reflectance Index (SRI) for constructions intended for exterior roof surfaces range from #{OpenStudio.toNeatString(startingSriExtRoof.min, 0, true)} to #{OpenStudio.toNeatString(startingSriExtRoof.max, 0, true)}.")

  # reporting final condition of model
  insulation_affected_area_ip = OpenStudio.convert(insulation_affected_area, 'm^2', 'ft^2').get
  sri_affected_area_ip = OpenStudio.convert(sri_affected_area, 'm^2', 'ft^2').get
  runner.registerFinalCondition("#{OpenStudio.toNeatString(insulation_affected_area_ip, 0, true)}(ft^2) of constructions intended for roof surfaces had insulation enhanced at a cost of $#{OpenStudio.toNeatString(running_cost_insulation, 0, true)}. #{OpenStudio.toNeatString(sri_affected_area_ip, 0, true)}(ft^2) of constructions intended for roof surfaces had the Solar Reflectance Index (SRI) enhanced at a cost of $#{OpenStudio.toNeatString(running_cost_sri, 0, true)}.")

  return true
end