def to_dict(self):
d = {}
d.update( {'quantity':self.quantity} )
d.update( {'_tolerance':self._tolerance} )
d.update( {'aperture':self.aperture.to_dict()} )
d.update( {'_shading_factor_winter':self._shading_factor_winter } )
d.update( {'_shading_factor_summer':self._shading_factor_summer} )
d.update( {'install_depth':self.install_depth} )
d.update( {'variant_type':self.variant_type} )
_edges = {}
for k, v in self.window_edges._asdict().iteritems():
_edges.update( {k:v.to_dict()} )
d.update( {'_window_edges':_edges} )
d.update( {'_glazing_edge_lengths':self.glazing_edge_lengths})
_glazing_srfc = to_face3d(self.glazing_surface)
if _glazing_srfc:
d.update( {'_glazing_surface':_glazing_srfc[0].to_dict()} )
if self.frame:
d.update( {'_frame':self.frame.to_dict()} )
if self.glazing:
d.update( {'_glazing':self.glazing.to_dict()} )
if self.installs:
d.update( {'_installs':self.installs.to_dict()} )
if self.shading_dimensions:
d.update( {'shading_dimensions':self.shading_dimensions.to_dict() } )
return d
def inset_LBT_Face3d(_face3d, _inset_dist=0.001):
rhino_geom = from_face3d(_face3d)
rhino_geom_inset = inset_rhino_surface(rhino_geom, _inset_dist)
lbt_face3d = to_face3d(rhino_geom_inset)
if lbt_face3d:
return lbt_face3d[0]
else:
return None
def to_dict(self):
d = {}
d.update( {'id':self.id} )
d.update( {'space_number':self.space_number} )
d.update( {'space_name':self.space_name} )
d.update( {'host_room_name':self.host_room_name} )
d.update( {'params':self.params} )
d.update( {'area_gross':self.area_gross} )
d.update( {'depth':self.depth} )
if self.surface:
# Remeber, to_face3d returns a LIST of surfaces incase it triangulates
# so for now, just getitng the first one in that list to pass along
# Someday this'll break everything...
lbt_surface = to_face3d(self.surface)
d.update( {'surface_list': lbt_surface[0].to_dict() } )
return d
except ImportError as e:
raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
try:
from ladybug_rhino.config import conversion_to_meters
from ladybug_rhino.togeometry import to_joined_gridded_mesh3d, to_face3d, \
to_vector3d
from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d
from ladybug_rhino.grasshopper import all_required_inputs, hide_output
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component) and _run:
# set the default offset distance
_height_limit_ = _height_limit_ if _height_limit_ is not None \
else 100 / conversion_to_meters()
# convert geometry, objstacles, and vectors to ladybug_geomtery
study_mesh = to_joined_gridded_mesh3d(_geometry, _grid_size)
obstacle_faces = [g for geo in _obstacles for g in to_face3d(geo)]
sun_vectors = [to_vector3d(vec) for vec in _vectors]
# compute the solar envelope
solar_obj = SolarEnvelope(
study_mesh, obstacle_faces, sun_vectors, _height_limit_, solar_rights_)
lb_mesh = solar_obj.envelope_mesh()
mesh = from_mesh3d(lb_mesh)
points = [from_point3d(pt) for pt in lb_mesh.vertices]
hide_output(ghenv.Component, 1)
from ladybug_rhino.grasshopper import all_required_inputs, longest_list, \
document_counter
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# duplicate the initial objects and process the construction
rooms = [room.duplicate() for room in _rooms]
if isinstance(_construction, str):
_construction = opaque_construction_by_identifier(_construction)
# determine whether the input _geo_or_area is geometry or floats
try:
areas = [float(num) for num in _geo_or_area]
except AttributeError: # assume that the input is a list of geometry
geo = [f for geo in _geo_or_area for f in to_face3d(geo)]
conversion = conversion_to_meters()**2
areas = [0 for room in rooms]
for i, room in enumerate(rooms):
for face in geo:
if room.geometry.is_point_inside(face.center):
areas[i] += face.area * conversion
# create the internal mass objects and assign them to the rooms
for i, room in enumerate(rooms):
area = longest_list(areas, i)
if area != 0:
if len(_name_) == 0: # make a default Room name
display_name = 'Internal Mass {}'.format(
document_counter('mass_count'))
else:
except ImportError as e:
raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
try:
from ladybug_rhino.togeometry import to_gridded_mesh3d, to_mesh3d, \
to_face3d, to_vector3d
from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d, from_vector3d
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# check the input and generate the mesh.
_offset_dist_ = _offset_dist_ or 0
if quad_only_: # use Ladybug's built-in meshing methods
lb_faces = to_face3d(_geometry)
try:
x_axis = to_vector3d(quad_only_)
lb_faces = [
Face3D(f.boundary, Plane(f.normal, f[0], x_axis), f.holes)
for f in lb_faces
]
except AttributeError:
pass # no plane connected; juse use default orientation
lb_meshes = [
geo.mesh_grid(_grid_size, offset=_offset_dist_) for geo in lb_faces
]
if len(lb_meshes) == 1:
lb_mesh = lb_meshes[0]
elif len(lb_meshes) > 1:
lb_mesh = Mesh3D.join_meshes(lb_meshes)
if len(_program_) != 0:
raise ValueError('_program_ has been specified but dragonfly-energy '
'has failed to import.\n{}'.format(e))
elif len(_constr_set_) != 0:
raise ValueError(
'_constr_set_ has been specified but dragonfly-energy '
'has failed to import.\n{}'.format(e))
elif len(conditioned_) != 0:
raise ValueError(
'conditioned_ has been specified but dragonfly-energy '
'has failed to import.\n{}'.format(e))
if all_required_inputs(ghenv.Component):
room2d = [] # list of room2ds that will be returned
face3ds = [face for geo in _geo
for face in to_face3d(geo)] # convert to lb geo
for i, geo in enumerate(face3ds):
# get the name for the Room2D
if len(_name_) == 0: # make a default Room2D name
display_name = 'Room_{}'.format(document_counter('room_count'))
else:
display_name = '{}_{}'.format(longest_list(_name_, i), i + 1) \
if len(_name_) != len(face3ds) else longest_list(_name_, i)
name = clean_and_id_string(display_name)
# create the Room2D
room = Room2D(name,
geo,
longest_list(_flr_to_ceiling, i),
tolerance=tolerance)
room.display_name = display_name
raise ValueError('rad_mod_ has been specified but honeybee-radiance '
'has failed to import.\n{}'.format(e))
if all_required_inputs(ghenv.Component):
shades = [] # list of shades that will be returned
for j, geo in enumerate(_geo):
if len(_name_) == 0: # make a default Shade name
name = display_name = clean_and_id_string('Shade')
else:
display_name = '{}_{}'.format(longest_list(_name_, j), j + 1) \
if len(_name_) != len(_geo) else longest_list(_name_, j)
name = clean_and_id_string(display_name)
is_detached = not longest_list(attached_,
j) if len(attached_) != 0 else True
lb_faces = to_face3d(geo)
for i, lb_face in enumerate(lb_faces):
shd_name = '{}_{}'.format(name, i) if len(lb_faces) > 1 else name
hb_shd = Shade(shd_name, lb_face, is_detached)
hb_shd.display_name = display_name
# try to assign the energyplus construction
if len(ep_constr_) != 0:
ep_constr = longest_list(ep_constr_, j)
if isinstance(ep_constr, str):
ep_constr = shade_construction_by_identifier(ep_constr)
hb_shd.properties.energy.construction = ep_constr
# try to assign the energyplus transmittance schedule
if len(ep_trans_sch_) != 0:
ep_trans_sch = longest_list(ep_trans_sch_, j)
try: # import ladybug_rhino dependencies
from ladybug_rhino.grasshopper import all_required_inputs
from ladybug_rhino.togeometry import to_mesh3d, to_face3d
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# set the default name and process the points to tuples
name = clean_and_id_rad_string('SensorGrid') if _name_ is None else _name_
pts = [(pt.X, pt.Y, pt.Z) for pt in _positions]
# create the sensor grid object
id = clean_rad_string(name) if '/' not in name else clean_rad_string(
name.split('/')[0])
if len(_directions_) == 0:
grid = SensorGrid.from_planar_positions(id, pts, (0, 0, 1))
else:
vecs = [(vec.X, vec.Y, vec.Z) for vec in _directions_]
grid = SensorGrid.from_position_and_direction(id, pts, vecs)
# set the display name
if _name_ is not None:
grid.display_name = _name_
if '/' in name:
grid.group_identifier = \
'/'.join(clean_rad_string(key) for key in name.split('/')[1:])
if mesh_ is not None:
grid.mesh = to_mesh3d(mesh_)
if base_geo_ is not None:
grid.base_geometry = to_face3d(base_geo_)
perim_offset_ = 0 if perim_offset_ is None else perim_offset_
buildings = [] # list of buildings that will be returned
for i, geo in enumerate(_footprint_geo):
# get the name for the Building
if len(_name_) == 0: # make a default Building name
display_name = 'Building_{}'.format(document_counter('bldg_count'))
name = clean_and_id_string(display_name)
else:
display_name = '{}_{}'.format(longest_list(_name_, i), i + 1) \
if len(_name_) != len(_footprint_geo) else longest_list(_name_, i)
name = clean_string(display_name)
# create the Building
building = Building.from_footprint(
name,
footprint=to_face3d(geo),
floor_to_floor_heights=_floor_to_floor,
perimeter_offset=perim_offset_,
tolerance=tolerance)
building.display_name = display_name
# assign the program
if len(_program_) != 0:
program = longest_list(_program_, i)
if isinstance(program, str):
program = program_type_by_identifier(program)
building.properties.energy.set_all_room_2d_program_type(program)
else: # generic office program by default
try:
building.properties.energy.set_all_room_2d_program_type(
office_program)
_rooms: Honeybee Rooms which will have their Face boundary conditions set
based on their spatial relation to the _ground geometry below.
_ground: Rhino Breps or Meshes that represent the Ground.
Returns:
rooms: The input Rooms with their Ground boundary conditions set.
"""
ghenv.Component.Name = 'HB Custom Ground'
ghenv.Component.NickName = 'CustomGround'
ghenv.Component.Message = '1.2.1'
ghenv.Component.Category = 'Honeybee'
ghenv.Component.SubCategory = '0 :: Create'
ghenv.Component.AdditionalHelpFromDocStrings = '0'
try: # import the ladybug_rhino dependencies
from ladybug_rhino.config import tolerance, angle_tolerance
from ladybug_rhino.togeometry import to_face3d
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
rooms = [room.duplicate() for room in _rooms] # duplicate to avoid editing input
ground_faces = [g for geo in _ground for g in to_face3d(geo)] # convert to lb geometry
# loop through the rooms and set the ground boundary conditions
for room in rooms:
room.ground_by_custom_surface(ground_faces, tolerance, angle_tolerance)
ghenv.Component.NickName = 'Terrain'
ghenv.Component.Message = '1.2.0'
ghenv.Component.Category = 'Dragonfly'
ghenv.Component.SubCategory = '4 :: AlternativeWeather'
ghenv.Component.AdditionalHelpFromDocStrings = '2'
try: # import the dragonfly_uwg dependencies
from dragonfly_uwg.terrain import Terrain
except ImportError as e:
raise ImportError('\nFailed to import dragonfly_uwg:\n\t{}'.format(e))
try:
from ladybug_rhino.togeometry import to_face3d
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# process the input geometry
geo = [face for rh_geo in _terrain_geo for face in to_face3d(rh_geo)]
# assign default values for the pvement properties
_albedo_ = _albedo_ if _albedo_ is not None else 0.1
_thickness_ = _thickness_ if _thickness_ is not None else 0.5
_conductivity_ = _conductivity_ if _conductivity_ is not None else 1.0
_vol_heat_cap_ = _vol_heat_cap_ if _vol_heat_cap_ is not None else 1.6e6
# create the terrain
terrain = Terrain(geo, _albedo_, _thickness_, _conductivity_,
_vol_heat_cap_)
def polygon_to_brep(polygon, z_height):
"""Convert a ladybug Polygon2D or list of polygon2D into Rhino breps."""
if isinstance(polygon, list): # face with holes
verts = []
for poly in polygon:
verts.append([Point3D(pt.x, pt.y, z_height) for pt in poly])
return from_face3d(Face3D(verts[0], holes=verts[1:]))
else:
verts = [Point3D(pt.x, pt.y, z_height) for pt in polygon]
return from_face3d(Face3D(verts))
if all_required_inputs(ghenv.Component):
# first extract the straight skeleton from the geometry
polyskel, boundaries, hole_polygons = [], [], []
for face in to_face3d(_floor_geo):
# convert the input geometry into Polygon2D for straight skeleton analysis
boundary = Polygon2D.from_array([(pt.x, pt.y) for pt in face.boundary])
if boundary.is_clockwise:
boundary = boundary.reverse()
holes, z_height = None, face[0].z
if face.has_holes:
holes = []
for hole in face.holes:
h_poly = Polygon2D.from_array([(pt.x, pt.y) for pt in hole])
if not h_poly.is_clockwise:
h_poly = h_poly.reverse()
holes.append(h_poly)
boundaries.append(boundary)
hole_polygons.append(holes)
# compute the skeleton and convert to line segments
display_name = '{}_{}'.format(longest_list(_name_, i), i + 1) \
if len(_name_) != len(_bldg_geo) else longest_list(_name_, i)
name = clean_string(display_name)
# interpret the input _floor_to_floor information
min, max = geo_min_max_height(geo)
floor_heights, interpreted_f2f = interpret_floor_height_subdivide(
_floor_to_floor, max, min)
# get the floor geometries of the building
floor_breps = split_solid_to_floors(geo, floor_heights)
floor_faces = []
for flr in floor_breps:
story_faces = []
for rm_face in flr:
story_faces.extend(to_face3d(rm_face))
floor_faces.append(story_faces)
# create the Building
building = Building.from_all_story_geometry(
name, floor_faces, floor_to_floor_heights=interpreted_f2f,
perimeter_offset=perim_offset_, tolerance=tolerance)
building.display_name = display_name
# assign the program
if len(_program_) != 0:
program = longest_list(_program_, i)
if isinstance(program, str):
program = program_type_by_identifier(program)
building.properties.energy.set_all_room_2d_program_type(program)
else: # generic office program by default
if all_required_inputs(ghenv.Component) and _run:
perim_offset_ = 0 if perim_offset_ is None else perim_offset_
buildings = [] # list of buildings that will be returned
for i, geo in enumerate(_footprint_geo):
# get the name for the Building
if len(_name_) == 0: # make a default Building name
display_name = 'Building_{}'.format(document_counter('bldg_count'))
name = clean_and_id_string(display_name)
else:
display_name = '{}_{}'.format(longest_list(_name_, i), i + 1) \
if len(_name_) != len(_footprint_geo) else longest_list(_name_, i)
name = clean_string(display_name)
# create the Building
building = Building.from_footprint(
name, footprint=to_face3d(geo), floor_to_floor_heights=_floor_to_floor,
perimeter_offset=perim_offset_, tolerance=tolerance)
building.display_name = display_name
# assign the program
if len(_program_) != 0:
program = longest_list(_program_, i)
if isinstance(program, str):
program = program_type_by_identifier(program)
building.properties.energy.set_all_room_2d_program_type(program)
else: # generic office program by default
try:
building.properties.energy.set_all_room_2d_program_type(office_program)
except (NameError, AttributeError):
pass # honeybee-energy is not installed
from honeybee.typing import clean_and_id_rad_string, clean_rad_string
except ImportError as e:
raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
try:
from honeybee_radiance.dynamic import StateGeometry
except ImportError as e:
raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
try: # import the ladybug_rhino dependencies
from ladybug_rhino.togeometry import to_face3d
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
geo = [] # list of geometries that will be returned
# set default name
name = clean_and_id_rad_string('StateGeo') if _name_ is None \
else clean_and_id_rad_string(_name_)
# create the StateGeometry
i = 0 # iterator to ensure each geometry gets a unique name
for rh_geo in _geo:
for lb_face in to_face3d(rh_geo):
hb_geo = StateGeometry('{}_{}'.format(name, i), lb_face, _modifier_)
if _name_ is not None:
hb_geo.display_name = _name_
geo.append(hb_geo)
'has failed to import.\n{}'.format(e))
if all_required_inputs(ghenv.Component):
context = [] # list of context shades that will be returned
for i, geo in enumerate(_geo):
# get the name for the ContextShade
if len(_name_) == 0: # make a default name
display_name = 'Context_{}'.format(document_counter('context_count'))
else:
display_name = '{}_{}'.format(longest_list(_name_, i), i + 1) \
if len(_name_) != len(_geo) else longest_list(_name_, i)
name = clean_and_id_string(display_name)
# create the ContextShade object
df_shd = ContextShade(name, to_face3d(geo))
df_shd.display_name = display_name
# try to assign the energyplus construction
if len(ep_constr_) != 0:
ep_constr = longest_list(ep_constr_, i)
if isinstance(ep_constr, str):
ep_constr = shade_construction_by_identifier(ep_constr)
df_shd.properties.energy.construction = ep_constr
# try to assign the energyplus transmittance schedule
if len(ep_trans_sch_) != 0:
ep_trans_sch = longest_list(ep_trans_sch_, i)
if isinstance(ep_trans_sch, str):
ep_trans_sch = schedule_by_identifier(ep_trans_sch)
df_shd.properties.energy.transmittance_schedule = ep_trans_sch
raise ValueError('ep_constr_ has been specified but honeybee-energy '
'has failed to import.\n{}'.format(e))
try: # import the honeybee-radiance extension
from honeybee_radiance.lib.modifiers import modifier_by_identifier
except ImportError as e:
if rad_mod_ is None:
raise ValueError('rad_mod_ has been specified but honeybee-radiance '
'has failed to import.\n{}'.format(e))
if all_required_inputs(ghenv.Component):
# process the inputs
rooms = [room.duplicate()
for room in _rooms] # duplicate to avoid editing input
guide_faces = [g for geo in _guide
for g in to_face3d(geo)] # convert to lb geometry
if type_ is not None and type_ not in face_types:
type_ = face_types.by_name(type_)
if bc_ is not None and bc_ not in boundary_conditions:
bc_ = boundary_conditions.by_name(bc_)
if isinstance(ep_constr_, str):
ep_constr_ = opaque_construction_by_identifier(ep_constr_)
if isinstance(rad_mod_, str):
rad_mod_ = modifier_by_identifier(rad_mod_)
# loop through the rooms and set the face properties
for room in rooms:
select_faces = room.faces_by_guide_surface(
guide_faces, tolerance=tolerance, angle_tolerance=angle_tolerance)
for hb_face in select_faces:
if type_ is not None: