def add_temperatures(t_start, t_end, fluid_type, coolprop_fluid, pressure, t_init=273.15): """ Add new temperature with associated heat capacity and viscosity :return: None """ with rpw.db.Transaction("Add temperatures"): for i in xrange(t_start, t_end + 1): # Call CoolProp to get fluid properties and convert it to internal units if necessary temperature = t_init + i viscosity = UnitUtils.ConvertToInternalUnits( PropsSI('V', 'T', temperature, 'P', pressure, coolprop_fluid), DisplayUnitType.DUT_PASCAL_SECONDS) density = UnitUtils.ConvertToInternalUnits(PropsSI('D', 'T', temperature, 'P', pressure, coolprop_fluid), DisplayUnitType.DUT_KILOGRAMS_PER_CUBIC_METER) logger.debug('ν={}, ρ={}'.format(viscosity, density)) # Catching exceptions and trying to overwrite temperature if asked by user in the TaskDialog try: fluid_type.AddTemperature(FluidTemperature(temperature, viscosity, density)) except Exceptions.ArgumentException: result = TaskDialog.Show("Error", "Temperature already exist, do you want to overwrite it ?", TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No | TaskDialogCommonButtons.Cancel, TaskDialogResult.Yes) if result == TaskDialogResult.Yes: try: fluid_type.RemoveTemperature(temperature) fluid_type.AddTemperature(FluidTemperature(temperature, viscosity, density)) except Exceptions.ArgumentException: TaskDialog.Show("Overwrite error", "Temperature is currently in use and cannot be overwritten") elif result == TaskDialogResult.No: pass else: break
def move_element_schedule(scheduleview_port, view, value_x, value_y): bb_vp = scheduleview_port.get_BoundingBox(view) if bb_vp: x = UnitUtils.ConvertToInternalUnits(value_x, DisplayUnitType.DUT_MILLIMETERS) y = UnitUtils.ConvertToInternalUnits(value_y, DisplayUnitType.DUT_MILLIMETERS) new_x = x - bb_vp.Max.X - bb_vp.Min.X pt3 = XYZ(new_x, y, 0) point = ElementTransformUtils.MoveElement(doc, scheduleview_port.Id, pt3) return point
def create_assets(self, revit_material, layer): doc = self.doc layer_name = self.layer_name country = self.country thermal_asset = ThermalAsset(layer_name, ThermalMaterialType.Solid) structural_asset = StructuralAsset(layer_name, StructuralAssetClass.Basic) thermal = utils.get_by_country(layer.thermal, country) physical = utils.get_by_country(layer.physical, country) density = getattr(physical, "density", 0) if density: thermal_asset.Density = ( structural_asset.Density) = UnitUtils.ConvertToInternalUnits( density, get_density_unit(), ) thermal_asset.Porosity = getattr(physical, "Porosity", 0) or 0 specific_heat_capacity = (getattr(thermal, "therm_capa", 0) or 0) * 3600 if specific_heat_capacity: thermal_asset.SpecificHeat = UnitUtils.ConvertToInternalUnits( specific_heat_capacity, get_heat_capacity_unit(), ) thermal_conductivity = getattr(thermal, "lambda_value", 0) or 0 if thermal_conductivity: thermal_asset.ThermalConductivity = UnitUtils.ConvertToInternalUnits( thermal_conductivity, get_conductivity_unit(), ) # Create thermal and structural property sets thermal_property_set = PropertySetElement.Create(doc, thermal_asset) structural_property_set = PropertySetElement.Create( doc, structural_asset) thermal_property_set.get_Parameter( BuiltInParameter.PROPERTY_SET_DESCRIPTION).Set(self.description) structural_property_set.get_Parameter( BuiltInParameter.PROPERTY_SET_DESCRIPTION).Set(self.description) thermal_property_set.get_Parameter( BuiltInParameter.MATERIAL_ASSET_PARAM_SOURCE_URL).Set(self.url) structural_property_set.get_Parameter( BuiltInParameter.MATERIAL_ASSET_PARAM_SOURCE_URL).Set(self.url) thermal_property_set.get_Parameter( BuiltInParameter.MATERIAL_ASSET_PARAM_SOURCE).Set( "materialsdb.org") structural_property_set.get_Parameter( BuiltInParameter.MATERIAL_ASSET_PARAM_SOURCE).Set( "materialsdb.org") # Assign thermal and structural property sets to material revit_material.SetMaterialAspectByPropertySet(MaterialAspect.Thermal, thermal_property_set.Id) revit_material.SetMaterialAspectByPropertySet( MaterialAspect.Structural, structural_property_set.Id)
def convert_cm_to_feet(length): """Function to convert cm to feet.""" rvt_year = int(app.VersionNumber) # RVT >= 2022 if rvt_year < 2022: from Autodesk.Revit.DB import DisplayUnitType return UnitUtils.Convert(length, DisplayUnitType.DUT_CENTIMETERS, DisplayUnitType.DUT_DECIMAL_FEET) # RVT >= 2022 else: from Autodesk.Revit.DB import UnitTypeId return UnitUtils.ConvertToInternalUnits(length, UnitTypeId.Centimeters)
def get_layers_to_string(structure_element, element_param_name, material_param_name, base=''): element_type = doc.GetElement(structure_element.GetTypeId()) element_param = element_type.LookupParameter(element_param_name) if element_param: structure = element_type.GetCompoundStructure() variable_layer_index = structure.VariableLayerIndex max_point = get_max_slab_shape_vertex(structure_element) layers = structure.GetLayers() data = '' for i in range(0, len(layers)): width = to_int(UnitUtils.ConvertFromInternalUnits(layers[i].Width, DisplayUnitType.DUT_MILLIMETERS)) name = get_material_name(layers[i].MaterialId, material_param_name).capitalize() if not name: name = 'Value_is_missing' is_variable_layer = layers[i].LayerId == variable_layer_index if width != 0 and not is_variable_layer or isinstance(max_point, str): data += '\r\n{}. {} - {} мм'.format(i + 1, name, width) elif is_variable_layer and not isinstance(max_point, str): total_width = to_int(width + max_point) data += '\r\n{}. {} - от {}-{} мм'.format(i + 1, name, width, total_width) else: data += '\r\n{}. {}'.format(i + 1, name) if base: data += '\r\n{}. {}'.format(len(layers) + 1, base) if element_param.StorageType == StorageType.String: element_param.Set(data.strip()) return data.strip()
def unit_conversion(): """Convert Revit units to Dynamo Units.""" doc = DocumentManager.Instance.CurrentDBDocument doc_units = doc.GetUnits() length_unit = doc_units.GetFormatOptions(UnitType.UT_Length).DisplayUnits return UnitUtils.ConvertFromInternalUnits(1.0, length_unit)
def set_value_by_param_name(elem, parameter_name, value): param = elem.LookupParameter(parameter_name) if param: if param.StorageType == StorageType.String: val = UnitUtils.ConvertFromInternalUnits(value, DisplayUnitType.DUT_SQUARE_METERS) param.Set(str(val)) elif param.StorageType == StorageType.Double: param.Set(value)
def get_max_slab_shape_vertex(structure_element): if structure_element.Category.Id.IntegerValue == -2000032: slab_shape_editor = structure_element.SlabShapeEditor if slab_shape_editor: slab_shape_vertices = slab_shape_editor.SlabShapeVertices point_z = [vertice.Position.Z for vertice in slab_shape_vertices] return UnitUtils.ConvertFromInternalUnits(max(point_z), DisplayUnitType.DUT_MILLIMETERS) else: return 'no shape editor'
def Convert_length(length): """ convert length To Internal Units \n Converts a value from a given display unit to Revit's internal units. """ # retrieve unit display current in revit unit_format_options = doc.GetUnits().GetFormatOptions(UnitType.UT_Length) display_unit = unit_format_options.DisplayUnits return UnitUtils.ConvertToInternalUnits(float(length), display_unit)
def around_axis_click(self, sender, e): try: rotate_elements.angles = UnitUtils.ConvertToInternalUnits( float(self.rotation_angle.Text), angle_unit) rotate_elements.selection = uidoc.Selection.GetElementIds() except ValueError: self.warning.Text = "Incorrect angles, input format required '0.0'" else: customizable_event.raise_event(rotate_elements.around_axis)
def cutElements(col, paramName, value): # Получение список плиток меньше значения value из paramName result = [] for i in col: para = i.LookupParameter(paramName) if para: param_value = round(UnitUtils.ConvertFromInternalUnits(para.AsDouble(), para.DisplayUnitType)) if param_value < value: result.append(i) return result
def set_unit(val): '''display given value with the conversion variables on top ''' val_out = None try: val_out = UnitUtils.Convert(val, USER_UNIT_IN, USER_UNIT_OUT) except: val_out = val return val_out
def set_parameter_by_name(value, param_name, document): f_manager = document.FamilyManager if len(list(f_manager.Types)) == 0: f_manager.NewType('Тип 1') param = f_manager.get_Parameter(param_name) if param: if param.CanAssignFormula: val = UnitUtils.ConvertFromInternalUnits(value, param.DisplayUnitType) f_manager.SetFormula(param, str(val)) return '{} - {}'.format(param_name, val) else: return 'Not OK'
def around_itself_click(self, sender, e): try: rotate_elements.selection = uidoc.Selection.GetElementIds() angles = [self.x_axis.Text, self.y_axis.Text, self.z_axis.Text] internal_angles = [ UnitUtils.ConvertToInternalUnits(float(i), angle_unit) for i in angles ] rotate_elements.angles = internal_angles except ValueError: self.warning.Text = "Incorrect angles, input format required '0.0'" else: self.warning.Text = "" customizable_event.raise_event(rotate_elements.around_itself)
def get_square_from_runs_and_landings(stair): if stair.Category.Id.IntegerValue == -2000120: document = stair.Document runs_square = get_square_from_part(stair.GetStairsRuns(), document) landings_square = get_square_from_part(stair.GetStairsLandings(), document) if runs_square: set_value(stair, IN[1], runs_square) # noqa value_runs = UnitUtils.ConvertFromInternalUnits( runs_square, DisplayUnitType.DUT_SQUARE_METERS) else: set_value(stair, IN[1], 0) # noqa value_runs = 'нет маршей' if landings_square: set_value(stair, IN[2], landings_square) # noqa value_landings = UnitUtils.ConvertFromInternalUnits( landings_square, DisplayUnitType.DUT_SQUARE_METERS) else: set_value(stair, IN[2], 0) # noqa value_landings = 'нет площадок' return 'Площадь ступенек: {}'.format( value_runs), 'Площадь площадок: {}'.format(value_landings) else: return 'Select stair'
def renameLevel(levels, sign=True): count = 1 TransactionManager.Instance.EnsureInTransaction(doc) for ld in levels: elev_mm = UnitUtils.ConvertFromInternalUnits( ld.Elevation, DisplayUnitType.DUT_METERS) param = ld.get_Parameter(BuiltInParameter.DATUM_TEXT) if param: if sign: name_level = "L{}(+{:.3f})".format(count, elev_mm) else: name_level = "B{}({:.3f})".format(count, elev_mm) param.Set(name_level) count += 1 TransactionManager.Instance.TransactionTaskDone()
def CreateDimensions(filledRegion, dimensionDirection): document = filledRegion.Document view = filledRegion.Document.GetElement(filledRegion.OwnerViewId) edgesDirection = dimensionDirection.CrossProduct(view.ViewDirection) edges = [] for x in FindRegionEdges(filledRegion): if IsEdgeDirectionSatisfied(x, edgesDirection): edges.append(x) if len(edges) < 2: return shift = UnitUtils.ConvertToInternalUnits( -10 * view.Scale, DisplayUnitType.DUT_MILLIMETERS) * edgesDirection dimensionLine = Line.CreateUnbound( filledRegion.get_BoundingBox(view).Min + shift, dimensionDirection) references = ReferenceArray() for edge in edges: references.Append(edge.Reference) document.Create.NewDimension(view, dimensionLine, references)
def GetBalisterCount(items, document): types = [] info = [] for item in items: param_length = item.get_Parameter(BuiltInParameter.CURVE_ELEM_LENGTH) railingType = document.GetElement(item.GetTypeId()) bp = railingType.BalusterPlacement.BalusterPattern cornerPost = railingType.BalusterPlacement.PostPattern cornerPost_el = doc.GetElement(cornerPost.CornerPost.BalusterFamilyId) info.append( UnitUtils.ConvertFromInternalUnits( bp.PatternAngle, DisplayUnitType.DUT_DEGREES_AND_MINUTES)) if bp.DistributionJustification == PatternJustification.Beginning or \ bp.DistributionJustification == PatternJustification.End: count = int(param_length.AsDouble() / bp.Length) elif bp.DistributionJustification == PatternJustification.Center: count = int(param_length.AsDouble() / bp.Length) + 2 elif bp.DistributionJustification == PatternJustification.SpreadPatternToFit: count = int(param_length.AsDouble() / bp.Length) - 2 if cornerPost_el: count += 1 types.append(count) return types, info
def import_config_length(length): return str(UnitUtils.ConvertFromInternalUnits(float(length), display_unit))
def ConvertFromInteralUnitToMM(Parameter): Parameter = UnitUtils.ConvertFromInternalUnits( float(Parameter), DisplayUnitType.DUT_MILLIMETERS) return Parameter
def Convert_length(length): Int_Length = (UnitUtils.ConvertFromInternalUnits(float(length), display_unit)) return int(round(Int_Length))
def valueParameter(param, paramName): para = param.LookupParameter(paramName) return round(UnitUtils.ConvertFromInternalUnits(para.AsDouble(), para.DisplayUnitType))
from RevitServices.Persistence import DocumentManager from RevitServices.Transactions import TransactionManager doc = DocumentManager.Instance.CurrentDBDocument # argument assigned the IN port elements = list(UnwrapElement(IN[0])) load_value = IN[1] load_type = list(UnwrapElement(IN[2])) # wrap input inside a list (if not a list) if not isinstance(load_value, list): load_value = [load_value] # output unit dut = DisplayUnitType.DUT_METERS # core data processing loads = [] TransactionManager.Instance.EnsureInTransaction(doc) for ids, (element, outer) in enumerate(zip(elements, load_value)): for inner in outer: Zaxis = UnitUtils.ConvertFromInternalUnits(inner, dut) areaload = AreaLoad.Create(doc, element, XYZ(0, 0, Zaxis), load_type[0]) loads.append(areaload) TransactionManager.Instance.ForceCloseTransaction() # return assigned the OUT port OUT = loads
def export_config_length(lenght): return str(UnitUtils.ConvertToInternalUnits(float(lenght), display_unit))
from RevitServices.Transactions import TransactionManager doc = DocumentManager.Instance.CurrentDBDocument el_fam = FilteredElementCollector(doc).OfClass(Family).ToElements() el_inst = FilteredElementCollector(doc).OfClass(FamilyInstance).ToElements() schemaGuid = System.Guid('3cd61681-a611-4a2f-b49c-ea8f0030807b') sch = Schema.Lookup(schemaGuid) fam_name = [f.Name for f in el_fam if f.GetEntity(sch).SchemaGUID == schemaGuid] el = [] param_offset_guid = System.Guid('e4793a44-6050-45b3-843e-cfb49d9191c5') param_guid = System.Guid('6ec2f9e9-3d50-4d75-a453-26ef4e6d1625') TransactionManager.Instance.EnsureInTransaction(doc) for e in el_inst: if e.Symbol.Family.Name in fam_name and e.get_Parameter(param_offset_guid): lev = UnitUtils.ConvertFromInternalUnits(e.Location.Point.Z, DisplayUnitType.DUT_MILLIMETERS) param = e.get_Parameter(param_offset_guid) param_value = UnitUtils.ConvertFromInternalUnits(param.AsDouble(), param.DisplayUnitType) if e.get_Parameter(param_guid): param_set = e.get_Parameter(param_guid) value = UnitUtils.ConvertToInternalUnits(lev + param_value, param_set.DisplayUnitType) param_set.Set(value) el.append(e) TransactionManager.Instance.TransactionTaskDone() OUT = el
def meter(double): return UnitUtils.ConvertFromInternalUnits(double, DisplayUnitType.DUT_METERS)
def convert_to_internal(value, unit="mm"): return UnitUtils.ConvertToInternalUnits( float(value), LENGTH_UNIT )
# Revit and Dynamo module from Autodesk.Revit.DB import Material, DisplayUnitType, UnitUtils from RevitServices.Persistence import DocumentManager doc = DocumentManager.Instance.CurrentDBDocument # argument assigned the IN port elements = list(UnwrapElement(IN[0])) # wrap input inside a list (if not a list) if not isinstance(elements, list): elements = [elements] # core data processing unit = DisplayUnitType.DUT_KILOGRAMS_PER_CUBIC_METER structural_asset, thermal_asset, element = [], [], [] for elem in elements: try: t1 = doc.GetElement( elem.StructuralAssetId).GetStructuralAsset().Density structural_asset.append(UnitUtils.ConvertFromInternalUnits(t1, unit)) t2 = doc.GetElement(elem.ThermalAssetId).GetThermalAsset().Density thermal_asset.append(UnitUtils.ConvertFromInternalUnits(t2, unit)) element.append(elem) except BaseException: pass # return assigned the OUT port OUT = structural_asset, thermal_asset, element
scale = v.Scale elems = FilteredElementCollector(doc, v.Id).OfClass(CurveElement) for e in elems: graphics_style_cat = e.LineStyle.GraphicsStyleCategory id_cat = graphics_style_cat.Id if BuiltInCategory(id_cat.IntegerValue) == BuiltInCategory.OST_ProfileFamilies: cat = graphics_style_cat line_length += e.GeometryCurve.Length gs = cat.GetGraphicsStyle(GraphicsStyleType.Projection) gsCat = gs.GraphicsStyleCategory gsCat.LineColor = Color(IN[1].Red, IN[1].Green, IN[1].Blue) # noqa v.Scale = 1 v.Scale = scale line_length = UnitUtils.ConvertFromInternalUnits(line_length, DisplayUnitType.DUT_MILLIMETERS) f_manager = doc.FamilyManager param_name = "_Профиль.Длина" length_param = f_manager.get_Parameter(param_name) if len(list(f_manager.Types)) == 0: f_manager.NewType('Тип 1') if length_param: if length_param.CanAssignFormula: f_manager.SetFormula(length_param, str(line_length)) OUT = "Длина профиля {}".format(round(line_length)) else: fparameter = f_manager.AddParameter( param_name, BuiltInParameterGroup.PG_DATA, ParameterType.Length, False)
lnkdoc = linkdoc[0] transform = rvtlinks[0].GetTotalTransform() rooms = FilteredElementCollector(lnkdoc).OfCategory( BuiltInCategory.OST_Rooms).ToElements() fam_col = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Furniture). \ WhereElementIsNotElementType().ToElements() mlist = [] for room in rooms: llist = [] room_box = room.get_BoundingBox(None) boxMin = transform.OfPoint(room_box.Min) boxMax = transform.OfPoint(room_box.Max) outline = Outline(boxMin, boxMax) bbfilter = BoundingBoxIntersectsFilter(outline) fam_ins = FilteredElementCollector(doc).OfCategory( BuiltInCategory.OST_Furniture).WherePasses(bbfilter).ToElements() llist.append(fam_ins) param = room.get_Parameter(BuiltInParameter.ROOM_AREA).AsDouble() llist.append( UnitUtils.ConvertFromInternalUnits(param, DisplayUnitType.DUT_SQUARE_METERS)) mlist.append(llist) flist = [] for f in fam_col: flist.append(lnkdoc.GetRoomAtPoint(f.Location.Point)) OUT = flist, fam_col