# *********************************************************************
# * 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.setAttribute("name", 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.setAttribute("name", 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.setAttribute("name", 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.setAttribute("name", 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.setAttribute("name", 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.setAttribute("name", 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.setAttribute("name", 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.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.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.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.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