# # *********************************************************************
# # * Copyright (c) 2008-2015, Natural Resources Canada
# # * All rights reserved.
# # *
# # * This library is free software; you can redistribute it and/or
# # * modify it under the terms of the GNU Lesser General Public
# # * License as published by the Free Software Foundation; either
# # * version 2.1 of the License, or (at your option) any later version.
# # *
# # * This library is distributed in the hope that it will be useful,
# # * but WITHOUT ANY WARRANTY; without even the implied warranty of
# # * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# # * Lesser General Public License for more details.
# # *
# # * You should have received a copy of the GNU Lesser General Public
# # * License along with this library; if not, write to the Free Software
# # * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
# # **********************************************************************/
#
#
#
# require "singleton"
#
#
# module BTAP
# module EQuest
# # Author:: Phylroy Lopez (mailto:plopez@nrcan.gc.ca)
# # Copyright:: Copyright (c) NRCan
# # License:: GNU Public Licence
# #This class contains encapsulates the generic interface for the DOE2.x command
# #set. It stores the u type, commands, and keyword pairs for each command. It also
# #stores the parent and child command relationships w.r.t. the building envelope
# #and the hvac systems. I have attempted to make the underlying storage of data
# #private so, if required, we could move to a database solution in the future
# #if required for web development..
#
# class DOECommand
#
# # Contains the user specified name
# attr_accessor :utype
# #Contains the u-value
# attr_accessor :uvalue
# # Contains the DOE-2 command name.
# attr_accessor :commandName
# # Contains the Keyword Pairs.
# attr_accessor :keywordPairs
# # Lists all ancestors in increasing order.
# attr_accessor :parents
# # An Array of all the children of this command.
# attr_accessor :children
# # The command type.
# attr_accessor :commandType
# # Flag to see if this component is exempt.
# attr_accessor :exempt
# # Comments. To be added to the command.
# attr_accessor :comments
# # A list of all the non_utype_commands.
# attr_accessor :non_utype_commands
# # A list of all the one line commands (no keyword pairs)
# attr_accessor :one_line_commands
# # Pointer to the building obj.
# attr_accessor :building
#
#
#
#
# def remove()
# #unlink children
# self.children.each {|item| item.remove}
# #unlink from parent.
# self.get_parents[0].children.delete(self)
# #remove from command array.
# @building.commands.delete(self)
# return self
# end
#
# def set_parent(parent)
# @parents.clear
# parent.get_parents().each {|parent| @parents << parent}
# @parents << parent
# end
#
# #This method will return the value of the keyword pair if available.
# #Example:
# #If you object has this data in it...
# #
# #"EL1 West Perim Spc (G.W4)" = SPACE
# #SHAPE = POLYGON
# #ZONE-TYPE = CONDITIONED
# #PEOPLE-SCHEDULE = "EL1 Bldg Occup Sch"
# #LIGHTING-SCHEDUL = ( "EL1 Bldg InsLt Sch" )
# #EQUIP-SCHEDULE = ( "EL1 Bldg Misc Sch" )
# #
# #
# #then calling
# #
# #get_keyword_value("ZONE-TYPE")
# #
# #will return the string
# #
# #"CONDITIONED".
# #
# #if the keyword does not exist, it will return a nil object.
# # Returns the value associated with the keyword.
# def get_keyword_value(string)
# return_string = String.new()
# found = false
# @keywordPairs.each do |pair|
# if pair[0] == string
# found = true
# return_string = pair[1]
# end
# end
# if found == false
# raise "Error: In the command #{@utype}:#{@command_name} Attempted to get a Keyword pair #{string} present in the command\n Is this keyword missing? \n#{output}"
# end
# return return_string
# end
#
# # Sets the keyword value.
# def set_keyword_value(keyword, value)
# found = false
# unless @keywordPairs.empty?
# @keywordPairs.each do |pair|
# if pair[0] == keyword
# pair[1] = value
# found = true
# end
# end
# if (found == false)
# @keywordPairs.push([keyword,value])
# end
# else
# #First in the array...
# add_keyword_pair(keyword,value)
# end
# end
#
# # Removes the keyword pair.
# def remove_keyword_pair(string)
# return_string = String.new()
# @keywordPairs.each do |pair|
# if pair[0] == string
# @keywordPairs.delete(pair)
# end
# end
# return return_string
# end
#
# def initialize()
# @utype = String.new()
# @commandName= String.new()
# @keywordPairs=Array.new()
# @parents = Array.new()
# @children = Array.new()
# @commandType = String.new()
# @exempt = false
# #HVAC Hierarchry
# @comments =Array.new()
# @hvacLevel = Array.new()
# @hvacLevel[0] =["SYSTEM"]
# @hvacLevel[1] =["ZONE"]
# #Envelope Hierachy
# @envelopeLevel = Array.new()
# @envelopeLevel[0] = ["FLOOR"]
# @envelopeLevel[1] = ["SPACE"]
#
# @envelopeLevel[2] = [
# "EXTERIOR-WALL",
# "INTERIOR-WALL",
# "UNDERGROUND-WALL",
# "ROOF"
# ]
#
# @envelopeLevel[3] = [
# "WINDOW",
# "DOOR"]
#
# @non_utype_commands = Array.new()
# @non_utype_commands = [
# "TITLE",
# "SITE-PARAMETERS",
# "BUILD-PARAMETER",
# "LOADS_REPORT",
# "SYSTEMS-REPORT",
# "MASTERS-METERS",
# "ECONOMICS-REPORT",
# "PLANT-REPORT",
# "LOADS-REPORT",
# "COMPLIANCE"
# ]
# @one_line_commands = Array.new()
# @one_line_commands = ["INPUT","RUN-PERIOD","DIAGNOSTIC","ABORT", "END", "COMPUTE", "STOP", "PROJECT-DATA"]
# end
#
# # Determines the DOE scope, either envelope or hvac (Window, Wall, Space Floor) or (System->Plant)
# # Hierarchy) this is required to determine parent/child relationships in the building.
# def doe_scope
# scope = "none"
# @envelopeLevel.each_index do |index|
# @envelopeLevel[index].each do |name|
# if (@commandName == name )
# scope = "envelope"
# end
# end
# end
#
# @hvacLevel.each_index do |index|
# @hvacLevel[index].each do |name|
# if (@commandName == name )
# scope = "hvac"
# end
# end
# end
# return scope
# end
# # Determines the DOE scope depth (Window, Wall, Space Floor) or (System->Plant) Hierarchy)
# def depth
# level = 0
# scopelist=[]
# if (doe_scope == "hvac")
# scopelist = @hvacLevel
# else
# scopelist = @envelopeLevel
# end
# scopelist.each_index do |index|
# scopelist[index].each do |name|
# if (@commandName == name )
# level = index
# end
# end
# end
# return level
# end
#
# #Outputs the command in DOE 2.2 format.
# def output
# return basic_output()
# end
#
# #Outputs the command in DOE 2.2 format.
# def basic_output()
# temp_string = String.new()
#
# if (@utype != "")
# temp_string = temp_string + "#{@utype} = "
# end
# temp_string = temp_string + @commandName
# temp_string = temp_string + "\n"
# @keywordPairs.each {|array| temp_string = temp_string + "\t#{array[0]} = #{array[1]}\n" }
# temp_string = temp_string + "..\n"
#
# temp_string = temp_string + "$Parents\n"
# @parents.each do |array|
# temp_string = temp_string + "$\t#{array.utype} = #{array.commandName}\n"
# end
# temp_string = temp_string + "..\n"
#
# temp_string = temp_string + "$Children\n"
# @children.each {|array| temp_string = temp_string + "$\t#{array.utype} = #{array.commandName}\n" }
# temp_string = temp_string + "..\n"
#
# end
#
# # Creates the command informantion based on DOE 2.2 syntax.
# def get_command_from_string(command_string)
# #Split the command based on the equal '=' sign.
# remove = ""
# keyword=""
# value=""
#
# if (command_string != "")
# #Get command and u-value
# if ( command_string.match(/(^\s*(\".*?\")\s*\=\s*(\S+)\s*)/) )
# @commandName=$3.strip
# @utype = $2.strip
# remove = Regexp.escape($1)
#
# else
# # if no u-value, get just the command.
# command_string.match(/(^\s*(\S*)\s)/ )
# remove = Regexp.escape($1)
# @commandName=$2.strip
# end
# #Remove command from string.
#
# command_string.sub!(/#{remove}/,"")
# command_string.strip!
#
#
# #Loop throught the keyword values.
# while ( command_string.length > 0 )
# #DOEMaterial, or SCHEDULES
# if ( command_string.match(/(^\s*(MATERIAL|DAY-SCHEDULES|WEEK-SCHEDULES)\s*(\=?)\s*(.*)\s*)/))
# #puts "Bracket"
# keyword = $2.strip
# value = $4.strip
# remove = Regexp.escape($1)
# #Stars
# elsif ( command_string.match(/(^\s*(\S*)\s*(\=?)\s*(\*.*?\*)\s*)/))
# #puts "Bracket"
# keyword = $2.strip
# value = $4.strip
# remove = Regexp.escape($1)
#
# #Brackets
# elsif ( command_string.match(/(^\s*(\S*)\s*(\=?)\s*(\(.*?\))\s*)/))
# #puts "Bracket"
# keyword = $2.strip
# value = $4.strip
# remove = Regexp.escape($1)
# #Quotes
# elsif ( command_string.match(/(^\s*(\S*)\s*(\=?)\s*(".*?")\s*)/) )
# #puts "Quotes"
# keyword = $2
# value = $4.strip
# remove = Regexp.escape($1)
# #single command
# elsif command_string.match(/(^\s*(\S*)\s*(\=?)\s*(\S+)\s*)/)
# #puts "Other"
# keyword = $2
# value = $4.strip
# remove = Regexp.escape($1)
# end
# #puts "DOE22::DOECommand: #{command_string}"
# #puts "K = #{keyword} V = #{value}\n"
# if (keyword != "")
# set_keyword_value(keyword,value)
# end
# command_string.sub!(/#{remove}/,"")
# end
# #puts "Keyword"
# #puts keywordPairs
# end
# end
#
# #Returns an array of the commands parents.
# def get_parents
# return @parents
# end
#
# #Returns an array of the commands children.
# def get_children
# return children
# end
#
# # Gets name.
# def get_name()
# return @utype
# end
#
# # Check if keyword exists.
# def check_keyword?(keyword)
# @keywordPairs.each do |pair|
# if pair[0] == keyword
# return true
# end
# end
# return false
# end
#
# # Gets the parent of command...if any.
# def get_parent(keyword)
#
# get_parents().each do |findcommand|
#
# if ( findcommand.commandName == keyword)
# return findcommand
# end
# end
# return nil
#
# end
#
# #Gets children of command, if any.
# def get_children_of_command(keyword)
# array = Array.new()
# children.each do |findcommand|
# if ( findcommand.commandName == keyword)
# array.push(findcommand)
# end
# end
# return array
# end
#
# def name()
# return utype
# end
#
# private
# def add_keyword_pair(keyword,pair)
# array = [keyword,pair]
# keywordPairs.push(array)
# end
# end
# class DOEZone < BTAP::EQuest::DOECommand
# attr_accessor :space
# # a vector of spaces used when the declaration of space is "combined"
# attr_accessor :space_uses
# # a lighting object which stores the lighting characteristics of each zone
# attr_accessor :lighting
# #defines the thermal mass characteristics of the zone.
# #could be a string object or a user defined object
# attr_accessor :thermal_mass
# # stores a constant floating value of the amount of air leakage,
# #accoriding to rule #4.3.5.9.
# attr_accessor :air_leakage
# # this will be a vector consisting of heat transfer objects,
# # which contains a pointer to the adjacent thermal block and a pointer
# # to the wall in between them
# attr_accessor :heat_transfers
# def initialize
# super()
# end
#
# def output
#
# temp_string = basic_output()
# if (@space == nil)
# temp_string = temp_string + "$ No space found to match zone!\n"
# else
# temp_string = temp_string + "$Space\n"
# temp_string = temp_string + "$\t#{@space.utype} = #{@space.commandName}\n"
# end
# return temp_string
# end
#
# # This method finds all the exterior surfaces, ie. Exterior Wall and Roof
# # Output => surfaces as an Array of commands
# def get_exterior_surfaces()
# surfaces = Array.new()
# @space.get_children().each do |child|
#
# if child.commandName == "EXTERIOR-WALL" ||
# child.commandName == "ROOF"
# surfaces.push(child)
# end
# end
# return surfaces
# end
#
# # This method returns all the children of the space
# def get_children()
# return @space.get_children()
# end
#
#
#
# # This method returns the area of the space
# def get_area()
# @space.get_area()
# end
#
#
#
#
# def convert_to_openstudio(model,runner = nil)
# if self.space.get_shape() == "NO-SHAPE"
# BTAP::runner_register("Info", "Thermal Zone contains a NO-SHAPE space named. OS does not support no shape spaces. Thermal Zone will not be created.",runner)
# else
# os_zone = OpenStudio::Model::ThermalZone.new(model)
# os_zone.setName(self.name)
# #set space to thermal zone
# OpenStudio::Model::getSpaceByName(model,self.space.name).get.setThermalZone(os_zone)
# BTAP::runner_register("Info", "\tThermalZone: " + self.name + " created",runner)
# end
# end
# end
#
#
# class DOESurface < DOECommand
# attr_accessor :construction
# attr_accessor :polygon
#
# def initialize
# super()
# @polygon = nil
# end
#
# def get_azimuth()
# #puts OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 0.0, 0.0), OpenStudio::Vector3d.new(1.0, 0.0, 0.0) ) )
# if check_keyword?("LOCATION")
# case get_keyword_value("LOCATION")
# when /SPACE-\s*V\s*(.*)/
# index = $1.strip.to_i - 1
# point0 = self.get_parent("SPACE").polygon.point_list[index]
# point1 = self.get_parent("SPACE").polygon.point_list[index + 1] ? get_parent("SPACE").polygon.point_list[index + 1] : get_parent("SPACE").polygon.point_list[0]
# edge = point1-point0
#
# sign = OpenStudio::Vector3d.new(1.0, 0.0, 0.0).dot(( edge )) > 0 ? 1 :-1
# angle = OpenStudio::radToDeg( sign * OpenStudio::getAngle(OpenStudio::Vector3d.new(1.0, 0.0, 0.0), ( point1 - point0 ) ) )
#
# #since get angle only get acute angles we need to get sign and completment for reflex angle
# angle = angle + 180 if edge.y < 0
# return angle
# when "FRONT"
# return OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("SPACE").polygon.point_list[1] - get_parent("SPACE").polygon.point_list[0] ) ) )
# when "RIGHT"
# return OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("SPACE").polygon.point_list[2] - get_parent("SPACE").polygon.point_list[1] ) ) )
# when "BACK"
# return OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("SPACE").polygon.point_list[3] - get_parent("SPACE").polygon.point_list[2] ) ) )
# when "LEFT"
# return OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("SPACE").polygon.point_list[0] - get_parent("SPACE").polygon.point_list[3] ) ) )
# end
# end
# return self.check_keyword?("AZIMUTH")? self.get_keyword_value("AZIMUTH").to_f : 0.0
# end
#
# def get_tilt()
# #puts OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 0.0, 0.0), OpenStudio::Vector3d.new(1.0, 0.0, 0.0) ) )
# if check_keyword?("LOCATION")
# case get_keyword_value("LOCATION")
# when "FRONT","BACK","LEFT","RIGHT",/SPACE-\s*V\s*(.*)/
# return 90.0
# when "TOP"
# return 0.0
# when "BOTTOM"
# return 180.0
# end
# end
# return self.check_keyword?("TILT")? self.get_keyword_value("TILT").to_f : 0.0
# end
#
#
#
#
# def get_origin()
# space_xref = self.check_keyword?("X")? self.get_keyword_value("X").to_f : 0.0
# space_yref = self.check_keyword?("Y")? self.get_keyword_value("Y").to_f : 0.0
# space_zref = self.check_keyword?("Z")? self.get_keyword_value("Z").to_f : 0.0
# return OpenStudio::Vector3d.new(space_xref,space_yref,space_zref)
# end
#
# def get_sub_surface_origin()
# height = ""
# BTAP::runner_register("Info", "geting origin",runner)
# origin = ""
# if self.check_keyword?("X") and self.check_keyword?("Y") and self.check_keyword?("Z")
# BTAP::runner_register("Info", "XYZ definition",runner)
# space_xref = self.get_keyword_value("X").to_f
# space_yref = self.get_keyword_value("Y").to_f
# space_zref = self.get_keyword_value("Z").to_f
# return OpenStudio::Vector3d.new(space_xref,space_yref,space_zref)
# end
# BTAP::runner_register("Info", get_name(),runner)
# array = Array.new()
# origin = ""
# floor = get_parent("FLOOR")
# space = get_parent("SPACE")
# case space.get_keyword_value("ZONE-TYPE")
# when "PLENUM"
# height = floor.get_keyword_value("FLOOR-HEIGHT").to_f - floor.get_keyword_value("SPACE-HEIGHT").to_f
# when "CONDITIONED","UNCONDITIONED"
# height = space.check_keyword?("HEIGHT") ? space.get_keyword_value("HEIGHT").to_f : floor.get_keyword_value("SPACE-HEIGHT").to_f
#
# end
# BTAP::runner_register("Info", "Space is #{space.get_shape}",runner)
# case space.get_shape
# when "BOX"
# BTAP::runner_register("Info", "Box Space Detected....",runner)
# #get height, width and depth of box.
# height = space.check_keyword?("HEIGHT").to_f ? space.check_keyword?("HEIGHT") : height
# width = space.get_keyword_value("WIDTH").to_f
# depth = space.get_keyword_value("DEPTH").to_f
#
# case get_keyword_value("LOCATION")
# when "TOP"
# BTAP::runner_register("Info", "Top of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new(0.0,0.0,height)
#
# when "BOTTOM"
# BTAP::runner_register("Info", "Bottom of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# when "FRONT"
# BTAP::runner_register("Info", "Front of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# when "RIGHT"
# BTAP::runner_register("Info", "Right of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new(width, 0.0, 0.0)
# when "BACK"
# BTAP::runner_register("Info", "Back of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new(width,depth,0.0)
# when "LEFT"
# BTAP::runner_register("Info", "Left of Box....",runner)
# #counter clockwise
# origin = OpenStudio::Point3d.new(0.0,depth,0.0)
#
# end
#
# when "POLYGON"
# #puts "Polygon Space definition detected..."
# if check_keyword?("LOCATION")
# #puts "LOCATION surface definition detected..."
# case get_keyword_value("LOCATION")
# when "BOTTOM"
# origin = OpenStudio::Vector3d.new(0.0,0.0, 0.0 )
# when "TOP"
# #puts "TOP surface definition detected..."
# #need to move floor polygon up to space height for top. Using Transformation.translation matrix for this.
#
# origin = OpenStudio::Vector3d.new(0.0,0.0, height ) #to-do!!!!!!!!!!!
# when /SPACE-\s*V\s*(.*)/
# #puts "SPACE-V#{$1} surface definition detected..."
# index = $1.strip.to_i - 1
# point0 = space.polygon.point_list[index]
# #counter clockwise
# origin = OpenStudio::Point3d.new( point0.x, point0.y, 0.0)
#
# end
# else
# #puts "CATCH-ALL for surface definition.."
# #nasty. The height is NOT defined if the height is the same as the space height...so gotta get it from it's parent space.
# space_height = space.check_keyword?("HEIGHT") ? space.get_keyword_value("HEIGHT").to_f : floor.get_keyword_value("SPACE-HEIGHT").to_f
# height = self.check_keyword?("HEIGHT") ? self.get_keyword_value("HEIGHT").to_f : space_height
# width = self.get_keyword_value("WIDTH").to_f
# #origin
# origin = OpenStudio::Point3d.new(width,0.0,0.0)
# end
# when "NO-SHAPE"
# raise("Using SHAPE = NO-SHAPE deifnition for space is not supported by open Studio")
# end
#
# origin = OpenStudio::Vector3d.new(origin.x,origin.y,origin.z)
# #puts "Surface origin vector is #{origin}"
# return origin
# end
#
#
#
# def get_transformation_matrix
# #Rotate points around z (azimuth) and x (Tilt)
# translation = OpenStudio::createTranslation(self.get_origin)
# e_a = OpenStudio::EulerAngles.new( OpenStudio::degToRad( self.get_tilt ), 0.0, OpenStudio::degToRad( 180.0 - self.get_azimuth ) )
# rotations = OpenStudio::Transformation::rotation(e_a)
# return translation * rotations
# end
#
# def get_3d_polygon()
# array = Array.new()
# origin = ""
# floor = get_parent("FLOOR")
# space = get_parent("SPACE")
# case space.get_keyword_value("ZONE-TYPE")
# when "PLENUM"
# height = floor.get_keyword_value("FLOOR-HEIGHT").to_f - floor.get_keyword_value("SPACE-HEIGHT").to_f
# when "CONDITIONED","UNCONDITIONED"
# height = space.check_keyword?("HEIGHT") ? space.get_keyword_value("HEIGHT").to_f : floor.get_keyword_value("SPACE-HEIGHT").to_f
# end
#
# #if the surface has been given a polygon. Then use it.
# if check_keyword?("POLYGON")
# # puts "Polygon Surface Detected...Doing a local transform.."
# #
# # puts "Point List"
# # puts self.polygon.point_list
# # puts "Origin"
# # puts self.get_origin
# # puts "azimuth"
# # puts self.get_azimuth
# # puts "tilt"
# # puts self.get_tilt
#
#
#
# #all other methods below create points relative to the space. This method however, need to be transformed.
# array = self.polygon.point_list
#
#
# #if surfaces are defined by shape of space.
# else
# case space.get_shape
# when "BOX"
# BTAP::runner_register("Info", "Box Space Detected....",runner)
# #get height, width and depth of box.
# height = space.check_keyword?("HEIGHT").to_f ? space.check_keyword?("HEIGHT") : height
# width = space.get_keyword_value("WIDTH").to_f
# depth = space.get_keyword_value("DEPTH").to_f
#
# case get_keyword_value("LOCATION")
# when "TOP"
# #puts "Top of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new(0.0,0.0,height)
# p2 = OpenStudio::Point3d.new(width,0.0,height)
# p3 = OpenStudio::Point3d.new(width,depth,height)
# p4 = OpenStudio::Point3d.new(0.0,depth,height)
# array = [origin,p2,p3,p4]
# when "BOTTOM"
# #puts "Bottom of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# p2 = OpenStudio::Point3d.new( 0.0, depth, 0.0)
# p3 = OpenStudio::Point3d.new( width, depth, 0.0)
# p4 = OpenStudio::Point3d.new( width,0.0 ,0.0 )
# array = [origin,p2,p3,p4]
# when "FRONT"
# #puts "Front of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# p2 = OpenStudio::Point3d.new( width,0.0 ,0.0 )
# p3 = OpenStudio::Point3d.new( width, 0.0, height)
# p4 = OpenStudio::Point3d.new( 0.0, 0.0, height)
# array = [origin,p2,p3,p4]
# when "RIGHT"
# #puts "Right of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new(width, 0.0, 0.0)
# p2 = OpenStudio::Point3d.new(width,depth, 0.0)
# p3 = OpenStudio::Point3d.new(width,depth,height)
# p4 = OpenStudio::Point3d.new(width,0.0,height)
# array = [origin,p2,p3,p4]
# when "BACK"
# #puts "Back of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new(width,depth,0.0)
# p2 = OpenStudio::Point3d.new(0.0,depth,0.0)
# p3 = OpenStudio::Point3d.new(0.0,depth,height)
# p4 = OpenStudio::Point3d.new(width,depth,height)
# array = [origin,p2,p3,p4]
# when "LEFT"
# #puts "Left of Box...."
# #counter clockwise
# origin = OpenStudio::Point3d.new(0.0,depth,0.0)
# p2 = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# p3 = OpenStudio::Point3d.new(0.0, 0.0,height)
# p4 = OpenStudio::Point3d.new(0.0,depth,height)
# array = [origin,p2,p3,p4]
# end
#
# when "POLYGON"
# #puts "Polygon Space definition detected..."
# if check_keyword?("LOCATION")
# #puts "LOCATION surface definition detected..."
# case get_keyword_value("LOCATION")
# when "BOTTOM"
# #puts "BOTTOM surface definition detected..."
# #reverse array
# array = space.polygon.point_list.dup
# first = array.pop
# array.insert(0,first).reverse!
# when "TOP"
# #puts "TOP surface definition detected..."
# #need to move floor polygon up to space height for top. Using Transformation.translation matrix for this.
# array = OpenStudio::createTranslation(OpenStudio::Vector3d.new(0.0,0.0, height )) * space.polygon.point_list
# when /SPACE-\s*V\s*(.*)/
# #puts "SPACE-V#{$1} surface definition detected..."
# index = $1.strip.to_i - 1
# point0 = space.polygon.point_list[index]
# point1 = space.polygon.point_list[index + 1] ? space.polygon.point_list[index + 1] : space.polygon.point_list[0]
# #counter clockwise
# origin = OpenStudio::Point3d.new( point0.x, point0.y, 0.0)
# p2 = OpenStudio::Point3d.new( point1.x, point1.y, 0.0)
# p3 = OpenStudio::Point3d.new( point1.x, point1.y, height )
# p4 = OpenStudio::Point3d.new( point0.x, point0.y, height )
# array = [origin,p2,p3,p4]
# end
# else
# #puts "CATCH-ALL for surface definition.."
# #nasty. The height is NOT defined if the height is the same as the space height...so gotta get it from it's parent space.
# space_height = space.check_keyword?("HEIGHT") ? space.get_keyword_value("HEIGHT").to_f : floor.get_keyword_value("SPACE-HEIGHT").to_f
# height = self.check_keyword?("HEIGHT") ? self.get_keyword_value("HEIGHT").to_f : space_height
# width = self.get_keyword_value("WIDTH").to_f
# #counter clockwise
# origin = OpenStudio::Point3d.new(width,0.0,0.0)
# p2 = OpenStudio::Point3d.new( 0.0,0.0,0.0 )
# p3 = OpenStudio::Point3d.new(0.0,0.0,height)
# p4 = OpenStudio::Point3d.new(width,0.0,height)
# array = [p4, p3, p2, origin]
#
#
#
# end
# when "NO-SHAPE"
# raise("Using SHAPE = NO-SHAPE deifnition for space is not supported...yet")
# end
# end
# # if self.check_keyword?("AZIMUTH") or self.check_keyword?("TILT")
# # puts "Did a transform"
# # return get_transformation_matrix * array
# # else
# # return array
# # end
# return array
# end
#
#
# def get_windows()
# return self.get_children_of_command("WINDOW")
# end
#
# def get_doors()
# return self.get_children_of_command("DOOR")
# end
#
#
#
# # This method finds all the commands within the building that are "Construction"
# # and if the utype matches, it gets the construction
# def determine_user_defined_construction()
# constructions = @building.find_all_commands("CONSTRUCTION")
# constructions.each do |construction|
# if ( construction.utype == get_keyword_value("CONSTRUCTION") )
# @construction = construction
# end
# end
# return @construction
# end
#
# #This method will try to convert a DOE inp file to an openstudio file..
# def convert_to_openstudio(model,runner = nil)
# #Get 3d polygon of surface and tranform the points based on space origin and the floor origin since they each may use their own co-ordinate base system.
# total_transform = ""
# if self.check_keyword?("AZIMUTH") or self.check_keyword?("TILT")
# total_transform = get_parent("FLOOR").get_transformation_matrix() * get_parent("SPACE").get_transformation_matrix() * get_transformation_matrix()
# else
# total_transform = get_parent("FLOOR").get_transformation_matrix() * get_parent("SPACE").get_transformation_matrix()
# end
# surface_points = total_transform * self.get_3d_polygon()
# #Add the surface to the new openstudio model.
#
# os_surface = OpenStudio::Model::Surface.new(surface_points, model)
# #set the name of the surface.
# os_surface.setName(self.name)
# case self.commandName
# #Set the surface boundary condition if it is a ground surface.
#
# when "UNDERGROUND-WALL"
# BTAP::Geometry::Surfaces::set_surfaces_boundary_condition(model,os_surface, "Ground")
# when "EXTERIOR-WALL","ROOF"
# #this is needed since the surface constructor defaults to a Ground boundary and Floor Surface type
# #when a horizontal surface is initialized.
# if os_surface.outsideBoundaryCondition == "Ground" and os_surface.surfaceType == "Floor"
# os_surface.setSurfaceType("RoofCeiling")
# end
# BTAP::Geometry::Surfaces::set_surfaces_boundary_condition(model,os_surface, "Outdoors")
# when "INTERIOR-WALL"
# BTAP::Geometry::Surfaces::set_surfaces_boundary_condition(model,os_surface, "Surface")
# end
#
# #Add to parent space that was already created.
# os_surface.setSpace(OpenStudio::Model::getSpaceByName( model,get_parent("SPACE").name).get )
# #output to console for debugging.
# BTAP::runner_register("Info", "\tSurface: " + self.name + " created",runner)
# #check if we need to create a mirror surface in another space.
# if self.check_keyword?("NEXT-TO")
# #reverse the points.
# new_array = surface_points.dup
# first = new_array.pop
# new_array.insert(0,first).reverse!
# #...then add the reverse surface to the model and assign the name with a mirror suffix.
# os_surface_mirror = OpenStudio::Model::Surface.new(new_array, model)
# os_surface_mirror.setName(self.name + "-mirror" )
# #Assign the mirror surface to the parent space that is NEXT-TO
# os_surface_mirror.setSpace(OpenStudio::Model::getSpaceByName(model,get_keyword_value("NEXT-TO")).get)
# #output to console for debugging.
# BTAP::runner_register("Info", "\tSurface: " + self.name + "-mirror" + " created",runner)
# end #if statement
#
# #Some switches for debugging.
# convert_sub_surfaces = true
# convert_sub_surfaces_as_surfaces = false
#
# #
# if convert_sub_surfaces
# #convert subsurfaces
# self.get_children().each do |child|
# #Get height and width of subsurface
# height = child.get_keyword_value("HEIGHT").to_f
# width = child.get_keyword_value("WIDTH").to_f
#
#
# #Sum the origin of the surface and the translation of the window
# x = os_surface.vertices.first().x + ( child.check_keyword?("X")? child.get_keyword_value("X").to_f : 0.0 )
# y = os_surface.vertices.first().y + ( child.check_keyword?("Y")? child.get_keyword_value("Y").to_f : 0.0 )
# z = os_surface.vertices.first().z
#
# #counter clockwise
# origin = OpenStudio::Point3d.new( x, y , z )
# p2 = OpenStudio::Point3d.new(x + width , y, z )
# p3 = OpenStudio::Point3d.new(x + width , y + height , z )
# p4 = OpenStudio::Point3d.new(x, y + height, z )
# polygon = [origin,p2,p3,p4]
#
# #get floot and space rotations
# space_azi = 360.0 - get_parent("SPACE").get_azimuth()
# floor_azi = 360.0 - get_parent("FLOOR").get_azimuth()
#
#
# tilt_trans = OpenStudio::Transformation::rotation(os_surface.vertices.first(), OpenStudio::Vector3d.new(1.0,0.0,0.0), OpenStudio::degToRad( self.get_tilt ))
# azi_trans = OpenStudio::Transformation::rotation(os_surface.vertices.first(), OpenStudio::Vector3d.new(0.0,0.0,1.0), OpenStudio::degToRad( 360.0 - self.get_azimuth + space_azi + floor_azi ))
# surface_points = azi_trans * tilt_trans * polygon
# if convert_sub_surfaces_as_surfaces
# #Debug subsurface
# os_sub_surface = OpenStudio::Model::Surface.new(surface_points, model)
# #set the name of the surface.
# os_sub_surface.setName(child.name)
# #Add to parent space that was already created.
# os_sub_surface.setSpace(OpenStudio::Model::getSpaceByName( model,self.get_parent("SPACE").name).get )
# else
# #Add the subsurface to the new openstudio model.
# os_sub_surface = OpenStudio::Model::SubSurface.new(surface_points, model)
# #set the name of the surface.
# os_sub_surface.setName(child.name)
# #Add to parent space that was already created.
# os_sub_surface.setSurface(os_surface)
# #output to console for debugging.
# BTAP::runner_register("Info", "\tSubSurface: " + child.name + " created",runner)
# case child.commandName
# when "WINDOW"
# #By default it is a window.
# when "DOOR"
# os_sub_surface.setSubSurfaceType( "Door" )
# end #end case.
#
# # Add overhang for subsurface if required. Note this only supports overhangs of width the same as the window.
# if child.check_keyword?("OVERHANG-D") == true
# offset = 0.0
# offset = child.get_keyword_value("OVERHANG-O").to_f if child.check_keyword?("OVERHANG-O")
# depth = 0.0
# depth = child.get_keyword_value("OVERHANG-D").to_f
# os_sub_surface.addOverhang( depth , offset )
# end
#
# end
# end
# end
# end
#
# end
#
# #This class allows to manipulate a subsurface (window/door) in inherits from surface.
# class DOESubSurface < DOESurface
#
# def initialize
# #run the parent class initialization.
# super()
# end
#
# # This method returns the area of the window
# def get_area()
# unless check_keyword?("HEIGHT") and check_keyword?("WIDTH")
# raise "Error: In the command #{@utype}:#{@command_name} the area could not be evaluated. Either the HEIGHT or WIDTH is invalid.\n #{output}"
# end
# return get_keyword_value("WIDTH").to_f * get_keyword_value("HEIGHT").to_f
# end
#
# #Return the widow polygon with an origin of zero
# def get_3d_polygon()
# height = get_keyword_value("HEIGHT").to_f
# width = get_keyword_value("WIDTH").to_f
# x = self.check_keyword?("X")? self.get_keyword_value("X").to_f : 0.0
# y = self.check_keyword?("Y")? self.get_keyword_value("Y").to_f : 0.0
# #counter clockwise
# origin = OpenStudio::Point3d.new( x, y , 0.0 )
# p2 = OpenStudio::Point3d.new(x + width , y,0.0 )
# p3 = OpenStudio::Point3d.new(x + width , y + height , 0.0 )
# p4 = OpenStudio::Point3d.new(x, y + height,0.0 )
# return [origin,p2,p3,p4]
# end
#
# #Returns the origin relative to the parent surface.
# def get_origin()
# origin = get_parent_surface().get_sub_surface_origin()
# return origin
# end
#
# #Gets azimuth, based on parent surface.
# def get_azimuth()
# get_parent_surface().get_azimuth()
# end
#
# #gets tilt based on parent surface.
# def get_tilt()
# get_parent_surface().get_tilt()
# end
#
# #return the parent surface of the subsurface.
# def get_parent_surface()
# get_parents().each do |findcommand|
# [
# "EXTERIOR-WALL",
# "INTERIOR-WALL",
# "UNDERGROUND-WALL",
# "ROOF"
# ].each do |type|
#
# if ( findcommand.commandName == type)
# return findcommand
# end
# end
# end
# raise("#no parent surface defined!")
# end
#
# #returns the translation matrix reletive to its parent ( the surface )
# def get_transformation_matrix
# return self.get_rotation_matrix() * self.get_translation_matrix()
# end
#
# def get_rotation_matrix
# #Rotate points around z (azimuth) and x (Tilt)
# e_a = OpenStudio::EulerAngles.new( OpenStudio::degToRad( self.get_tilt ), 0.0, OpenStudio::degToRad( 0.0 ) )
# rotations = OpenStudio::Transformation::rotation(e_a)
# return rotations
# end
#
# def get_translation_matrix
# #Rotate points around z (azimuth) and x (Tilt)
# translation = OpenStudio::createTranslation(self.get_origin)
# return translation
# end
#
#
#
#
#
# # this will translate the subsurface to the openstudio model.
# def convert_to_openstudio(model)
# end
# end
#
# #an attempt to organize the BDLlibs...don't think it works well at all.
# class DOEBDLlib
#
# attr_accessor :db, :materials
#
# include Singleton
#
#
#
#
# # stores the name of the individual materials
#
# attr_accessor :commandList
# # stores the name of the individual layers
#
#
# def initialize
# @commandList = Array.new()
# @db = Sequel.sqlite
# @db.create_table :materials do # Create a new table
# primary_key :id, :integer, :auto_increment => true
# column :command_name, :text
# column :name, :text
# column :type, :text
# column :thickness, :float
# column :conductivity, :float
# column :resistance, :float
# column :density, :float
# column :spec_heat, :float
# end
# @materials = @db[:materials] # Create a dataset
#
# @db.create_table :layers do # Create a new table
# primary_key :id, :integer, :auto_increment => true
# column :command_name, :text
# column :name, :text
# column :material, :text
# column :inside_film_res, :float
# end
# @layers = @db[:layers] # Create a dataset
#
#
# store_material()
# end
#
#
#
# def find_material(utype)
# posts = @materials.filter(:name => utype)
# record = posts.first()
# #Create the new command object.
# command = DOE2::DOECommand.new()
# #Insert the collected information into the object.
# command.commandName = "MATERIAL"
# command.utype = record[:name]
# command.set_keyword_value("TYPE", record[:type])
# command.set_keyword_value("THICKNESS", record[:thickness])
# command.set_keyword_value("CONDUCTIVITY", record[:conductivity])
# command.set_keyword_value("DENSITY", record[:density])
# command.set_keyword_value("SPECIFIC HEAT", record[:spec_heat])
#
# return command
# end
#
#
# def find_layer(utype)
# posts = @layers.filter(:name => utype)
# record = posts.first()
# #Create the new command object.
# command = DOE2::DOECommand.new()
# #Insert the collected information into the object.
# command.commandName = "LAYERS"
# command.utype = record[:name]
# command.set_keyword_value("MATERIAL", record[:material])
# command.set_keyword_value("THICKNESS", record[:thickness])
# command.set_keyword_value("CONDUCTIVITY", record[:conductivity])
# command.set_keyword_value("DENSITY", record[:density])
# command.set_keyword_value("SPECIFIC HEAT", record[:spec_heat])
#
# return command
# end
#
#
#
#
#
# # stores the material information using keywordPairs into the command structure
# # accessed using the find_command method
# private
# def store_material
#
# begin
# f = File.open("../Resources/DOE2_2/bdllib.dat")
# rescue
# f = File.open("Resources/DOE2_2/bdllib.dat")
# end
#
# lines = f.readlines
# # Iterating through the file.
# lines.each_index do |i|
# command_string = ""
# # If we find a material.
# if lines[i].match(/\$LIBRARY-ENTRY\s(.{32})MAT .*/)
# #Get the name strips the white space.
# name = ("\""+$1.strip + "\"")
#
# #Is this the last line?
# command_string = get_data(command_string, i, lines)
# #Extract data for material type PROPERTIES.
# if (match = command_string.match(/^\s*TYPE\s*=\s*(\S*)\s*TH\s*=\s*(\S*)\s*COND\s*=\s*(\S*)\s*DENS\s*=\s*(\S*)\s*S-H\s*=\s*(\S*)\s*$/) )
# #Create the new command object.
# command = DOE2::DOECommand.new()
# #Insert the collected information into the object.
# command.commandName = "MATERIAL"
# command.utype = name
# command.set_keyword_value("TYPE", $1.strip)
# command.set_keyword_value("THICKNESS", $2.strip.to_f.to_s)
# command.set_keyword_value("CONDUCTIVITY", $3.strip.to_f.to_s)
# command.set_keyword_value("DENSITY", $4.strip.to_f.to_s)
# command.set_keyword_value("SPECIFIC HEAT", $5.strip.to_f.to_s)
# #Push the object into the array for storage.
# @commandList.push(command)
# @materials << {:name => name,
# :command_name => 'MATERIAL',
# :type => $1.strip,
# :thickness => $2.strip.to_f.to_s,
# :conductivity => $3.strip.to_f.to_s,
# :density => $4.strip.to_f.to_s,
# :spec_heat => $5.strip.to_f.to_s}
#
#
#
# #Extract data for material type RESISTANCE.
# elsif (match = command_string.match(/^\s*TYPE\s*=\s*(\S*)\s*RES\s*=\s*(\S*)\s*$/) )
# command = DOE2::DOECommand.new()
# command.commandName = "MATERIAL"
# command.utype = name
# command.set_keyword_value("TYPE", $1.strip)
# command.set_keyword_value("RESISTANCE", $2.strip.to_f.to_s)
# #Push the object into the array for storage.
# @materials << {:name => name,
# :command_name => 'MATERIAL',
# :type => $1.strip,
# :resistance => $2.strip.to_f.to_s}
#
# @commandList.push(command)
# else
# raise("data not extracted")
# end
# end
#
# if lines[i].match(/\$LIBRARY-ENTRY\s(.{32})LA .*/)
# #Get the name
# name = ("\""+$1.strip + "\"")
# #Is this the last line?
# command_string = get_data(command_string, i, lines)
# #Extract data into the command.
# if (match = command_string.match(/^\s*MAT\s*=\s*(.*?)\s*I-F-R\s*=\s*(\S*)\s*$/) )
# command = DOE2::DOECommand.new()
# command.commandName = "LAYERS"
# command.utype = name
# command.set_keyword_value("MATERIAL",$1)
# #Push the object into the array for storage.
# @layers << {:name => name,
# :command_name => 'LAYER',
# :material => $1.strip,
# :inside_film_res => $2.strip.to_f.to_s}
# @commandList.push(command)
# else
# raise("data not extracted")
# end
# end
# end
# end
#
# private
# # This method will get all the
# def get_data(command_string, i, lines)
# #Do this while this is NOT the last line of data.
# while (! lines[i].match(/^(.*?)\.\.\s*(.{6})?\s*?(\d*)?/) )
# #Grab all the data in between.
# if ( lines[i].match(/^\$.*$/) )
# elsif ( myarray = lines[i].match(/^(.*?)\s*(.{6})?\s*?(\d*)?\s*$/) )
# command_string = command_string + $1.strip
# end
# #Increment counter.
# i = i + 1
# end
# #Get the last line
# lines[i].match(/^(.*?)\.\.\s*(.{6})?\s*?(\d*)?/)
# command_string = command_string + $1.strip
# if command_string == ""
# raise("error")
# end
# i = i + 1
# command_string
# end
# end
#
# #class that
# class DOEExteriorWall < DOESurface
#
# def initialize
# #call the parent class.
# super()
# end
#
# # This method finds the area of the exterior wall
# def get_area()
# OpenStudio::getArea(self.get_3d_polygon())
# end
#
# #This method finds the floor parent
# def get_floor()
# get_parent("FLOOR")
# end
#
# #This method finds the space parent command
# def get_space()
# get_parent("SPACE")
# end
#
# #This method gets the construction command
# def get_construction_name()
# get_keyword_value("CONSTRUCTION")
# end
#
# #This method returns the window area
# def get_window_area()
# get_children_area("WINDOW")
# end
#
# #This method returns the door area
# def get_door_area()
# get_children_area("DOOR")
# end
#
# # This method returns the difference between the wall area and the window
# # and door
# def get_opaque_area()
# get_area.to_f - get_window_area().to_f - get_door_area().to_f
# end
#
# # This method returns the fraction of the wall dominated by the window
# def get_fwr()
# get_window_area().to_f / get_area.to_f
# end
#
# # This method returns the area of the children classes based on the given
# # commandname.
# # Input => A command_name as a String
# # Output => Total area as a float
# def get_children_area(scommand_name)
# area = 0.0
# @children.each do |child|
#
# if child.commandName == scommand_name
# area = child.get_area() + area
# end
# end
# return area
# end
#
# # This method checks if the construction only has a defined U-value
# def just_u_value?()
# @construction.check_keyword?("U-VALUE")
# end
#
#
# end
#
#
#
#
#
#
# #The interface for the roof command.. same as parent.
# class DOERoof < DOECommand
# def initialize
# super()
# end
#
# # This method finds the area of the roof
# def get_area
#
# # Finds the floor and space parents and assigns them to @floor and @space
# # variables to be used later
# parent = get_parents
# parent.each do |findcommand|
# if ( findcommand.commandName == "FLOOR" )
# @floor = findcommand
# end
# if ( findcommand.commandName == "SPACE")
# @space = findcommand
# end
# end
#
# # Get the keyword value for location
# begin
# location = get_keyword_value("LOCATION")
# rescue
# end
#
# # Get the keyword value for polygon
# begin
# polygon_id = get_keyword_value("POLYGON")
# rescue
# end
#
# # if the polygon_id keyword value was nil and the location value was nil, then
# # the height and width are directly defined within the "roof" command
#
#
# if ( location == "BOTTOM" || location == "TOP") && (@space.get_shape != "BOX")
# return @space.polygon.get_area
#
# elsif ( location == nil && polygon_id == nil )
# height = get_keyword_value("HEIGHT")
# width = get_keyword_value("WIDTH")
# height = height.to_f
# width = width.to_f
# return height * width
# elsif ( location == nil && polygon_id != nil)
# return @space.polygon.get_area
#
#
# # if the location was defined as "SPACE...", it is immediately followed by a
# # vertex, upon which lies the width of the roof
# elsif location.match(/SPACE.*/)
# location = location.sub( /^(.{6})/, "")
# width = @space.polygon.get_length(location)
# height = @floor.get_space_height
# return width * height
# # if the shape was a box, the width and height would be taken from the
# # "SPACE" object
# elsif ( @space.get_shape == "BOX" )
# width = @space.get_width
# height = @space.get_height
# return width * height
# else
# raise "The area could not be evaluated"
# end
# end
#
# #returns tilt of roof surface.
# def get_tilt()
# if check_keyword?("TILT") then return get_keyword_value("TILT").to_f
# else
# if check_keyword?("LOCATION")
# location = get_keyword_value("LOCATION")
# case location
# when "TOP"
# return 0.0
# when "BOTTOM"
# return 180.0
# when "LEFT", "RIGHT", "BACK", "FRONT"
# return 90.0
# end
# end
# # If it is a polygon or not defined, set to DOE default = 0.0
# return 0
# end
# end
#
# # This method returns the Azimuth value as a FLOAT if it exists
# # It first checks if the azimuth keyword value is present within the roof
# # command itself. If it does not find this, then it checks for the location
# # keyword and assigns the correct azimuth depending on the azimuth of the parent
# # space. However, if the shape of the parent space is defined as a polygon, then it
# # searches for the location of the roof and uses the polygon's get-azimuth for the vertex
# # to return the azimuth of the roof
#
# #NOTE: The FRONT is defined as 0, going clockwise, ie. RIGHT = 90 degrees
#
# #OUTPUT: Azimuth between the parent SPACE and the ROOF
# def get_azimuth()
# space = get_parent("SPACE")
# if check_keyword?("AZIMUTH") then return get_keyword_value("AZIMUTH").to_f
# else
# if check_keyword?("LOCATION")
# location = get_keyword_value("LOCATION")
#
# case location
# when "TOP"
# raise "Exception: Azimuth does not exist"
# when "BOTTOM"
# raise "Exception: Azimuth does not exist"
# when "FRONT"
# return 0.0 + space.get_azimuth
# when "RIGHT"
# return 90.0 + space.get_azimuth
# when "BACK"
# return 180.0 + space.get_azimuth
# when "LEFT"
# return 270.0 + space.get_azimuth
# end
# end
# if space.get_keyword_value("SHAPE") == "POLYGON"
# space_vertex = get_keyword_value("LOCATION")
# space_vertex.match(/SPACE-(.*)/)
# vertex = $1.strip
# return space.polygon.get_azimuth(vertex)
# end
#
# end
# end
#
# # This method returns the Azimuth value as a FLOAT if it exists
# # It first checks if the azimuth keyword value is present within the roof
# # command itself. If it does not find this, then it checks for the location
# # keyword and assigns the correct azimuth depending on the azimuth of the parent
# # space. However, if the shape of the parent space is defined as a polygon, then it
# # searches for the location of the roof and uses the polygon's get-azimuth for the vertex
# # and adding it on to the overall azimuth to get the Absolute Azimuth from True North
#
# #NOTE: The FRONT is defined as 0, going clockwise, ie. RIGHT = 90 degrees
#
# #OUTPUT: Azimuth between ROOF and TRUE NORTH
# def get_absolute_azimuth
# space = get_parent("SPACE")
# if check_keyword?("AZIMUTH")
# azimuth = get_keyword_value("AZIMUTH").to_f
# space_azimuth = space.get_absolute_azimuth
# return azimuth + space_azimuth
# else
# if check_keyword?("LOCATION")
# location = get_keyword_value("LOCATION")
# case location
# when "TOP"
# raise "Exception: Azimuth does not exist"
# when "BOTTOM"
# raise "Exception: Azimuth does not exist"
# when "FRONT"
# return 0.0 + space.get_absolute_azimuth
# when "RIGHT"
# return 90.0 + space.get_absolute_azimuth
# when "BACK"
# return 180.0 + space.get_absolute_azimuth
# when "LEFT"
# return 270.0 + space.get_absolute_azimuth
# end
# end
# if space.get_keyword_value("SHAPE") == "POLYGON"
# space_vertex = get_keyword_value("LOCATION")
# space_vertex.match(/SPACE-(.*)/)
# vertex = $1.strip
# return space.polygon.get_azimuth(vertex) + space.get_absolute_azimuth
# end
# end
# end
# end
# #Interface for the DOESpace Command.
# class DOESpace < DOECommand
# attr_accessor :polygon
# attr_accessor :zone
# def initialize
#
# super()
# end
#
# #this outputs the command to a string.
# def output
# temp_string = basic_output()
# if @polygon != nil
# temp_string = temp_string + "$Polygon\n"
# temp_string = temp_string + "$\t#{@polygon.utype} = #{@polygon.commandName}\n"
# end
# if @zone != nil
# temp_string = temp_string + "$Zone\n"
# temp_string = temp_string + "$\t#{@zone.utype} = #{@zone.commandName}\n"
# end
# return temp_string
# end
#
# # This method finds the area of the space
# def get_area
#
# # get the keyword value of shape
# shape = get_keyword_value("SHAPE")
#
# # if the shape value is nil, or it is defined as "NO-SHAPE", the get_area value
# # would be defined, and would represent the get_area of the space
# if ( shape == nil || shape == "NO-SHAPE")
# area = get_keyword_value("AREA")
# area = area.to_f
# return area
#
# # if the shape value is "BOX", the height and width key values are given,
# # and the get_area would be defined as their product
# elsif ( shape == "BOX" )
# height = get_keyword_value("HEIGHT")
# width = get_keyword_value("WIDTH")
# height = height.to_f
# width = width.to_f
# return height * width
#
# # if the shape value is defined as a polygon , the get_area of the polygon would
# # represent the get_area of the space
# elsif ( shape == "POLYGON")
# return @polygon.get_area
# else
# raise "Error: The area could not be evaluated. Please check inputs\n "
#
# end
# end
#
# # This method finds the volume of the space
# def get_volume
#
# # get the keyword value of "SHAPE"
# shape = get_keyword_value("SHAPE")
#
# # if the shape value returns nil, or is defined as "NO-SHAPE", the volume is
# # given directly
# if ( shape == nil || shape == "NO-SHAPE")
# volume = get_keyword_value("VOLUME")
# volume = volume.to_f
# return volume
#
# # if the shape is defined as a "BOX", the values for height, width, and
# # depth are given, from which you can get the volume
# elsif ( shape == "BOX" )
# height = get_keyword_value("HEIGHT")
# width = get_keyword_value("WIDTH")
# depth = get_keyword_value("DEPTH")
# height = height.to_f
# width = width.to_f
# depth = depth.to_f
# return height * width * depth
#
# # if the shape is defined as a "POLYGON", the get_area is defined as the area
# # of the polygon, and the height is given by the value of "HEIGHT"
# elsif ( shape == "POLYGON")
# height = getKeywordvalue("HEIGHT")
# temp = get_keyword_value("POLYGON")
# height = height.to_f
# @polygon.utype = temp
# return @polygon.get_area * height
# else
# raise "Error: The volume could not be evaluated. Please check inputs\n "
#
# end
#
# end
#
# def get_height()
# if check_keyword?("HEIGHT") then return get_keyword_value("HEIGHT").to_f end
# return get_floor.get_keyword_value("SPACE-HEIGHT").to_f
# end
#
# def get_width
# width = get_keyword_value("WIDTH")
# width = width.to_f
# return width
# end
#
# def get_depth
# depth = get_keyword_value("DEPTH")
# depth = depth.to_f
# return depth
# end
#
# def get_shape
# return "NO-SHAPE" unless check_keyword?("SHAPE")
# return get_keyword_value("SHAPE")
# end
#
# def get_floor
# get_parent("FLOOR")
# end
#
#
# def get_origin()
# space_origin = nil
# if check_keyword?("LOCATION") and ( not self.check_keyword?("X") or not self.check_keyword?("Y") or not self.check_keyword?("Z") )
# zero = OpenStudio::Point3d.new( 0.0, 0.0, 0.0 )
# case get_keyword_value("LOCATION")
# when /FLOOR-\s*V\s*(.*)/
# index = $1.strip.to_i - 1
# surf_vector = get_parent("FLOOR").polygon.point_list[index] - zero
# when "FRONT"
# surf_vector = get_parent("FLOOR").polygon.point_list[0] - zero
# when "RIGHT"
# surf_vector = get_parent("FLOOR").polygon.point_list[1] - zero
# when "BACK"
# surf_vector = get_parent("FLOOR").polygon.point_list[2] - zero
# when "LEFT"
# surf_vector = get_parent("FLOOR").polygon.point_list[3] - zero
# end
# space_xref = self.check_keyword?("X")? self.get_keyword_value("X").to_f : 0.0
# space_yref = self.check_keyword?("Y")? self.get_keyword_value("Y").to_f : 0.0
# space_zref = self.check_keyword?("Z")? self.get_keyword_value("Z").to_f : 0.0
# space_origin = OpenStudio::Vector3d.new(space_xref,space_yref,space_zref)
# space_origin = surf_vector + space_origin
# else
# space_xref = self.check_keyword?("X")? self.get_keyword_value("X").to_f : 0.0
# space_yref = self.check_keyword?("Y")? self.get_keyword_value("Y").to_f : 0.0
# space_zref = self.check_keyword?("Z")? self.get_keyword_value("Z").to_f : 0.0
# space_origin = OpenStudio::Vector3d.new(space_xref,space_yref,space_zref)
# end
# return space_origin
# end
#
# def get_azimuth()
# angle = 0.0
# #puts OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 0.0, 0.0), OpenStudio::Vector3d.new(1.0, 0.0, 0.0) ) )
# if check_keyword?("LOCATION") and not check_keyword?("AZIMUTH")
# case get_keyword_value("LOCATION")
# when /FLOOR-\s*V\s*(.*)/
# index = $1.strip.to_i - 1
# point0 = self.get_parent("FLOOR").polygon.point_list[index]
# point1 = self.get_parent("FLOOR").polygon.point_list[index + 1] ? get_parent("FLOOR").polygon.point_list[index + 1] : get_parent("FLOOR").polygon.point_list[0]
# edge = point1-point0
#
#
# sign = 1.0# OpenStudio::Vector3d.new(1.0, 0.0, 0.0).dot(( edge )) > 0 ? 1 :-1
# angle = OpenStudio::radToDeg( sign * OpenStudio::getAngle(OpenStudio::Vector3d.new(1.0, 0.0, 0.0), ( point1 - point0 ) ) )
#
# #since get angle only get acute angles we need to get sign and completment for reflex angle
# if edge.y > 0.0
# angle = -1.0 * angle
# end
#
# when "FRONT"
# angle = OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("FLOOR").polygon.point_list[1] - get_parent("FLOOR").polygon.point_list[0] ) ) )
# when "RIGHT"
# angle = OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("FLOOR").polygon.point_list[2] - get_parent("FLOOR").polygon.point_list[1] ) ) )
# when "BACK"
# angle = OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("FLOOR").polygon.point_list[3] - get_parent("FLOOR").polygon.point_list[2] ) ) )
# when "LEFT"
# angle = OpenStudio::radToDeg( OpenStudio::getAngle(OpenStudio::Vector3d.new(0.0, 1.0, 0.0), ( get_parent("FLOOR").polygon.point_list[0] - get_parent("FLOOR").polygon.point_list[3] ) ) )
# end
# else
# angle = self.check_keyword?("AZIMUTH")? self.get_keyword_value("AZIMUTH").to_f : 0.0
# end
# return angle
# end
#
#
# def get_transformation_matrix()
# #This will transform the space vertices to normal space co-ordinates using Sketchup/OS convention
# return OpenStudio::createTranslation(self.get_origin) * OpenStudio::Transformation::rotation(OpenStudio::Vector3d.new(0.0, 0.0, 1.0), OpenStudio::degToRad(360.0 - self.get_azimuth()))
# end
#
# def get_rotation_matrix()
# return OpenStudio::Transformation::rotation(OpenStudio::Vector3d.new(0.0, 0.0, 1.0), OpenStudio::degToRad(360.0 - self.get_azimuth()))
# end
#
# def convert_to_openstudio(model,runner = nil)
# if self.get_keyword_value("SHAPE") == "NO-SHAPE"
# BTAP::runner_register("Info", "OpenStudio does not support NO-SHAPE SPACE definitions currently. Not importing the space #{self.name}.",runner)
# else
# os_space = OpenStudio::Model::Space.new(model)
# os_space.setName(self.name)
# #set floor
# os_space.setBuildingStory(OpenStudio::Model::getBuildingStoryByName(model,self.get_parent("FLOOR").name).get)
# BTAP::runner_register("Info", "\tSpace: " + self.name + " created",runner)
# #puts "\t\t Azimuth:#{self.get_azimuth}"
# #puts "\t\t Azimuth:#{self.get_origin}"
# end
# end
#
# end
# class DOEFloor < DOESurface
# attr_accessor :polygon
# # a string object which defines the type of roof (e.g. attic)
# attr_accessor :type
# # The absorptance of the exterior surface of the floor
# # (see rule #4.3.5.3.(6)
# attr_accessor :absorptance
# # thermal insulation of floors
# attr_accessor :thermal_insulation
#
# def initialize
# super()
# end
#
# #This method returns the floor area
# def get_area
#
# # get the keyword for the shape of the floor
# case get_keyword_value("SHAPE")
#
# # if the keyword value is "BOX", the width and depth values are defined
# when "BOX"
# return get_keyword_value("WIDTH").to_f * get_keyword_value("DEPTH").to_f
#
# # if the keyword value is "POLYGON", the get_area is defined as the area of the
# # given polygon
# when "POLYGON"
# return @polygon.get_area
#
# # if the keyword value of the floor is "No-SHAPE", the get_area is given as the
# # get_area keyword value
# when "NO-SHAPE"
# return get_keyword_value("AREA").to_f
# else
# raise "Error: The area could not be evaluated. Please check inputs\n "
# end
# end
#
# # This method returns the volume of the floor space
# def get_volume
# return get_floor_height.to_f * get_area.to_f
# end
#
# # gets the height of the floor
# def get_height
# return get_keyword_value("FLOOR-HEIGHT").to_f
# end
#
# # gets the space height
# def get_space_height
# return get_keyword_value("SPACE-HEIGHT").to_f
# end
#
# def get_origin()
# space_xref = self.check_keyword?("X")? self.get_keyword_value("X").to_f : 0.0
# space_yref = self.check_keyword?("Y")? self.get_keyword_value("Y").to_f : 0.0
# space_zref = self.check_keyword?("Z")? self.get_keyword_value("Z").to_f : 0.0
# return OpenStudio::Vector3d.new(space_xref,space_yref,space_zref)
# end
#
# def get_azimuth()
# return self.check_keyword?("AZIMUTH")? self.get_keyword_value("AZIMUTH").to_f : 0.0
# end
#
# def get_transformation_matrix()
# return OpenStudio::createTranslation(self.get_origin) * OpenStudio::Transformation::rotation(OpenStudio::Vector3d.new(0.0, 0.0, 1.0), OpenStudio::degToRad(360.0 - self.get_azimuth()))
# end
#
# def get_rotation_matrix()
# return OpenStudio::Transformation::rotation(OpenStudio::Vector3d.new(0.0, 0.0, 1.0), OpenStudio::degToRad(360.0 - self.get_azimuth()))
# end
#
# def convert_to_openstudio(model,runner = nil)
# floor = OpenStudio::Model::BuildingStory.new(model)
# floor.setName(self.name)
# BTAP::runner_register("Info", "\tBuildingStory: " + self.name + " created",runner)
# end
#
# end
# #This class makes it easier to deal with DOE Polygons.
# class DOEPolygon < DOECommand
#
# attr_accessor :point_list
#
# #The constructor.
# def initialize
# super()
# @point_list = Array.new()
# #Convert Keywork Pairs to points.
#
# end
#
# def create_point_list()
#
# #Convert Keywork Pairs to points.
# @point_list.clear
# @keywordPairs.each do |array|
#
# array[1].match(/\(\s*(\-?\d*\.?\d*)\s*\,\s*(\-?\d*\.?\d*)\s*\)/)
# #puts array[1]
#
# point = OpenStudio::Point3d.new($1.to_f,$2.to_f,0.0)
# @point_list.push(point)
# end
# # @point_list.each do |p|
# # puts p.x.to_s + " " + p.y.to_s + " " + p.z.to_s + " "
# # end
# end
#
# # This method returns the area of the polygon.
# def get_area
# openstudio::getArea(@points_list)
# end
#
#
# # This method must determine the length of the given point to the next point
# # in the polygon list. If the point is the last point, then it will be the
# # distance from the last point to the first.
# # point_name is the string named keyword in the keyword pair list.
# # Example:
# # "DOEPolygon 2" = POLYGON
# # V1 = ( 0, 0 )
# # V2 = ( 0, 1 )
# # V3 = ( 2, 1 )
# # V4 = ( 2 ,0 )
# # get_length(3) should return "2"
# # get_length(2) should return "1"
#
# def get_length(point_index)
# if @points_list.size < pointindex + 2
# return OpenStudio::getDistance(@point_list[0],@point_list.last)
# else
# return OpenStudio::getDistance(@point_list[point_index],@point_list[point_index + 1] )
# end
# end
#
#
# def get_azimuth(point_index)
# if @points_list.size < pointindex + 2
# return OpenStudio::radToDeg(OpenStudio::getAngle(@point_list.last - @point_list[0] , openstudio::Vector3d( 1.0, 0.0, 0.0)))
# else
# return OpenStudio::radToDeg(OpenStudio::getAngle(@point_list[point_index + 1] - @point_list[point_index] , openstudio::Vector3d( 1.0, 0.0, 0.0)))
# end
# end
#
# end
# class DOELayer < DOECommand
# # type of material (see rule #4.3.5.2.(3))
# attr_accessor :material
# # the thickness of the material (see rule #4.3.5.2.(3))
# attr_accessor :thickness
# def initialize
# super()
# end
# end
# class DOEMaterial < DOECommand
# # characteristics of the materials
# attr_accessor :density
# attr_accessor :specific_heat
# attr_accessor :thermal_conductivity
# def initialize
# super()
# end
# end
# class DOEConstruction < DOECommand
#
# def initialize
# super()
# end
#
# def get_materials()
# bdllib = DOE2::DOEBDLlib.instance
# materials = Array.new
#
# case self.get_keyword_value("TYPE")
# when "LAYERS"
# # finds the command associated with the layers keyword
# layers_command = building.find_command_with_utype( self.get_keyword_value("LAYERS") )
#
# #if Layres command cannot be found in the inp file... find it in the bdl database.
# layers_command = bdllib.find_layer(self.get_keyword_value("LAYERS")) unless layers_command.length == 1
#
# # if there ends up to be more than one command with the layers keyword
# # raise an exception
# raise "Layers was defined more than once " + self.get_keyword_value("LAYERS").to_s if layers_command.length > 1
#
# # get all the materials, separate it by the quotation marks and push it
# # onto the materials array
# layers_command[0].get_keyword_value("MATERIAL").scan(/(\".*?\")/).each do |material|
# material_command = ""
#
# #Try to find material in doe model.
# material_command_array = building.find_command_with_utype(material.to_s.strip)
#
# # if there ends up to be more than one, raise an exception
# raise "Material was defined more than once #{material}" if material_command_array.length > 1
#
# # if the material cannot be found within the model, find it within the doe2 database
# material_command = bdllib.find_material(material) if material_command_array.length < 1
#
# #If material was found then set it.
# material_command = material_command_array[0] if material_command_array.length == 1
#
# materials.push(material_command)
# end
# return materials
# when "U-VALUE"
# return nil
# end
# end
#
# # This method finds the u-value of the given construction
# # Output => total conductivity as a float
# def get_u_value()
# total_conductivity = 0.0
# case self.get_keyword_value("TYPE")
# when "LAYERS"
# self.get_materials().each do |material_command|
# case material_command.get_keyword_value("TYPE")
# when "RESISTANCE"
# conductivity = 1 / material_command.get_keyword_value("RESISTANCE").to_f
# when "PROPERTIES"
# conductivity = material_command.get_keyword_value("CONDUCTIVITY").to_f
# else
# raise "Error in material properties"
# end
# total_conductivity = total_conductivity + conductivity
# end
# return total_conductivity
# when "U-VALUE"
# return self.get_keyword_value("U-VALUE").to_f
# end
# end
#
#
# end
# class DOECommandFactory
# def initialize
#
# end
#
# def DOECommandFactory.command_factory(command_string, building)
#
# command = ""
# command_name = ""
# if (command_string != "")
# #Get command and u-value
# if ( command_string.match(/(^\s*(\".*?\")\s*\=\s*(\S+)\s*)/) )
# command_name=$3.strip
# else
# # if no u-value, get just the command.
# command_string.match(/(^\s*(\S*)\s)/ )
# @command_name=$2.strip
#
# end
# end
# case command_name
# when "ZONE" then
# command = DOEZone.new()
# when "FLOOR" then
# command = DOEFloor.new()
# when "SPACE" then
# command = DOESpace.new()
# when "EXTERIOR-WALL" then
# command = DOEExteriorWall.new()
# when "INTERIOR-WALL" then
# command = DOESurface.new()
# when "UNDERGROUND-WALL" then
# command = DOESurface.new()
# when "ROOF" then
# command = DOERoof.new()
# when "WINDOW" then
# command = DOESubSurface.new()
# when "DOOR" then
# command = DOESubSurface.new()
# when "POLYGON" then
# command = DOEPolygon.new()
# when "LAYER" then
# command = DOELayer.new()
# when "MATERIAL" then
# command = DOEMaterial.new()
# when "CONSTRUCTION" then
# command = DOEConstruction.new()
# else
# command = DOECommand.new()
# end
#
# command.get_command_from_string(command_string)
# command.building = building
# return command
# end
# end
#
# # This is the main interface dealing with DOE inp files. You can load, save
# # manipulate doe files with this interface at a command level.
# class DOEBuilding
#
# #An array to contain all the DOE
# attr_accessor :commands
# #An array to contain the current parent when reading in the input files.
# attr_accessor :parents
#
#
# # This method makes a deep copy of the building object.
# def clone
# return Marshal::load(Marshal.dump(self))
# end
#
# # The Constructor.
# def initialize
#
# @commands=[]
# @parents=[]
# @commandList = Array.new()
#
# end
#
# # This method will find all Commands given the command name string.
# # Example
# # def find_all_Command("ZONE") will return an array of all the ZONE commands
# # used in the building.
# def find_all_commands (sCOMMAND)
# array = Array.new()
# @commands.each do |command|
# if (command.commandName == sCOMMAND)
# array.push(command)
# end
# end
# return array
# end
#
# # This method will find all Commands given the command name string.
# # Example
# # def find_all_Command("Default Construction") will return an array of all
# # the commands with "Default Construction" as the u-type used in the building.
# def find_command_with_utype (utype)
# array = Array.new()
# @commands.each do |command|
# if (command.utype == utype)
# array.push(command)
# end
# end
# return array
# end
#
#
# # Same as find_all_commands except you can use regular expressions.
# def find_all_regex(sCOMMAND)
# array = Array.new()
# search =/#{sCOMMAND}/
# @commands.each do |command|
# if (command.commandName.match(search) )
# array.push(command)
# end
#
# end
# return array
# end
#
# # Find a matching keyword value pair in from an array of commands.
# # Example:
# # find_keyword_value(building.commands, "TYPE", "CONDITIONED") will return
# # all the commands that have the
# # TYPE = CONDITIONED"
# # Keyword pair.
# def search_by_keyword_value( keyword, value)
# returnarray = Array.new()
# @commands.each do |command|
# if ( command.keywordPairs[keyword] == value )
# returnarray.push(command)
# end
# end
# return returnarray
# end
#
#
# # Will read an input file into memory and store all the commands into the
# # commands array.
# # param filename
# # param runner
# def load_inp(filename,runner = nil)
# BTAP::runner_register("Info", "loading file:" + filename, runner)
# #Open the file.
# #puts filename
# iter = 0
#
#
# File.exist?(filename)
# f = File.open(filename, "r")
#
#
#
#
# #Read the file into an array, line by line.
# lines = f.readlines
# #Set up the temp string.
# command_string =""
#
# lines.each do|line|
# iter = iter.next
# #line.forced_encoding("US-ASCII")
# #Ignore comments (To do!...strip from file as well as in-line comments.
# if (!line.match(/\$.*/) )
#
# if (myarray = line.match(/(.*?)\.\./) )
# #Add the last part of the command to the newline...may be blank."
# command_string = command_string + myarray[1]
# #Determine correct command class to create, then populates it."
# command = DOECommandFactory.command_factory(command_string, self)
# #Push the command into the command array."
# @commands.push(command)
# command_string = ""
# else
# myarray = line.match(/(.*)/)
# command_string = command_string + myarray[1]
# end
# end
# end
#
# organize_data()
# BTAP::runner_register("Info","INP model contains:", runner)
# #report number of things read in.
# ["SPACE","ZONE","EXTERIOR-WALL","ROOF","INTERIOR-WALL","UNDERGROUND-WALL","WINDOW","DOOR","MATERIAL","CONSTRUCTION"].each do |item|
# items = self.find_all_commands(item)
# message = "\t#{item} = #{items.size}"
# BTAP::runner_register("Info",message, runner)
# end
# BTAP::runner_register("Info", "\tFinished Loading File:" + filename,runner)
# end
#
#
#
# # This will right a clean output file, meaning no comments. Good for doing
# # diffs
# def save_inp(string)
# array = @commands
# w = File.open(string, 'w')
# array.each { |command| w.print command.output }
# w.close
# end
#
#
#
#
#
# #This routine organizes the hierarchy of the space <-> zones and the polygon
# # associations that are not formally identified by the sequential relationship
# # like the floor, walls, windows. It would seem that zones and spaces are 1 to
# # one relationships. So each zone will have a reference to its space and vice versa.
# # If there is a polygon command in the space or floor definition, a reference to the
# # polygon class will be set.
# def organize_data()
# # set_envelope_hierarchy
# # This method determines the current parents of the current command.
# def determine_current_parents(new_command)
# if @last_command.nil?
# @last_command = new_command
# end
# #Check to see if scope (HVAC versus Envelope) has changed or the parent depth is undefined "0"
# if (!@parents.empty? and (new_command.doe_scope != @parents.last.doe_scope or new_command.depth == 0 ))
# @parents.clear
# end
# #no change in parent.
# if ( (new_command.depth == @last_command.depth))
# #no change
# @last_command = new_command
# #puts "#{new_command.commandName}"
# end
# #Parent depth added
# if ( new_command.depth > @last_command.depth)
# @parents.push(@last_command)
# #puts "Added parent#{@last_command.commandName}"
# @last_command = new_command
# end
# #parent depth removed.
# if ( new_command.depth < @last_command.depth)
# parent = @parents.pop
# #puts "Removed parent #{parent}"
# @last_command = new_command
# end
# array = Array.new(@parents)
# return array
# end
#
#
# @commands.each do |command|
# if command.doe_scope() == "envelope"
# #Sets parents of command.
# parents = determine_current_parents(command)
# if (!parents.empty?)
# command.parents = parents
# end
# #inserts current command into the parent's children.
# if (!command.parents.empty?)
# command.parents.last.children.push(command)
# end
# end
# end
# # Associating the polygons with the FLoor and spaces.
# polygons = find_all_commands("POLYGON")
# spaces = find_all_commands("SPACE")
# floors = find_all_commands("FLOOR")
# zones = find_all_commands("ZONE")
# ext_walls = find_all_commands("EXTERIOR-WALL")
# roof = find_all_commands("ROOF")
# door = find_all_commands("DOOR")
# int_walls = find_all_commands("INTERIOR-WALL")
# underground_walls = find_all_commands("UNDERGROUND-WALL")
# underground_floors = find_all_commands("UNDERGROUND-FLOOR")
# constructions =find_all_commands("CONSTRUCTION")
# surface_lists = [ ext_walls, roof, door, int_walls, underground_walls, underground_floors]
#
#
# #Organize surface data.
# surface_lists.each do |surfaces|
# surfaces.each do |surface|
# #Assign constructions to surface objects
# constructions.each do |construction|
# if ( construction.utype == surface.get_keyword_value("CONSTRUCTION") )
# surface.construction = construction
# end
# end
# #Find Polygons associated with surface.
# polygons.each do |polygon|
# if ( surface.check_keyword?("POLYGON") and polygon.utype == surface.get_keyword_value("POLYGON") )
# surface.polygon = polygon
# end
# end
# end
# end
#
#
#
# #Organize polygon data for space and floors.
# polygons.each do |polygon|
# #set up point list in polygon objects
# polygon.create_point_list()
# #Find Polygons associated with floor and and reference to floor.
# floors.each do |floor|
# if ( polygon.utype == floor.get_keyword_value("POLYGON") )
# floor.polygon = polygon
# end
# end
# #Find Polygons for space and add reference to the space.
# spaces.sort.each do |space|
# if space.check_keyword?("POLYGON")
# if ( polygon.utype == space.get_keyword_value("POLYGON") )
# space.polygon = polygon
# end
# end
# end
# end
#
#
#
# # Find spaces that belong to the zone.
# zones.each do |zone|
# spaces.sort.each do |space|
# if ( space.utype == zone.get_keyword_value("SPACE") )
# space.zone = zone
# zone.space = space
# end
# end
# end
# end
#
#
#
# def get_building_transformation_matrix()
# build_params = self.find_all_commands("BUILD-PARAMETERS")[0]
# building_xref = build_params.check_keyword?("X-REF")? build_params.get_keyword?("X-REF") : 0.0
# building_yref = build_params.check_keyword?("Y-REF")? build_params.get_keyword?("Y-REF") : 0.0
# building_origin = OpenStudio::Vector3d.new(building_xref,building_yref,0.0)
# building_azimuth = build_params.check_keyword?("AZIMUTH")? build_params.get_keyword?("AZIMUTH") : 0.0
# return OpenStudio::Transformation::rotation(OpenStudio::Vector3d(0.0, 0.0, 1.0), openstudio::degToRad(building_azimuth)) * OpenStudio::Transformation::translation(building_origin)
# end
#
#
#
#
# #this method will convert a DOE inp file to the OSM file.. This will return
# # and openstudio model object.
# def create_openstudio_model_new(runner = nil)
# beginning_time = Time.now
#
# end_time = Time.now
# BTAP::runner_register("Info", "Time elapsed #{(end_time - beginning_time)*1000} milliseconds",runner)
# model = OpenStudio::Model::Model.new()
# #add All Materials
# # find_all_commands( "Materials" ).each do |doe_material|
# # end
# #
# # find_all_commands( "Constructions" ).each do |doe_cons|
# # end
#
# #this block will create OS story objects in the OS model.
# BTAP::runner_register("Info", "Exporting DOE FLOORS to OS",runner)
# find_all_commands("FLOOR").each do |doe_floor|
# doe_floor.convert_to_openstudio(model)
# end
# BTAP::runner_register("Info", OpenStudio::Model::getBuildingStorys(model).size.to_s + " floors created",runner)
#
# #this block will create OS space objects in the OS model.
# BTAP::runner_register("Info", "Exporting DOE SPACES to OS",runner)
# find_all_commands("SPACE").each do |doe_space|
# doe_space.convert_to_openstudio(model)
# end
# BTAP::runner_register("Info", OpenStudio::Model::getSpaces(model).size.to_s + " spaces created",runner)
#
# #this block will create OS space objects in the OS model.
# BTAP::runner_register("Info", "Exporting DOE ZONES to OS",runner)
# find_all_commands("ZONE").each do |doe_zone|
# doe_zone.convert_to_openstudio(model)
# end
# BTAP::runner_register("Info", OpenStudio::Model::getThermalZones(model).size.to_s + " zones created",runner)
#
# #this block will create OS surface objects in the OS model.
# BTAP::runner_register("Info", "Exporting DOE Surfaces to OS",runner)
# all_surfaces = Array.new()
# @commands.each do |command|
# case command.commandName
# when "EXTERIOR-WALL","INTERIOR-WALL","UNDERGROUND-WALL","ROOF"
# all_surfaces.push(command)
# end
# end
# all_surfaces.each do |doe_surface|
# doe_surface.convert_to_openstudio(model)
# end
# BTAP::runner_register("Info", OpenStudio::Model::getSurfaces(model).size.to_s + " surfaces created",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getSubSurfaces(model).size.to_s + " sub_surfaces created",runner)
# BTAP::runner_register("Info", "Setting Boundary Conditions for surfaces",runner)
# BTAP::Geometry::match_surfaces(model)
#
# x_scale = y_scale = z_scale = 0.3048
# BTAP::runner_register("Info", "scaling model from feet to meters",runner)
# model.getPlanarSurfaces.sort.each do |surface|
# new_vertices = OpenStudio::Point3dVector.new
# surface.vertices.each do |vertex|
# new_vertices << OpenStudio::Point3d.new(vertex.x * x_scale, vertex.y * y_scale, vertex.z * z_scale)
# end
# surface.setVertices(new_vertices)
# end
#
# model.getPlanarSurfaceGroups.sort.each do |surface_group|
# transformation = surface_group.transformation
# translation = transformation.translation
# euler_angles = transformation.eulerAngles
# new_translation = OpenStudio::Vector3d.new(translation.x * x_scale, translation.y * y_scale, translation.z * z_scale)
# #TODO these might be in the wrong order
# new_transformation = OpenStudio::createRotation(euler_angles) * OpenStudio::createTranslation(new_translation)
# surface_group.setTransformation(new_transformation)
# end
# BTAP::runner_register("Info", "DOE2.2 -> OS Geometry Conversion Complete",runner)
# BTAP::runner_register("Info", "Summary of Conversion",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getBuildingStorys(model).size.to_s + " floors created",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getSpaces(model).size.to_s + " spaces created",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getThermalZones(model).size.to_s + " thermal zones created",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getSurfaces(model).size.to_s + " surfaces created",runner)
# BTAP::runner_register("Info", OpenStudio::Model::getSubSurfaces(model).size.to_s + " sub_surfaces created",runner)
# BTAP::runner_register("Info", "No Contruction were converted.",runner)
# BTAP::runner_register("Info", "No Materials were converted",runner)
# BTAP::runner_register("Info", "No HVAC components were converted",runner)
# BTAP::runner_register("Info", "No Environment or Simulation setting were converted.",runner)
#
# end_time = Time.now
# BTAP::runner_register("Info", "Time elapsed #{(end_time - beginning_time)} seconds",runner)
# return model
# end
#
#
#
#
#
# def get_materials()
# BTAP::runner_register("Info", "Spaces",runner)
# find_all_commands("SPACE").each do |space|
# BTAP::runner_register("Info", space.get_azimuth(),runner)
# end
# BTAP::runner_register("Info", "Materials",runner)
# find_all_commands("MATERIAL").each do |materials|
# BTAP::runner_register("Info", materials.get_name(),runner)
# end
# BTAP::runner_register("Info", "Layers",runner)
# find_all_commands("LAYERS").each do |materials|
# BTAP::runner_register("Info", materials.get_name(),runner)
# end
# BTAP::runner_register("Info", "Constructions",runner)
# find_all_commands("CONSTRUCTION").each do |materials|
# BTAP::runner_register("Info", materials.get_name(),runner)
# end
#
# end
#
#
# end
# # This class will manage all the layer information of the Reference components.
# class LayerManager
# include Singleton
# class Layer
#
# attr_accessor :name
# attr_accessor :thickness
# attr_accessor :conductivity
# attr_accessor :density
# attr_accessor :specific_heat
# attr_accessor :air_space
# attr_accessor :resistance
# def initialize
# @air_space = false
# end
#
# def set( thickness, conductivity, density, specific_heat)
# @thickness, @conductivity, @density, @specific_heat = thickness, conductivity, density, specific_heat
# @airspace = false
# end
#
# def set_air_space(thickness, resistance)
# @thickness, @resistance = thickness, resistance
# @air_space = true
# end
#
# def output
# string = "Airspace = #{@air_space}\nThickness = #{@thickness}\nConductivity = #{@conductivity}\nResistance = #{@resistance}\nDensity = #{@density}\nSpecificHeat = #{@specific_heat}\n"
# end
# end
# # Array of all the layers
# attr_accessor :layers
# def initialize
# @layers = Array.new()
# end
#
# #Add a layer. If the layer already exists. It will return the exi
# def add_layer(new_layer)
# #first determine if the layer already exists.
# @layers.each do |current_layer|
# if new_layer == current_layer
# return current_layer
# end
# end
# @layers.push(new_layer)
# return @layers.last()
# end
#
# private
#
# def clear()
# @layers.clear()
# end
# end
# #This class manages all of the constructions that are used in the simulation. It
# #should remove any constructions that are doubly defined in the project.
# class ConstructionManager
# # An array containing all the constructions.
# attr_accessor :constructions
#
# # The layer manager all the constructions.
# attr_accessor :layer_manager
# class Construction
#
# #The unique name for the construction.
# attr_accessor :name
# #The array which contains the material layers of the construction.
# attr_accessor :layers
#
# def initialize
# #Set up the array for the layers.
# @layers = Array.new()
# end
#
# #Adds a layer object to the construction.
# # Must pass a Layer object as an arg.
# def add_layer_object( object )
# layers.push( object )
# end
#
# #Adds a layer based on the physical properties list.
# #All units are based on the simulators input.
# def add_layer(thickness, conductivity, density, specific_heat)
# layer = Layer.new()
# # Make sure all the values are > 0.
# layer.set(thickness, conductivity, density, specific_heat)
# @layers.push(layer)
# end
#
# # Adds an airspace to the construction based on the thickness and Resistances.
# #All units are based on the simulators input.
# def add_air_space(thickness, resistance )
# layer = Layer.new()
# layer.set_air_space(thickness, resistance)
# @layers.push(layer)
# end
#
# def output()
# soutput = ""
# @layers.each do|layer|
# soutput = soutput + layer.output() + "\n"
# end
# soutput
# end
# end
#
#
# def initialize
# @constructions = Array.new()
# @layer_manager = LayerManager.instance()
# end
#
#
# #Adds a new construction to the construction array.
# #Arg must be a construction object.
# def add_construction(new_construction)
# #first determine if the layer already exists.
# @constructions.each do |current_construction|
# if new_construction == current_construction
# return current_construction
# end
# end
# new_construction.layers.each do |new_layer|
# #If the new layer already exists...use the old one instead.
# # it is the layerManager's job to decide this.
# new_layer = @layer_manager.add_layer(new_layer)
# end
# @constructions.push(new_construction)
# return @constructions.last()
# end
#
# def clear()
# @constructions.clear()
# @layer_manager.clear()
# end
#
# end
# end
# end
#