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_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 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 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 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 jt_toInternalUnits(lengthValue):
return UnitUtils.ConvertToInternalUnits(
lengthValue,
Document.GetUnits(doc).GetFormatOptions(
UnitType.UT_Length).DisplayUnits)
fam_doc = doc.EditFamily(family)
if fam_doc:
family_manager = fam_doc.FamilyManager
sweep_col = FilteredElementCollector(fam_doc).OfClass(Sweep).ToElements()
sweep = [s for s in list(sweep_col) if s.IsSolid][0]
empty_sweep = [s for s in list(sweep_col) if not s.IsSolid][0]
trans1 = Transaction(fam_doc, 'Delete empty form')
trans1.Start()
fam_doc.Delete(empty_sweep.Id)
param_ARH_l = family_manager.get_Parameter('ARH_l')
if param_ARH_l:
family_manager.Set(
param_ARH_l,
UnitUtils.ConvertToInternalUnits(1000,
param_ARH_l.DisplayUnitType))
square = get_square_from_solid(sweep)[0]
vol1 = get_square_from_solid(sweep)[1]
vol2 = get_volume_from_bBox(sweep)
trans1.RollBack()
trans2 = Transaction(fam_doc, 'Set values')
trans2.Start()
sq = set_parameter_by_name(square, 'ARH_sr', fam_doc)
volume1 = set_parameter_by_name(vol1, 'ARH_v1', fam_doc)
volume2 = set_parameter_by_name(vol2, 'ARH_v2', fam_doc)
trans2.Commit()
fam_doc.LoadFamily(doc, FamilyOption())
fam_doc.Close(False)
OUT = square, vol1
def change_width_colomn(schedule, value=30):
table_data_section = schedule.GetTableData().GetSectionData(SectionType.Body)
table_data_section.RefreshData()
definition = schedule.Definition
for i in range(0, len(definition.GetFieldOrder())):
table_data_section.SetColumnWidth(i, UnitUtils.ConvertToInternalUnits(value, DisplayUnitType.DUT_MILLIMETERS))
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 export_config_length(lenght):
return str(UnitUtils.ConvertToInternalUnits(float(lenght), display_unit))
def export_click(self, sender, e):
main_worksheet = self.main_worksheet
service_column = self.service_column
parameters_list = [
parameter.strip()
for parameter in self.tb_exported_parameters.Text.split(",")
]
columns_list = [
column.strip()
for column in self.tb_exported_column.Text.split(",")
]
# popup a message if same amount of parameter and column
if len(parameters_list) != len(columns_list):
rpw.ui.forms.Alert(
"Pas le même nombre de paramètres et colonnes indiqués."
"Merci de corriger puis de relancer l'opération.")
return
# Create report headers
for index, parameter_name in enumerate(parameters_list):
export_sheet.Cells(1, index * 2 + 3).Value2 = parameter_name
export_sheet.Cells(2, index * 2 + 3).Value2 = "Avant"
export_sheet.Cells(2, index * 2 + 4).Value2 = "Après"
# Export values and append modified values to report
with rpw.db.Transaction("Export excel values to Revit"):
for space in self.spaces:
# Check if report row is free (no number written yet)
if export_sheet.Cells(self.export_row_count, 1).Value2:
self.export_row_count += 1
# Check if space is in an analysed service
if not self.service_check(space.service):
continue
# Retrieve Revit space if it exist
if space.id:
revit_space = revit.doc.GetElement(space.id)
else:
logger.info("L'espace {} n'a pas été trouvé".format(
space.common_name))
continue
# Retrieve parameter value from revit spaces
# with unit conversion if necessary (based on Revit DisplayUnitType)
for parameter_name, column, index in zip(
parameters_list, columns_list,
range(len(columns_list))):
parameter = revit_space.LookupParameter(parameter_name)
if not parameter:
logger.info("Parameter «{}» was not found".format(
parameter_name))
continue
cell_value = main_worksheet.Cells(space.row, column).Value2
parameter_value = None
if parameter.StorageType == StorageType.Integer:
if cell_value:
parameter_value = parameter.AsInteger()
new_parameter_value = int(cell_value)
else:
new_parameter_value = 0
elif parameter.StorageType == StorageType.String:
parameter_value = parameter.AsString()
new_parameter_value = str(cell_value)
elif parameter.StorageType == StorageType.Double:
if cell_value:
parameter_value = UnitUtils.ConvertFromInternalUnits(
parameter.AsDouble(),
parameter.DisplayUnitType)
else:
cell_value = 0
try:
new_parameter_value = UnitUtils.ConvertToInternalUnits(
cell_value, parameter.DisplayUnitType)
except TypeError:
error_sheet.Cells(self.error_row_count, 1).Value2 = \
"TypeError avec la valeur {} ligne {} colonne {}". format(cell_value, space.row, column)
self.error_row_count += 1
new_parameter_value = 0
else:
continue
main_sheet_value = main_worksheet.Cells(space.row,
column).Value2
if is_close(main_sheet_value, parameter_value) \
and not self.cb_full_report.IsChecked:
continue
else:
export_sheet.Cells(self.export_row_count,
1).Value2 = space.service
export_sheet.Cells(self.export_row_count,
2).Value2 = space.number
export_sheet.Cells(self.export_row_count, index * 2 +
3).Value2 = parameter_value
if not parameter.Set(new_parameter_value):
main_sheet_value = "Failed to assign new value to space"
main_sheet_cell = export_sheet.Cells(
self.export_row_count, index * 2 + 4)
main_sheet_cell.Value2 = main_sheet_value
if not is_close(main_sheet_value, parameter_value):
main_sheet_cell.Font.Color = -16776961
logger.debug("EXPORT - space {}".format(
space.common_name))
logger.debug(main_sheet_value == parameter_value)
logger.debug(type(main_sheet_value))
logger.debug(main_sheet_value)
logger.debug(type(parameter_value))
logger.debug(parameter_value)
# Set range for TableStyle
self.export_data_range = export_sheet.Range(
export_sheet.Cells(1, 1),
export_sheet.Cells(self.export_row_count,
len(columns_list) * 2 + 2))
def units(mmToFeets):
dut = DisplayUnitType.DUT_MILLIMETERS
return UnitUtils.ConvertToInternalUnits(mmToFeets, dut)
def convert_to_internal(value, unit="mm"):
return UnitUtils.ConvertToInternalUnits(
float(value), DisplayUnitType.DUT_MILLIMETERS
)
doc = DocumentManager.Instance.CurrentDBDocument
el = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_GenericModel) \
.WhereElementIsNotElementType().ToElements()
el_filter = []
point_z = []
TransactionManager.Instance.EnsureInTransaction(doc)
for i in el:
param_group_model = i.Symbol.LookupParameter('Группа модели')
param_otmetka = i.LookupParameter(IN[1]) # noqa
if param_group_model:
if param_group_model.AsString() == IN[0]: # noqa
el_filter.append(i)
pointXYZ = i.Location.Point
point_z.append(
round(
UnitUtils.ConvertFromInternalUnits(
pointXYZ.Z, DisplayUnitType.DUT_MILLIMETERS)))
else:
OUT = "Нет совпадающих критериев"
if param_otmetka:
for p in point_z:
param_otmetka.Set(
UnitUtils.ConvertToInternalUnits(
p, param_otmetka.DisplayUnitType))
else:
OUT = 'Нет такого параметра для записи значения'
TransactionManager.Instance.TransactionTaskDone()
path = r""
with open(path, 'rb') as csvfile:
file_reader = csv.reader(csvfile, delimiter='\t')
# Skip first 2 lines
file_reader.next()
file_reader.next()
with rpw.db.Transaction('Import heating/cooling', doc):
for row in file_reader:
number = '{}.{}'.format(row[0][0], row[0][1:3])
for space in FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_MEPSpaces): # type: Space
if space.Number == number:
hl_param = space.get_Parameter(
BuiltInParameter.ROOM_DESIGN_HEATING_LOAD_PARAM
) # type: Parameter
hl_param.Set(
UnitUtils.ConvertToInternalUnits(
float(row[9]), DisplayUnitType.DUT_WATTS))
cl_param = space.get_Parameter(
BuiltInParameter.ROOM_DESIGN_COOLING_LOAD_PARAM
) # type: Parameter
cl_param.Set(
UnitUtils.ConvertToInternalUnits(
float(row[12]), DisplayUnitType.DUT_WATTS))
break
else:
logger.info('Following space not found : {}'.format(number))
def convert_to_internal(value, unit="mm"):
return UnitUtils.ConvertToInternalUnits(
float(value), LENGTH_UNIT
)
fam_doc = doc.EditFamily(family)
# Семейство-----------------------------------------------------------------------------------
if fam_doc:
family_manager = fam_doc.FamilyManager
sweep_col = FilteredElementCollector(fam_doc).OfClass(Sweep).ToElements()
sweep = [s for s in list(sweep_col) if s.IsSolid][0]
empty_sweep = [s for s in list(sweep_col) if not s.IsSolid][0]
with Transaction(fam_doc, 'Delete empty form') as trans1:
trans1.Start()
fam_doc.Delete(empty_sweep.Id)
param_ARH_l = family_manager.get_Parameter('ARH_l')
if param_ARH_l:
family_manager.Set(param_ARH_l, UnitUtils.ConvertToInternalUnits(1000, param_ARH_l.DisplayUnitType))
square = get_square_from_solid(sweep)[0]
vol1 = get_square_from_solid(sweep)[1]
vol2 = get_volume_from_bBox(sweep)
export_to_stl(r'{3D}', fam_doc.Title, fam_doc)
trans1.RollBack()
with Transaction(fam_doc, 'Set values') as trans2:
trans2.Start()
sq = set_parameter_by_name(square, 'ARH_sr', fam_doc)
volume1 = set_parameter_by_name(vol1, 'ARH_v1', fam_doc)
volume2 = set_parameter_by_name(vol2, 'ARH_v2', fam_doc)
trans2.Commit()
fam_doc.LoadFamily(doc, FamilyOption())
fam_doc.Close(False)
