def test_create_roomairsettingsonenodedisplacementventilation(self):
pyidf.validation_level = ValidationLevel.error
obj = RoomAirSettingsOneNodeDisplacementVentilation()
# object-list
var_zone_name = "object-list|Zone Name"
obj.zone_name = var_zone_name
# real
var_fraction_of_convective_internal_loads_added_to_floor_air = 0.5
obj.fraction_of_convective_internal_loads_added_to_floor_air = var_fraction_of_convective_internal_loads_added_to_floor_air
# real
var_fraction_of_infiltration_internal_loads_added_to_floor_air = 0.5
obj.fraction_of_infiltration_internal_loads_added_to_floor_air = var_fraction_of_infiltration_internal_loads_added_to_floor_air
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.roomairsettingsonenodedisplacementventilations[0].zone_name, var_zone_name)
self.assertAlmostEqual(idf2.roomairsettingsonenodedisplacementventilations[0].fraction_of_convective_internal_loads_added_to_floor_air, var_fraction_of_convective_internal_loads_added_to_floor_air)
self.assertAlmostEqual(idf2.roomairsettingsonenodedisplacementventilations[0].fraction_of_infiltration_internal_loads_added_to_floor_air, var_fraction_of_infiltration_internal_loads_added_to_floor_air)
def test_create_airflownetworkdistributioncomponentleakageratio(self):
pyidf.validation_level = ValidationLevel.error
obj = AirflowNetworkDistributionComponentLeakageRatio()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_effective_leakage_ratio = 0.50005
obj.effective_leakage_ratio = var_effective_leakage_ratio
# real
var_maximum_flow_rate = 0.0001
obj.maximum_flow_rate = var_maximum_flow_rate
# real
var_reference_pressure_difference = 0.0001
obj.reference_pressure_difference = var_reference_pressure_difference
# real
var_air_mass_flow_exponent = 0.75
obj.air_mass_flow_exponent = var_air_mass_flow_exponent
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.airflownetworkdistributioncomponentleakageratios[0].name, var_name)
self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentleakageratios[0].effective_leakage_ratio, var_effective_leakage_ratio)
self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentleakageratios[0].maximum_flow_rate, var_maximum_flow_rate)
self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentleakageratios[0].reference_pressure_difference, var_reference_pressure_difference)
self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentleakageratios[0].air_mass_flow_exponent, var_air_mass_flow_exponent)
def test_create_setpointmanagersinglezoneonestageheating(self):
pyidf.validation_level = ValidationLevel.error
obj = SetpointManagerSingleZoneOneStageHeating()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_heating_stage_on_supply_air_setpoint_temperature = 2.2
obj.heating_stage_on_supply_air_setpoint_temperature = var_heating_stage_on_supply_air_setpoint_temperature
# real
var_heating_stage_off_supply_air_setpoint_temperature = 3.3
obj.heating_stage_off_supply_air_setpoint_temperature = var_heating_stage_off_supply_air_setpoint_temperature
# object-list
var_control_zone_name = "object-list|Control Zone Name"
obj.control_zone_name = var_control_zone_name
# node
var_setpoint_node_or_nodelist_name = "node|Setpoint Node or NodeList Name"
obj.setpoint_node_or_nodelist_name = var_setpoint_node_or_nodelist_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.setpointmanagersinglezoneonestageheatings[0].name, var_name)
self.assertAlmostEqual(idf2.setpointmanagersinglezoneonestageheatings[0].heating_stage_on_supply_air_setpoint_temperature, var_heating_stage_on_supply_air_setpoint_temperature)
self.assertAlmostEqual(idf2.setpointmanagersinglezoneonestageheatings[0].heating_stage_off_supply_air_setpoint_temperature, var_heating_stage_off_supply_air_setpoint_temperature)
self.assertEqual(idf2.setpointmanagersinglezoneonestageheatings[0].control_zone_name, var_control_zone_name)
self.assertEqual(idf2.setpointmanagersinglezoneonestageheatings[0].setpoint_node_or_nodelist_name, var_setpoint_node_or_nodelist_name)
def test_create_zonecontaminantsourceandsinkgenericcutoffmodel(self):
pyidf.validation_level = ValidationLevel.error
obj = ZoneContaminantSourceAndSinkGenericCutoffModel()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_zone_name = "object-list|Zone Name"
obj.zone_name = var_zone_name
# real
var_design_generation_rate_coefficient = 0.0
obj.design_generation_rate_coefficient = var_design_generation_rate_coefficient
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_cutoff_generic_contaminant_at_which_emission_ceases = 0.0001
obj.cutoff_generic_contaminant_at_which_emission_ceases = var_cutoff_generic_contaminant_at_which_emission_ceases
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.zonecontaminantsourceandsinkgenericcutoffmodels[0].name, var_name)
self.assertEqual(idf2.zonecontaminantsourceandsinkgenericcutoffmodels[0].zone_name, var_zone_name)
self.assertAlmostEqual(idf2.zonecontaminantsourceandsinkgenericcutoffmodels[0].design_generation_rate_coefficient, var_design_generation_rate_coefficient)
self.assertEqual(idf2.zonecontaminantsourceandsinkgenericcutoffmodels[0].schedule_name, var_schedule_name)
self.assertAlmostEqual(idf2.zonecontaminantsourceandsinkgenericcutoffmodels[0].cutoff_generic_contaminant_at_which_emission_ceases, var_cutoff_generic_contaminant_at_which_emission_ceases)
def test_create_groundheattransferslabmanualgrid(self):
pyidf.validation_level = ValidationLevel.error
obj = GroundHeatTransferSlabManualGrid()
# real
var_nx_number_of_cells_in_the_x_direction = 1.0
obj.nx_number_of_cells_in_the_x_direction = var_nx_number_of_cells_in_the_x_direction
# real
var_ny_number_of_cells_in_the_y_direction = 1.0
obj.ny_number_of_cells_in_the_y_direction = var_ny_number_of_cells_in_the_y_direction
# real
var_nz_number_of_cells_in_the_z_direction = 1.0
obj.nz_number_of_cells_in_the_z_direction = var_nz_number_of_cells_in_the_z_direction
# real
var_ibox_x_direction_cell_indicator_of_slab_edge = 4.4
obj.ibox_x_direction_cell_indicator_of_slab_edge = var_ibox_x_direction_cell_indicator_of_slab_edge
# real
var_jbox_y_direction_cell_indicator_of_slab_edge = 5.5
obj.jbox_y_direction_cell_indicator_of_slab_edge = var_jbox_y_direction_cell_indicator_of_slab_edge
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(idf2.groundheattransferslabmanualgrids[0].nx_number_of_cells_in_the_x_direction, var_nx_number_of_cells_in_the_x_direction)
self.assertAlmostEqual(idf2.groundheattransferslabmanualgrids[0].ny_number_of_cells_in_the_y_direction, var_ny_number_of_cells_in_the_y_direction)
self.assertAlmostEqual(idf2.groundheattransferslabmanualgrids[0].nz_number_of_cells_in_the_z_direction, var_nz_number_of_cells_in_the_z_direction)
self.assertAlmostEqual(idf2.groundheattransferslabmanualgrids[0].ibox_x_direction_cell_indicator_of_slab_edge, var_ibox_x_direction_cell_indicator_of_slab_edge)
self.assertAlmostEqual(idf2.groundheattransferslabmanualgrids[0].jbox_y_direction_cell_indicator_of_slab_edge, var_jbox_y_direction_cell_indicator_of_slab_edge)
def test_create_surfacecontrolmovableinsulation(self):
pyidf.validation_level = ValidationLevel.error
obj = SurfaceControlMovableInsulation()
# alpha
var_insulation_type = "Outside"
obj.insulation_type = var_insulation_type
# object-list
var_surface_name = "object-list|Surface Name"
obj.surface_name = var_surface_name
# object-list
var_material_name = "object-list|Material Name"
obj.material_name = var_material_name
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.surfacecontrolmovableinsulations[0].insulation_type, var_insulation_type)
self.assertEqual(idf2.surfacecontrolmovableinsulations[0].surface_name, var_surface_name)
self.assertEqual(idf2.surfacecontrolmovableinsulations[0].material_name, var_material_name)
self.assertEqual(idf2.surfacecontrolmovableinsulations[0].schedule_name, var_schedule_name)
def test_create_shadingpropertyreflectance(self):
pyidf.validation_level = ValidationLevel.error
obj = ShadingPropertyReflectance()
# object-list
var_shading_surface_name = "object-list|Shading Surface Name"
obj.shading_surface_name = var_shading_surface_name
# real
var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface = 0.5
obj.diffuse_solar_reflectance_of_unglazed_part_of_shading_surface = var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface
# real
var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface = 0.5
obj.diffuse_visible_reflectance_of_unglazed_part_of_shading_surface = var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface
# real
var_fraction_of_shading_surface_that_is_glazed = 0.5
obj.fraction_of_shading_surface_that_is_glazed = var_fraction_of_shading_surface_that_is_glazed
# alpha
var_glazing_construction_name = "Glazing Construction Name"
obj.glazing_construction_name = var_glazing_construction_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.shadingpropertyreflectances[0].shading_surface_name, var_shading_surface_name)
self.assertAlmostEqual(idf2.shadingpropertyreflectances[0].diffuse_solar_reflectance_of_unglazed_part_of_shading_surface, var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface)
self.assertAlmostEqual(idf2.shadingpropertyreflectances[0].diffuse_visible_reflectance_of_unglazed_part_of_shading_surface, var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface)
self.assertAlmostEqual(idf2.shadingpropertyreflectances[0].fraction_of_shading_surface_that_is_glazed, var_fraction_of_shading_surface_that_is_glazed)
self.assertEqual(idf2.shadingpropertyreflectances[0].glazing_construction_name, var_glazing_construction_name)
def test_create_refrigerationcompressorlist(self):
pyidf.validation_level = ValidationLevel.error
obj = RefrigerationCompressorList()
# alpha
var_name = "Name"
obj.name = var_name
paras = []
var_refrigeration_compressor_1_name = "object-list|Refrigeration Compressor 1 Name"
paras.append(var_refrigeration_compressor_1_name)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.refrigerationcompressorlists[0].name, var_name)
index = obj.extensible_field_index("Refrigeration Compressor 1 Name")
self.assertEqual(idf2.refrigerationcompressorlists[0].extensibles[0][index], var_refrigeration_compressor_1_name)
def test_create_airflownetworkmultizoneexternalnode(self):
pyidf.validation_level = ValidationLevel.error
obj = AirflowNetworkMultiZoneExternalNode()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_external_node_height = 2.2
obj.external_node_height = var_external_node_height
# object-list
var_wind_pressure_coefficient_values_object_name = "object-list|Wind Pressure Coefficient Values Object Name"
obj.wind_pressure_coefficient_values_object_name = var_wind_pressure_coefficient_values_object_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.airflownetworkmultizoneexternalnodes[0].name, var_name)
self.assertAlmostEqual(idf2.airflownetworkmultizoneexternalnodes[0].external_node_height, var_external_node_height)
self.assertEqual(idf2.airflownetworkmultizoneexternalnodes[0].wind_pressure_coefficient_values_object_name, var_wind_pressure_coefficient_values_object_name)
def test_create_thermalstorageicesimple(self):
pyidf.validation_level = ValidationLevel.error
obj = ThermalStorageIceSimple()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_ice_storage_type = "IceOnCoilInternal"
obj.ice_storage_type = var_ice_storage_type
# real
var_capacity = 3.3
obj.capacity = var_capacity
# node
var_inlet_node_name = "node|Inlet Node Name"
obj.inlet_node_name = var_inlet_node_name
# node
var_outlet_node_name = "node|Outlet Node Name"
obj.outlet_node_name = var_outlet_node_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.thermalstorageicesimples[0].name, var_name)
self.assertEqual(idf2.thermalstorageicesimples[0].ice_storage_type, var_ice_storage_type)
self.assertAlmostEqual(idf2.thermalstorageicesimples[0].capacity, var_capacity)
self.assertEqual(idf2.thermalstorageicesimples[0].inlet_node_name, var_inlet_node_name)
self.assertEqual(idf2.thermalstorageicesimples[0].outlet_node_name, var_outlet_node_name)
def test_create_scheduletypelimits(self):
pyidf.validation_level = ValidationLevel.error
obj = ScheduleTypeLimits()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_lower_limit_value = 2.2
obj.lower_limit_value = var_lower_limit_value
# real
var_upper_limit_value = 3.3
obj.upper_limit_value = var_upper_limit_value
# alpha
var_numeric_type = "Continuous"
obj.numeric_type = var_numeric_type
# alpha
var_unit_type = "Dimensionless"
obj.unit_type = var_unit_type
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.scheduletypelimitss[0].name, var_name)
self.assertAlmostEqual(idf2.scheduletypelimitss[0].lower_limit_value, var_lower_limit_value)
self.assertAlmostEqual(idf2.scheduletypelimitss[0].upper_limit_value, var_upper_limit_value)
self.assertEqual(idf2.scheduletypelimitss[0].numeric_type, var_numeric_type)
self.assertEqual(idf2.scheduletypelimitss[0].unit_type, var_unit_type)
def test_create_exteriorlights(self):
pyidf.validation_level = ValidationLevel.error
obj = ExteriorLights()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_design_level = 0.0
obj.design_level = var_design_level
# alpha
var_control_option = "ScheduleNameOnly"
obj.control_option = var_control_option
# alpha
var_enduse_subcategory = "End-Use Subcategory"
obj.enduse_subcategory = var_enduse_subcategory
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.exteriorlightss[0].name, var_name)
self.assertEqual(idf2.exteriorlightss[0].schedule_name, var_schedule_name)
self.assertAlmostEqual(idf2.exteriorlightss[0].design_level, var_design_level)
self.assertEqual(idf2.exteriorlightss[0].control_option, var_control_option)
self.assertEqual(idf2.exteriorlightss[0].enduse_subcategory, var_enduse_subcategory)
def test_create_airterminalsingleductuncontrolled(self):
pyidf.validation_level = ValidationLevel.error
obj = AirTerminalSingleDuctUncontrolled()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_availability_schedule_name = "object-list|Availability Schedule Name"
obj.availability_schedule_name = var_availability_schedule_name
# node
var_zone_supply_air_node_name = "node|Zone Supply Air Node Name"
obj.zone_supply_air_node_name = var_zone_supply_air_node_name
# real
var_maximum_air_flow_rate = 0.0
obj.maximum_air_flow_rate = var_maximum_air_flow_rate
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.airterminalsingleductuncontrolleds[0].name, var_name)
self.assertEqual(idf2.airterminalsingleductuncontrolleds[0].availability_schedule_name, var_availability_schedule_name)
self.assertEqual(idf2.airterminalsingleductuncontrolleds[0].zone_supply_air_node_name, var_zone_supply_air_node_name)
self.assertAlmostEqual(idf2.airterminalsingleductuncontrolleds[0].maximum_air_flow_rate, var_maximum_air_flow_rate)
def test_create_exteriorwaterequipment(self):
pyidf.validation_level = ValidationLevel.error
obj = ExteriorWaterEquipment()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_fuel_use_type = "Water"
obj.fuel_use_type = var_fuel_use_type
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_design_level = 0.0
obj.design_level = var_design_level
# alpha
var_enduse_subcategory = "End-Use Subcategory"
obj.enduse_subcategory = var_enduse_subcategory
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.exteriorwaterequipments[0].name, var_name)
self.assertEqual(idf2.exteriorwaterequipments[0].fuel_use_type, var_fuel_use_type)
self.assertEqual(idf2.exteriorwaterequipments[0].schedule_name, var_schedule_name)
self.assertAlmostEqual(idf2.exteriorwaterequipments[0].design_level, var_design_level)
self.assertEqual(idf2.exteriorwaterequipments[0].enduse_subcategory, var_enduse_subcategory)
def test_create_roomairnodeairflownetworkadjacentsurfacelist(self):
pyidf.validation_level = ValidationLevel.error
obj = RoomAirNodeAirflowNetworkAdjacentSurfaceList()
# Alpha
var_name = "Alpha|Name"
obj.name = var_name
paras = []
var_surface_1_name = "object-list|Surface 1 Name"
paras.append(var_surface_1_name)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.roomairnodeairflownetworkadjacentsurfacelists[0].name, var_name)
index = obj.extensible_field_index("Surface 1 Name")
self.assertEqual(idf2.roomairnodeairflownetworkadjacentsurfacelists[0].extensibles[0][index], var_surface_1_name)
def test_create_heatbalancesettingsconductionfinitedifference(self):
pyidf.validation_level = ValidationLevel.error
obj = HeatBalanceSettingsConductionFiniteDifference()
# alpha
var_difference_scheme = "CrankNicholsonSecondOrder"
obj.difference_scheme = var_difference_scheme
# real
var_space_discretization_constant = 2.2
obj.space_discretization_constant = var_space_discretization_constant
# real
var_relaxation_factor = 0.505
obj.relaxation_factor = var_relaxation_factor
# real
var_inside_face_surface_temperature_convergence_criteria = 0.00500005
obj.inside_face_surface_temperature_convergence_criteria = var_inside_face_surface_temperature_convergence_criteria
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.heatbalancesettingsconductionfinitedifferences[0].difference_scheme, var_difference_scheme)
self.assertAlmostEqual(idf2.heatbalancesettingsconductionfinitedifferences[0].space_discretization_constant, var_space_discretization_constant)
self.assertAlmostEqual(idf2.heatbalancesettingsconductionfinitedifferences[0].relaxation_factor, var_relaxation_factor)
self.assertAlmostEqual(idf2.heatbalancesettingsconductionfinitedifferences[0].inside_face_surface_temperature_convergence_criteria, var_inside_face_surface_temperature_convergence_criteria)
def test_create_energymanagementsystemcurveortableindexvariable(self):
pyidf.validation_level = ValidationLevel.error
obj = EnergyManagementSystemCurveOrTableIndexVariable()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_curve_or_table_object_name = "object-list|Curve or Table Object Name"
obj.curve_or_table_object_name = var_curve_or_table_object_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode="r") as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.energymanagementsystemcurveortableindexvariables[0].name, var_name)
self.assertEqual(
idf2.energymanagementsystemcurveortableindexvariables[0].curve_or_table_object_name,
var_curve_or_table_object_name,
)
def test_create_constructioncfactorundergroundwall(self):
pyidf.validation_level = ValidationLevel.error
obj = ConstructionCfactorUndergroundWall()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_cfactor = 0.0001
obj.cfactor = var_cfactor
# real
var_height = 0.0001
obj.height = var_height
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.constructioncfactorundergroundwalls[0].name, var_name)
self.assertAlmostEqual(idf2.constructioncfactorundergroundwalls[0].cfactor, var_cfactor)
self.assertAlmostEqual(idf2.constructioncfactorundergroundwalls[0].height, var_height)
def test_create_weatherpropertyskytemperature(self):
pyidf.validation_level = ValidationLevel.error
obj = WeatherPropertySkyTemperature()
# object-list
var_name = "object-list|Name"
obj.name = var_name
# alpha
var_calculation_type = "ScheduleValue"
obj.calculation_type = var_calculation_type
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.weatherpropertyskytemperatures[0].name, var_name)
self.assertEqual(idf2.weatherpropertyskytemperatures[0].calculation_type, var_calculation_type)
self.assertEqual(idf2.weatherpropertyskytemperatures[0].schedule_name, var_schedule_name)
def test_create_outputtablemonthly(self):
pyidf.validation_level = ValidationLevel.error
obj = OutputTableMonthly()
# alpha
var_name = "Name"
obj.name = var_name
# integer
var_digits_after_decimal = 5
obj.digits_after_decimal = var_digits_after_decimal
paras = []
var_variable_or_meter_1_name = "external-list|Variable or Meter 1 Name"
paras.append(var_variable_or_meter_1_name)
var_aggregation_type_for_variable_or_meter_1 = "SumOrAverage"
paras.append(var_aggregation_type_for_variable_or_meter_1)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.outputtablemonthlys[0].name, var_name)
self.assertEqual(idf2.outputtablemonthlys[0].digits_after_decimal, var_digits_after_decimal)
index = obj.extensible_field_index("Variable or Meter 1 Name")
self.assertEqual(idf2.outputtablemonthlys[0].extensibles[0][index], var_variable_or_meter_1_name)
index = obj.extensible_field_index("Aggregation Type for Variable or Meter 1")
self.assertEqual(idf2.outputtablemonthlys[0].extensibles[0][index], var_aggregation_type_for_variable_or_meter_1)
def test_create_fluidpropertiesglycolconcentration(self):
pyidf.validation_level = ValidationLevel.error
obj = FluidPropertiesGlycolConcentration()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_glycol_type = "EthyleneGlycol"
obj.glycol_type = var_glycol_type
# object-list
var_user_defined_glycol_name = "object-list|User Defined Glycol Name"
obj.user_defined_glycol_name = var_user_defined_glycol_name
# real
var_glycol_concentration = 0.5
obj.glycol_concentration = var_glycol_concentration
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.fluidpropertiesglycolconcentrations[0].name, var_name)
self.assertEqual(idf2.fluidpropertiesglycolconcentrations[0].glycol_type, var_glycol_type)
self.assertEqual(idf2.fluidpropertiesglycolconcentrations[0].user_defined_glycol_name, var_user_defined_glycol_name)
self.assertAlmostEqual(idf2.fluidpropertiesglycolconcentrations[0].glycol_concentration, var_glycol_concentration)
def test_create_surfacepropertyheattransferalgorithmconstruction(self):
pyidf.validation_level = ValidationLevel.error
obj = SurfacePropertyHeatTransferAlgorithmConstruction()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_algorithm = "ConductionTransferFunction"
obj.algorithm = var_algorithm
# object-list
var_construction_name = "object-list|Construction Name"
obj.construction_name = var_construction_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.surfacepropertyheattransferalgorithmconstructions[0].name, var_name)
self.assertEqual(idf2.surfacepropertyheattransferalgorithmconstructions[0].algorithm, var_algorithm)
self.assertEqual(idf2.surfacepropertyheattransferalgorithmconstructions[0].construction_name, var_construction_name)
def test_create_groundheattransferslabinsulation(self):
pyidf.validation_level = ValidationLevel.error
obj = GroundHeatTransferSlabInsulation()
# real
var_rins_r_value_of_under_slab_insulation = 1.1
obj.rins_r_value_of_under_slab_insulation = var_rins_r_value_of_under_slab_insulation
# real
var_dins_width_of_strip_of_under_slab_insulation = 2.2
obj.dins_width_of_strip_of_under_slab_insulation = var_dins_width_of_strip_of_under_slab_insulation
# real
var_rvins_r_value_of_vertical_insulation = 3.3
obj.rvins_r_value_of_vertical_insulation = var_rvins_r_value_of_vertical_insulation
# real
var_zvins_depth_of_vertical_insulation = 4.4
obj.zvins_depth_of_vertical_insulation = var_zvins_depth_of_vertical_insulation
# integer
var_ivins_flag_is_there_vertical_insulation = 0
obj.ivins_flag_is_there_vertical_insulation = var_ivins_flag_is_there_vertical_insulation
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(idf2.groundheattransferslabinsulations[0].rins_r_value_of_under_slab_insulation, var_rins_r_value_of_under_slab_insulation)
self.assertAlmostEqual(idf2.groundheattransferslabinsulations[0].dins_width_of_strip_of_under_slab_insulation, var_dins_width_of_strip_of_under_slab_insulation)
self.assertAlmostEqual(idf2.groundheattransferslabinsulations[0].rvins_r_value_of_vertical_insulation, var_rvins_r_value_of_vertical_insulation)
self.assertAlmostEqual(idf2.groundheattransferslabinsulations[0].zvins_depth_of_vertical_insulation, var_zvins_depth_of_vertical_insulation)
self.assertEqual(idf2.groundheattransferslabinsulations[0].ivins_flag_is_there_vertical_insulation, var_ivins_flag_is_there_vertical_insulation)
def test_create_sizingparameters(self):
pyidf.validation_level = ValidationLevel.error
obj = SizingParameters()
# real
var_heating_sizing_factor = 0.0001
obj.heating_sizing_factor = var_heating_sizing_factor
# real
var_cooling_sizing_factor = 0.0001
obj.cooling_sizing_factor = var_cooling_sizing_factor
# integer
var_timesteps_in_averaging_window = 1
obj.timesteps_in_averaging_window = var_timesteps_in_averaging_window
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(idf2.sizingparameterss[0].heating_sizing_factor, var_heating_sizing_factor)
self.assertAlmostEqual(idf2.sizingparameterss[0].cooling_sizing_factor, var_cooling_sizing_factor)
self.assertEqual(idf2.sizingparameterss[0].timesteps_in_averaging_window, var_timesteps_in_averaging_window)
def test_create_energymanagementsystemtrendvariable(self):
pyidf.validation_level = ValidationLevel.error
obj = EnergyManagementSystemTrendVariable()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_ems_variable_name = "EMS Variable Name"
obj.ems_variable_name = var_ems_variable_name
# integer
var_number_of_timesteps_to_be_logged = 1
obj.number_of_timesteps_to_be_logged = var_number_of_timesteps_to_be_logged
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.energymanagementsystemtrendvariables[0].name, var_name)
self.assertEqual(idf2.energymanagementsystemtrendvariables[0].ems_variable_name, var_ems_variable_name)
self.assertEqual(idf2.energymanagementsystemtrendvariables[0].number_of_timesteps_to_be_logged, var_number_of_timesteps_to_be_logged)
def test_create_connectormixer(self):
pyidf.validation_level = ValidationLevel.error
obj = ConnectorMixer()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_outlet_branch_name = "object-list|Outlet Branch Name"
obj.outlet_branch_name = var_outlet_branch_name
paras = []
var_inlet_branch_name = "object-list|Inlet Branch Name"
paras.append(var_inlet_branch_name)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.connectormixers[0].name, var_name)
self.assertEqual(idf2.connectormixers[0].outlet_branch_name, var_outlet_branch_name)
index = obj.extensible_field_index("Inlet Branch Name")
self.assertEqual(idf2.connectormixers[0].extensibles[0][index], var_inlet_branch_name)
def test_create_setpointmanagersinglezonehumiditymaximum(self):
pyidf.validation_level = ValidationLevel.error
obj = SetpointManagerSingleZoneHumidityMaximum()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_control_variable = "Control Variable"
obj.control_variable = var_control_variable
# alpha
var_schedule_name = "Schedule Name"
obj.schedule_name = var_schedule_name
# node
var_setpoint_node_or_nodelist_name = "node|Setpoint Node or NodeList Name"
obj.setpoint_node_or_nodelist_name = var_setpoint_node_or_nodelist_name
# node
var_control_zone_air_node_name = "node|Control Zone Air Node Name"
obj.control_zone_air_node_name = var_control_zone_air_node_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.setpointmanagersinglezonehumiditymaximums[0].name, var_name)
self.assertEqual(idf2.setpointmanagersinglezonehumiditymaximums[0].control_variable, var_control_variable)
self.assertEqual(idf2.setpointmanagersinglezonehumiditymaximums[0].schedule_name, var_schedule_name)
self.assertEqual(idf2.setpointmanagersinglezonehumiditymaximums[0].setpoint_node_or_nodelist_name, var_setpoint_node_or_nodelist_name)
self.assertEqual(idf2.setpointmanagersinglezonehumiditymaximums[0].control_zone_air_node_name, var_control_zone_air_node_name)
def test_create_airflownetworkdistributionnode(self):
pyidf.validation_level = ValidationLevel.error
obj = AirflowNetworkDistributionNode()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_component_name_or_node_name = "Component Name or Node Name"
obj.component_name_or_node_name = var_component_name_or_node_name
# alpha
var_component_object_type_or_node_type = "AirLoopHVAC:ZoneMixer"
obj.component_object_type_or_node_type = var_component_object_type_or_node_type
# real
var_node_height = 4.4
obj.node_height = var_node_height
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.airflownetworkdistributionnodes[0].name, var_name)
self.assertEqual(idf2.airflownetworkdistributionnodes[0].component_name_or_node_name, var_component_name_or_node_name)
self.assertEqual(idf2.airflownetworkdistributionnodes[0].component_object_type_or_node_type, var_component_object_type_or_node_type)
self.assertAlmostEqual(idf2.airflownetworkdistributionnodes[0].node_height, var_node_height)
def test_create_thermostatsetpointdualsetpoint(self):
pyidf.validation_level = ValidationLevel.error
obj = ThermostatSetpointDualSetpoint()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_heating_setpoint_temperature_schedule_name = "object-list|Heating Setpoint Temperature Schedule Name"
obj.heating_setpoint_temperature_schedule_name = var_heating_setpoint_temperature_schedule_name
# object-list
var_cooling_setpoint_temperature_schedule_name = "object-list|Cooling Setpoint Temperature Schedule Name"
obj.cooling_setpoint_temperature_schedule_name = var_cooling_setpoint_temperature_schedule_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.thermostatsetpointdualsetpoints[0].name, var_name)
self.assertEqual(idf2.thermostatsetpointdualsetpoints[0].heating_setpoint_temperature_schedule_name, var_heating_setpoint_temperature_schedule_name)
self.assertEqual(idf2.thermostatsetpointdualsetpoints[0].cooling_setpoint_temperature_schedule_name, var_cooling_setpoint_temperature_schedule_name)
def test_create_airflownetworkintrazonelinkage(self):
pyidf.validation_level = ValidationLevel.error
obj = AirflowNetworkIntraZoneLinkage()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_node_1_name = "Node 1 Name"
obj.node_1_name = var_node_1_name
# alpha
var_node_2_name = "Node 2 Name"
obj.node_2_name = var_node_2_name
# object-list
var_component_name = "object-list|Component Name"
obj.component_name = var_component_name
# object-list
var_airflownetworkmultizonesurface_name = "object-list|AirflowNetwork:MultiZone:Surface Name"
obj.airflownetworkmultizonesurface_name = var_airflownetworkmultizonesurface_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.airflownetworkintrazonelinkages[0].name, var_name)
self.assertEqual(idf2.airflownetworkintrazonelinkages[0].node_1_name, var_node_1_name)
self.assertEqual(idf2.airflownetworkintrazonelinkages[0].node_2_name, var_node_2_name)
self.assertEqual(idf2.airflownetworkintrazonelinkages[0].component_name, var_component_name)
self.assertEqual(idf2.airflownetworkintrazonelinkages[0].airflownetworkmultizonesurface_name, var_airflownetworkmultizonesurface_name)
def test_create_schedulefile(self):
pyidf.validation_level = ValidationLevel.error
obj = ScheduleFile()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_schedule_type_limits_name = "object-list|Schedule Type Limits Name"
obj.schedule_type_limits_name = var_schedule_type_limits_name
# alpha
var_file_name = "File Name"
obj.file_name = var_file_name
# integer
var_column_number = 1
obj.column_number = var_column_number
# integer
var_rows_to_skip_at_top = 0
obj.rows_to_skip_at_top = var_rows_to_skip_at_top
# real
var_number_of_hours_of_data = 8772.0
obj.number_of_hours_of_data = var_number_of_hours_of_data
# alpha
var_column_separator = "Comma"
obj.column_separator = var_column_separator
# alpha
var_interpolate_to_timestep = "Yes"
obj.interpolate_to_timestep = var_interpolate_to_timestep
# integer
var_minutes_per_item = 30
obj.minutes_per_item = var_minutes_per_item
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.schedulefiles[0].name, var_name)
self.assertEqual(idf2.schedulefiles[0].schedule_type_limits_name, var_schedule_type_limits_name)
self.assertEqual(idf2.schedulefiles[0].file_name, var_file_name)
self.assertEqual(idf2.schedulefiles[0].column_number, var_column_number)
self.assertEqual(idf2.schedulefiles[0].rows_to_skip_at_top, var_rows_to_skip_at_top)
self.assertAlmostEqual(idf2.schedulefiles[0].number_of_hours_of_data, var_number_of_hours_of_data)
self.assertEqual(idf2.schedulefiles[0].column_separator, var_column_separator)
self.assertEqual(idf2.schedulefiles[0].interpolate_to_timestep, var_interpolate_to_timestep)
self.assertEqual(idf2.schedulefiles[0].minutes_per_item, var_minutes_per_item)
def test_create_faultmodeltemperaturesensoroffsetoutdoorair(self):
pyidf.validation_level = ValidationLevel.error
obj = FaultModelTemperatureSensorOffsetOutdoorAir()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_availability_schedule_name = "object-list|Availability Schedule Name"
obj.availability_schedule_name = var_availability_schedule_name
# object-list
var_severity_schedule_name = "object-list|Severity Schedule Name"
obj.severity_schedule_name = var_severity_schedule_name
# alpha
var_controller_object_type = "Controller:OutdoorAir"
obj.controller_object_type = var_controller_object_type
# object-list
var_controller_object_name = "object-list|Controller Object Name"
obj.controller_object_name = var_controller_object_name
# real
var_temperature_sensor_offset = 0.0
obj.temperature_sensor_offset = var_temperature_sensor_offset
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].name,
var_name)
self.assertEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].
availability_schedule_name, var_availability_schedule_name)
self.assertEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].
severity_schedule_name, var_severity_schedule_name)
self.assertEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].
controller_object_type, var_controller_object_type)
self.assertEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].
controller_object_name, var_controller_object_name)
self.assertAlmostEqual(
idf2.faultmodeltemperaturesensoroffsetoutdoorairs[0].
temperature_sensor_offset, var_temperature_sensor_offset)
def test_create_groundheattransferslabmaterials(self):
pyidf.validation_level = ValidationLevel.error
obj = GroundHeatTransferSlabMaterials()
# real
var_nmat_number_of_materials = 0.0001
obj.nmat_number_of_materials = var_nmat_number_of_materials
# real
var_albedo_surface_albedo_no_snow = 0.5
obj.albedo_surface_albedo_no_snow = var_albedo_surface_albedo_no_snow
# real
var_albedo_surface_albedo_snow = 0.5
obj.albedo_surface_albedo_snow = var_albedo_surface_albedo_snow
# real
var_epslw_surface_emissivity_no_snow = 0.0001
obj.epslw_surface_emissivity_no_snow = var_epslw_surface_emissivity_no_snow
# real
var_epslw_surface_emissivity_snow = 0.0001
obj.epslw_surface_emissivity_snow = var_epslw_surface_emissivity_snow
# real
var_z0_surface_roughness_no_snow = 0.0001
obj.z0_surface_roughness_no_snow = var_z0_surface_roughness_no_snow
# real
var_z0_surface_roughness_snow = 0.0001
obj.z0_surface_roughness_snow = var_z0_surface_roughness_snow
# real
var_hin_indoor_hconv_downward_flow = 0.0001
obj.hin_indoor_hconv_downward_flow = var_hin_indoor_hconv_downward_flow
# real
var_hin_indoor_hconv_upward = 0.0001
obj.hin_indoor_hconv_upward = var_hin_indoor_hconv_upward
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].nmat_number_of_materials, var_nmat_number_of_materials)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].albedo_surface_albedo_no_snow, var_albedo_surface_albedo_no_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].albedo_surface_albedo_snow, var_albedo_surface_albedo_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].epslw_surface_emissivity_no_snow, var_epslw_surface_emissivity_no_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].epslw_surface_emissivity_snow, var_epslw_surface_emissivity_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].z0_surface_roughness_no_snow, var_z0_surface_roughness_no_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].z0_surface_roughness_snow, var_z0_surface_roughness_snow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].hin_indoor_hconv_downward_flow, var_hin_indoor_hconv_downward_flow)
self.assertAlmostEqual(idf2.groundheattransferslabmaterialss[0].hin_indoor_hconv_upward, var_hin_indoor_hconv_upward)
def test_create_door(self):
pyidf.validation_level = ValidationLevel.error
obj = Door()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_construction_name = "object-list|Construction Name"
obj.construction_name = var_construction_name
# object-list
var_building_surface_name = "object-list|Building Surface Name"
obj.building_surface_name = var_building_surface_name
# real
var_multiplier = 1.0
obj.multiplier = var_multiplier
# real
var_starting_x_coordinate = 5.5
obj.starting_x_coordinate = var_starting_x_coordinate
# real
var_starting_z_coordinate = 6.6
obj.starting_z_coordinate = var_starting_z_coordinate
# real
var_length = 7.7
obj.length = var_length
# real
var_height = 8.8
obj.height = var_height
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.doors[0].name, var_name)
self.assertEqual(idf2.doors[0].construction_name,
var_construction_name)
self.assertEqual(idf2.doors[0].building_surface_name,
var_building_surface_name)
self.assertAlmostEqual(idf2.doors[0].multiplier, var_multiplier)
self.assertAlmostEqual(idf2.doors[0].starting_x_coordinate,
var_starting_x_coordinate)
self.assertAlmostEqual(idf2.doors[0].starting_z_coordinate,
var_starting_z_coordinate)
self.assertAlmostEqual(idf2.doors[0].length, var_length)
self.assertAlmostEqual(idf2.doors[0].height, var_height)
def test_create_sitegroundtemperatureundisturbedxing(self):
pyidf.validation_level = ValidationLevel.error
obj = SiteGroundTemperatureUndisturbedXing()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_soil_thermal_conductivity = 0.0001
obj.soil_thermal_conductivity = var_soil_thermal_conductivity
# real
var_soil_density = 0.0001
obj.soil_density = var_soil_density
# real
var_soil_specific_heat = 0.0001
obj.soil_specific_heat = var_soil_specific_heat
# real
var_average_soil_surface_tempeature = 5.5
obj.average_soil_surface_tempeature = var_average_soil_surface_tempeature
# real
var_soil_surface_temperature_amplitude_1 = 6.6
obj.soil_surface_temperature_amplitude_1 = var_soil_surface_temperature_amplitude_1
# real
var_soil_surface_temperature_amplitude_2 = 7.7
obj.soil_surface_temperature_amplitude_2 = var_soil_surface_temperature_amplitude_2
# real
var_phase_shift_of_temperature_amplitude_1 = 364.9999
obj.phase_shift_of_temperature_amplitude_1 = var_phase_shift_of_temperature_amplitude_1
# real
var_phase_shift_of_temperature_amplitude_2 = 364.9999
obj.phase_shift_of_temperature_amplitude_2 = var_phase_shift_of_temperature_amplitude_2
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.sitegroundtemperatureundisturbedxings[0].name, var_name)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].soil_thermal_conductivity, var_soil_thermal_conductivity)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].soil_density, var_soil_density)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].soil_specific_heat, var_soil_specific_heat)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].average_soil_surface_tempeature, var_average_soil_surface_tempeature)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].soil_surface_temperature_amplitude_1, var_soil_surface_temperature_amplitude_1)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].soil_surface_temperature_amplitude_2, var_soil_surface_temperature_amplitude_2)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].phase_shift_of_temperature_amplitude_1, var_phase_shift_of_temperature_amplitude_1)
self.assertAlmostEqual(idf2.sitegroundtemperatureundisturbedxings[0].phase_shift_of_temperature_amplitude_2, var_phase_shift_of_temperature_amplitude_2)
def test_create_zonecontaminantsourceandsinkgenericconstant(self):
pyidf.validation_level = ValidationLevel.error
obj = ZoneContaminantSourceAndSinkGenericConstant()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_zone_name = "object-list|Zone Name"
obj.zone_name = var_zone_name
# real
var_design_generation_rate = 0.0
obj.design_generation_rate = var_design_generation_rate
# object-list
var_generation_schedule_name = "object-list|Generation Schedule Name"
obj.generation_schedule_name = var_generation_schedule_name
# real
var_design_removal_coefficient = 0.0
obj.design_removal_coefficient = var_design_removal_coefficient
# object-list
var_removal_schedule_name = "object-list|Removal Schedule Name"
obj.removal_schedule_name = var_removal_schedule_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].name,
var_name)
self.assertEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].zone_name,
var_zone_name)
self.assertAlmostEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].
design_generation_rate, var_design_generation_rate)
self.assertEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].
generation_schedule_name, var_generation_schedule_name)
self.assertAlmostEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].
design_removal_coefficient, var_design_removal_coefficient)
self.assertEqual(
idf2.zonecontaminantsourceandsinkgenericconstants[0].
removal_schedule_name, var_removal_schedule_name)
def test_create_coilheatingdesuperheater(self):
pyidf.validation_level = ValidationLevel.error
obj = CoilHeatingDesuperheater()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_availability_schedule_name = "object-list|Availability Schedule Name"
obj.availability_schedule_name = var_availability_schedule_name
# real
var_heat_reclaim_recovery_efficiency = 0.0
obj.heat_reclaim_recovery_efficiency = var_heat_reclaim_recovery_efficiency
# node
var_air_inlet_node_name = "node|Air Inlet Node Name"
obj.air_inlet_node_name = var_air_inlet_node_name
# node
var_air_outlet_node_name = "node|Air Outlet Node Name"
obj.air_outlet_node_name = var_air_outlet_node_name
# alpha
var_heating_source_object_type = "Coil:Cooling:DX:SingleSpeed"
obj.heating_source_object_type = var_heating_source_object_type
# object-list
var_heating_source_name = "object-list|Heating Source Name"
obj.heating_source_name = var_heating_source_name
# node
var_temperature_setpoint_node_name = "node|Temperature Setpoint Node Name"
obj.temperature_setpoint_node_name = var_temperature_setpoint_node_name
# real
var_parasitic_electric_load = 0.0
obj.parasitic_electric_load = var_parasitic_electric_load
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.coilheatingdesuperheaters[0].name, var_name)
self.assertEqual(idf2.coilheatingdesuperheaters[0].availability_schedule_name, var_availability_schedule_name)
self.assertAlmostEqual(idf2.coilheatingdesuperheaters[0].heat_reclaim_recovery_efficiency, var_heat_reclaim_recovery_efficiency)
self.assertEqual(idf2.coilheatingdesuperheaters[0].air_inlet_node_name, var_air_inlet_node_name)
self.assertEqual(idf2.coilheatingdesuperheaters[0].air_outlet_node_name, var_air_outlet_node_name)
self.assertEqual(idf2.coilheatingdesuperheaters[0].heating_source_object_type, var_heating_source_object_type)
self.assertEqual(idf2.coilheatingdesuperheaters[0].heating_source_name, var_heating_source_name)
self.assertEqual(idf2.coilheatingdesuperheaters[0].temperature_setpoint_node_name, var_temperature_setpoint_node_name)
self.assertAlmostEqual(idf2.coilheatingdesuperheaters[0].parasitic_electric_load, var_parasitic_electric_load)
def test_create_zonebaseboardoutdoortemperaturecontrolled(self):
pyidf.validation_level = ValidationLevel.error
obj = ZoneBaseboardOutdoorTemperatureControlled()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_zone_name = "object-list|Zone Name"
obj.zone_name = var_zone_name
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_capacity_at_low_temperature = 0.0001
obj.capacity_at_low_temperature = var_capacity_at_low_temperature
# real
var_low_temperature = 5.5
obj.low_temperature = var_low_temperature
# real
var_capacity_at_high_temperature = 0.0
obj.capacity_at_high_temperature = var_capacity_at_high_temperature
# real
var_high_temperature = 7.7
obj.high_temperature = var_high_temperature
# real
var_fraction_radiant = 0.5
obj.fraction_radiant = var_fraction_radiant
# alpha
var_enduse_subcategory = "End-Use Subcategory"
obj.enduse_subcategory = var_enduse_subcategory
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].name, var_name)
self.assertEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].zone_name, var_zone_name)
self.assertEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].schedule_name, var_schedule_name)
self.assertAlmostEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].capacity_at_low_temperature, var_capacity_at_low_temperature)
self.assertAlmostEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].low_temperature, var_low_temperature)
self.assertAlmostEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].capacity_at_high_temperature, var_capacity_at_high_temperature)
self.assertAlmostEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].high_temperature, var_high_temperature)
self.assertAlmostEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].fraction_radiant, var_fraction_radiant)
self.assertEqual(idf2.zonebaseboardoutdoortemperaturecontrolleds[0].enduse_subcategory, var_enduse_subcategory)
def test_create_humidifiersteamelectric(self):
pyidf.validation_level = ValidationLevel.error
obj = HumidifierSteamElectric()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_availability_schedule_name = "object-list|Availability Schedule Name"
obj.availability_schedule_name = var_availability_schedule_name
# real
var_rated_capacity = 0.0
obj.rated_capacity = var_rated_capacity
# real
var_rated_power = 0.0
obj.rated_power = var_rated_power
# real
var_rated_fan_power = 0.0
obj.rated_fan_power = var_rated_fan_power
# real
var_standby_power = 0.0
obj.standby_power = var_standby_power
# node
var_air_inlet_node_name = "node|Air Inlet Node Name"
obj.air_inlet_node_name = var_air_inlet_node_name
# node
var_air_outlet_node_name = "node|Air Outlet Node Name"
obj.air_outlet_node_name = var_air_outlet_node_name
# object-list
var_water_storage_tank_name = "object-list|Water Storage Tank Name"
obj.water_storage_tank_name = var_water_storage_tank_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.humidifiersteamelectrics[0].name, var_name)
self.assertEqual(idf2.humidifiersteamelectrics[0].availability_schedule_name, var_availability_schedule_name)
self.assertAlmostEqual(idf2.humidifiersteamelectrics[0].rated_capacity, var_rated_capacity)
self.assertAlmostEqual(idf2.humidifiersteamelectrics[0].rated_power, var_rated_power)
self.assertAlmostEqual(idf2.humidifiersteamelectrics[0].rated_fan_power, var_rated_fan_power)
self.assertAlmostEqual(idf2.humidifiersteamelectrics[0].standby_power, var_standby_power)
self.assertEqual(idf2.humidifiersteamelectrics[0].air_inlet_node_name, var_air_inlet_node_name)
self.assertEqual(idf2.humidifiersteamelectrics[0].air_outlet_node_name, var_air_outlet_node_name)
self.assertEqual(idf2.humidifiersteamelectrics[0].water_storage_tank_name, var_water_storage_tank_name)
def test_create_shadingsite(self):
pyidf.validation_level = ValidationLevel.error
obj = ShadingSite()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_azimuth_angle = 180.0
obj.azimuth_angle = var_azimuth_angle
# real
var_tilt_angle = 90.0
obj.tilt_angle = var_tilt_angle
# real
var_starting_x_coordinate = 4.4
obj.starting_x_coordinate = var_starting_x_coordinate
# real
var_starting_y_coordinate = 5.5
obj.starting_y_coordinate = var_starting_y_coordinate
# real
var_starting_z_coordinate = 6.6
obj.starting_z_coordinate = var_starting_z_coordinate
# real
var_length = 7.7
obj.length = var_length
# real
var_height = 8.8
obj.height = var_height
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.shadingsites[0].name, var_name)
self.assertAlmostEqual(idf2.shadingsites[0].azimuth_angle,
var_azimuth_angle)
self.assertAlmostEqual(idf2.shadingsites[0].tilt_angle, var_tilt_angle)
self.assertAlmostEqual(idf2.shadingsites[0].starting_x_coordinate,
var_starting_x_coordinate)
self.assertAlmostEqual(idf2.shadingsites[0].starting_y_coordinate,
var_starting_y_coordinate)
self.assertAlmostEqual(idf2.shadingsites[0].starting_z_coordinate,
var_starting_z_coordinate)
self.assertAlmostEqual(idf2.shadingsites[0].length, var_length)
self.assertAlmostEqual(idf2.shadingsites[0].height, var_height)
def test_create_zoneinfiltrationeffectiveleakagearea(self):
pyidf.validation_level = ValidationLevel.error
obj = ZoneInfiltrationEffectiveLeakageArea()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_zone_name = "object-list|Zone Name"
obj.zone_name = var_zone_name
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_effective_air_leakage_area = 0.0001
obj.effective_air_leakage_area = var_effective_air_leakage_area
# real
var_stack_coefficient = 0.0001
obj.stack_coefficient = var_stack_coefficient
# real
var_wind_coefficient = 0.0001
obj.wind_coefficient = var_wind_coefficient
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.zoneinfiltrationeffectiveleakageareas[0].name,
var_name)
self.assertEqual(
idf2.zoneinfiltrationeffectiveleakageareas[0].zone_name,
var_zone_name)
self.assertEqual(
idf2.zoneinfiltrationeffectiveleakageareas[0].schedule_name,
var_schedule_name)
self.assertAlmostEqual(
idf2.zoneinfiltrationeffectiveleakageareas[0].
effective_air_leakage_area, var_effective_air_leakage_area)
self.assertAlmostEqual(
idf2.zoneinfiltrationeffectiveleakageareas[0].stack_coefficient,
var_stack_coefficient)
self.assertAlmostEqual(
idf2.zoneinfiltrationeffectiveleakageareas[0].wind_coefficient,
var_wind_coefficient)
def test_create_groundheattransferslabinsulation(self):
pyidf.validation_level = ValidationLevel.error
obj = GroundHeatTransferSlabInsulation()
# real
var_rins_r_value_of_under_slab_insulation = 1.1
obj.rins_r_value_of_under_slab_insulation = var_rins_r_value_of_under_slab_insulation
# real
var_dins_width_of_strip_of_under_slab_insulation = 2.2
obj.dins_width_of_strip_of_under_slab_insulation = var_dins_width_of_strip_of_under_slab_insulation
# real
var_rvins_r_value_of_vertical_insulation = 3.3
obj.rvins_r_value_of_vertical_insulation = var_rvins_r_value_of_vertical_insulation
# real
var_zvins_depth_of_vertical_insulation = 4.4
obj.zvins_depth_of_vertical_insulation = var_zvins_depth_of_vertical_insulation
# integer
var_ivins_flag_is_there_vertical_insulation = 0
obj.ivins_flag_is_there_vertical_insulation = var_ivins_flag_is_there_vertical_insulation
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(
idf2.groundheattransferslabinsulations[0].
rins_r_value_of_under_slab_insulation,
var_rins_r_value_of_under_slab_insulation)
self.assertAlmostEqual(
idf2.groundheattransferslabinsulations[0].
dins_width_of_strip_of_under_slab_insulation,
var_dins_width_of_strip_of_under_slab_insulation)
self.assertAlmostEqual(
idf2.groundheattransferslabinsulations[0].
rvins_r_value_of_vertical_insulation,
var_rvins_r_value_of_vertical_insulation)
self.assertAlmostEqual(
idf2.groundheattransferslabinsulations[0].
zvins_depth_of_vertical_insulation,
var_zvins_depth_of_vertical_insulation)
self.assertEqual(
idf2.groundheattransferslabinsulations[0].
ivins_flag_is_there_vertical_insulation,
var_ivins_flag_is_there_vertical_insulation)
def test_create_shadingsitedetailed(self):
pyidf.validation_level = ValidationLevel.error
obj = ShadingSiteDetailed()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_transmittance_schedule_name = "object-list|Transmittance Schedule Name"
obj.transmittance_schedule_name = var_transmittance_schedule_name
# real
var_number_of_vertices = 3.0
obj.number_of_vertices = var_number_of_vertices
paras = []
var_vertex_1_xcoordinate = 4.4
paras.append(var_vertex_1_xcoordinate)
var_vertex_1_ycoordinate = 5.5
paras.append(var_vertex_1_ycoordinate)
var_vertex_1_zcoordinate = 6.6
paras.append(var_vertex_1_zcoordinate)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.shadingsitedetaileds[0].name, var_name)
self.assertEqual(
idf2.shadingsitedetaileds[0].transmittance_schedule_name,
var_transmittance_schedule_name)
self.assertAlmostEqual(idf2.shadingsitedetaileds[0].number_of_vertices,
var_number_of_vertices)
index = obj.extensible_field_index("Vertex 1 X-coordinate")
self.assertAlmostEqual(
idf2.shadingsitedetaileds[0].extensibles[0][index],
var_vertex_1_xcoordinate)
index = obj.extensible_field_index("Vertex 1 Y-coordinate")
self.assertAlmostEqual(
idf2.shadingsitedetaileds[0].extensibles[0][index],
var_vertex_1_ycoordinate)
index = obj.extensible_field_index("Vertex 1 Z-coordinate")
self.assertAlmostEqual(
idf2.shadingsitedetaileds[0].extensibles[0][index],
var_vertex_1_zcoordinate)
def test_create_zonerefrigerationdoormixing(self):
pyidf.validation_level = ValidationLevel.error
obj = ZoneRefrigerationDoorMixing()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_zone_1_name = "object-list|Zone 1 Name"
obj.zone_1_name = var_zone_1_name
# object-list
var_zone_2_name = "object-list|Zone 2 Name"
obj.zone_2_name = var_zone_2_name
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# real
var_door_height = 25.0
obj.door_height = var_door_height
# real
var_door_area = 200.0
obj.door_area = var_door_area
# alpha
var_door_protection_type = "None"
obj.door_protection_type = var_door_protection_type
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.zonerefrigerationdoormixings[0].name, var_name)
self.assertEqual(idf2.zonerefrigerationdoormixings[0].zone_1_name,
var_zone_1_name)
self.assertEqual(idf2.zonerefrigerationdoormixings[0].zone_2_name,
var_zone_2_name)
self.assertEqual(idf2.zonerefrigerationdoormixings[0].schedule_name,
var_schedule_name)
self.assertAlmostEqual(
idf2.zonerefrigerationdoormixings[0].door_height, var_door_height)
self.assertAlmostEqual(idf2.zonerefrigerationdoormixings[0].door_area,
var_door_area)
self.assertEqual(
idf2.zonerefrigerationdoormixings[0].door_protection_type,
var_door_protection_type)
def test_create_solarcollectorunglazedtranspiredmultisystem(self):
pyidf.validation_level = ValidationLevel.error
obj = SolarCollectorUnglazedTranspiredMultisystem()
# object-list
var_solar_collector_name = "object-list|Solar Collector Name"
obj.solar_collector_name = var_solar_collector_name
paras = []
var_outdoor_air_system_1_collector_inlet_node = "node|Outdoor Air System 1 Collector Inlet Node"
paras.append(var_outdoor_air_system_1_collector_inlet_node)
var_outdoor_air_system_1_collector_outlet_node = "node|Outdoor Air System 1 Collector Outlet Node"
paras.append(var_outdoor_air_system_1_collector_outlet_node)
var_outdoor_air_system_1_mixed_air_node = "node|Outdoor Air System 1 Mixed Air Node"
paras.append(var_outdoor_air_system_1_mixed_air_node)
var_outdoor_air_system_1_zone_node = "node|Outdoor Air System 1 Zone Node"
paras.append(var_outdoor_air_system_1_zone_node)
obj.add_extensible(*paras)
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.solarcollectorunglazedtranspiredmultisystems[0].
solar_collector_name, var_solar_collector_name)
index = obj.extensible_field_index(
"Outdoor Air System 1 Collector Inlet Node")
self.assertEqual(
idf2.solarcollectorunglazedtranspiredmultisystems[0].extensibles[0]
[index], var_outdoor_air_system_1_collector_inlet_node)
index = obj.extensible_field_index(
"Outdoor Air System 1 Collector Outlet Node")
self.assertEqual(
idf2.solarcollectorunglazedtranspiredmultisystems[0].extensibles[0]
[index], var_outdoor_air_system_1_collector_outlet_node)
index = obj.extensible_field_index(
"Outdoor Air System 1 Mixed Air Node")
self.assertEqual(
idf2.solarcollectorunglazedtranspiredmultisystems[0].extensibles[0]
[index], var_outdoor_air_system_1_mixed_air_node)
index = obj.extensible_field_index("Outdoor Air System 1 Zone Node")
self.assertEqual(
idf2.solarcollectorunglazedtranspiredmultisystems[0].extensibles[0]
[index], var_outdoor_air_system_1_zone_node)
def test_create_fanperformancenightventilation(self):
pyidf.validation_level = ValidationLevel.error
obj = FanPerformanceNightVentilation()
# object-list
var_fan_name = "object-list|Fan Name"
obj.fan_name = var_fan_name
# real
var_fan_total_efficiency = 0.50005
obj.fan_total_efficiency = var_fan_total_efficiency
# real
var_pressure_rise = 3.3
obj.pressure_rise = var_pressure_rise
# real
var_maximum_flow_rate = 0.0
obj.maximum_flow_rate = var_maximum_flow_rate
# real
var_motor_efficiency = 0.50005
obj.motor_efficiency = var_motor_efficiency
# real
var_motor_in_airstream_fraction = 0.5
obj.motor_in_airstream_fraction = var_motor_in_airstream_fraction
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.fanperformancenightventilations[0].fan_name,
var_fan_name)
self.assertAlmostEqual(
idf2.fanperformancenightventilations[0].fan_total_efficiency,
var_fan_total_efficiency)
self.assertAlmostEqual(
idf2.fanperformancenightventilations[0].pressure_rise,
var_pressure_rise)
self.assertAlmostEqual(
idf2.fanperformancenightventilations[0].maximum_flow_rate,
var_maximum_flow_rate)
self.assertAlmostEqual(
idf2.fanperformancenightventilations[0].motor_efficiency,
var_motor_efficiency)
self.assertAlmostEqual(
idf2.fanperformancenightventilations[0].
motor_in_airstream_fraction, var_motor_in_airstream_fraction)
def test_create_groundheattransferslabmanualgrid(self):
pyidf.validation_level = ValidationLevel.error
obj = GroundHeatTransferSlabManualGrid()
# real
var_nx_number_of_cells_in_the_x_direction = 1.0
obj.nx_number_of_cells_in_the_x_direction = var_nx_number_of_cells_in_the_x_direction
# real
var_ny_number_of_cells_in_the_y_direction = 1.0
obj.ny_number_of_cells_in_the_y_direction = var_ny_number_of_cells_in_the_y_direction
# real
var_nz_number_of_cells_in_the_z_direction = 1.0
obj.nz_number_of_cells_in_the_z_direction = var_nz_number_of_cells_in_the_z_direction
# real
var_ibox_x_direction_cell_indicator_of_slab_edge = 4.4
obj.ibox_x_direction_cell_indicator_of_slab_edge = var_ibox_x_direction_cell_indicator_of_slab_edge
# real
var_jbox_y_direction_cell_indicator_of_slab_edge = 5.5
obj.jbox_y_direction_cell_indicator_of_slab_edge = var_jbox_y_direction_cell_indicator_of_slab_edge
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertAlmostEqual(
idf2.groundheattransferslabmanualgrids[0].
nx_number_of_cells_in_the_x_direction,
var_nx_number_of_cells_in_the_x_direction)
self.assertAlmostEqual(
idf2.groundheattransferslabmanualgrids[0].
ny_number_of_cells_in_the_y_direction,
var_ny_number_of_cells_in_the_y_direction)
self.assertAlmostEqual(
idf2.groundheattransferslabmanualgrids[0].
nz_number_of_cells_in_the_z_direction,
var_nz_number_of_cells_in_the_z_direction)
self.assertAlmostEqual(
idf2.groundheattransferslabmanualgrids[0].
ibox_x_direction_cell_indicator_of_slab_edge,
var_ibox_x_direction_cell_indicator_of_slab_edge)
self.assertAlmostEqual(
idf2.groundheattransferslabmanualgrids[0].
jbox_y_direction_cell_indicator_of_slab_edge,
var_jbox_y_direction_cell_indicator_of_slab_edge)
def test_create_surfacepropertiesvaporcoefficients(self):
pyidf.validation_level = ValidationLevel.error
obj = SurfacePropertiesVaporCoefficients()
# object-list
var_surface_name = "object-list|Surface Name"
obj.surface_name = var_surface_name
# alpha
var_constant_external_vapor_transfer_coefficient = "Yes"
obj.constant_external_vapor_transfer_coefficient = var_constant_external_vapor_transfer_coefficient
# real
var_external_vapor_coefficient_value = 0.0
obj.external_vapor_coefficient_value = var_external_vapor_coefficient_value
# alpha
var_constant_internal_vapor_transfer_coefficient = "Yes"
obj.constant_internal_vapor_transfer_coefficient = var_constant_internal_vapor_transfer_coefficient
# real
var_internal_vapor_coefficient_value = 0.0
obj.internal_vapor_coefficient_value = var_internal_vapor_coefficient_value
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.surfacepropertiesvaporcoefficientss[0].surface_name,
var_surface_name)
self.assertEqual(
idf2.surfacepropertiesvaporcoefficientss[0].
constant_external_vapor_transfer_coefficient,
var_constant_external_vapor_transfer_coefficient)
self.assertAlmostEqual(
idf2.surfacepropertiesvaporcoefficientss[0].
external_vapor_coefficient_value,
var_external_vapor_coefficient_value)
self.assertEqual(
idf2.surfacepropertiesvaporcoefficientss[0].
constant_internal_vapor_transfer_coefficient,
var_constant_internal_vapor_transfer_coefficient)
self.assertAlmostEqual(
idf2.surfacepropertiesvaporcoefficientss[0].
internal_vapor_coefficient_value,
var_internal_vapor_coefficient_value)
def test_create_outputtabletimebins(self):
pyidf.validation_level = ValidationLevel.error
obj = OutputTableTimeBins()
# alpha
var_key_value = "Key Value"
obj.key_value = var_key_value
# external-list
var_variable_name = "external-list|Variable Name"
obj.variable_name = var_variable_name
# real
var_interval_start = 3.3
obj.interval_start = var_interval_start
# real
var_interval_size = 4.4
obj.interval_size = var_interval_size
# integer
var_interval_count = 10
obj.interval_count = var_interval_count
# object-list
var_schedule_name = "object-list|Schedule Name"
obj.schedule_name = var_schedule_name
# alpha
var_variable_type = "Energy"
obj.variable_type = var_variable_type
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.outputtabletimebinss[0].key_value, var_key_value)
self.assertEqual(idf2.outputtabletimebinss[0].variable_name,
var_variable_name)
self.assertAlmostEqual(idf2.outputtabletimebinss[0].interval_start,
var_interval_start)
self.assertAlmostEqual(idf2.outputtabletimebinss[0].interval_size,
var_interval_size)
self.assertEqual(idf2.outputtabletimebinss[0].interval_count,
var_interval_count)
self.assertEqual(idf2.outputtabletimebinss[0].schedule_name,
var_schedule_name)
self.assertEqual(idf2.outputtabletimebinss[0].variable_type,
var_variable_type)
def test_create_shadingpropertyreflectance(self):
pyidf.validation_level = ValidationLevel.error
obj = ShadingPropertyReflectance()
# object-list
var_shading_surface_name = "object-list|Shading Surface Name"
obj.shading_surface_name = var_shading_surface_name
# real
var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface = 0.5
obj.diffuse_solar_reflectance_of_unglazed_part_of_shading_surface = var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface
# real
var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface = 0.5
obj.diffuse_visible_reflectance_of_unglazed_part_of_shading_surface = var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface
# real
var_fraction_of_shading_surface_that_is_glazed = 0.5
obj.fraction_of_shading_surface_that_is_glazed = var_fraction_of_shading_surface_that_is_glazed
# alpha
var_glazing_construction_name = "Glazing Construction Name"
obj.glazing_construction_name = var_glazing_construction_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.shadingpropertyreflectances[0].shading_surface_name,
var_shading_surface_name)
self.assertAlmostEqual(
idf2.shadingpropertyreflectances[0].
diffuse_solar_reflectance_of_unglazed_part_of_shading_surface,
var_diffuse_solar_reflectance_of_unglazed_part_of_shading_surface)
self.assertAlmostEqual(
idf2.shadingpropertyreflectances[0].
diffuse_visible_reflectance_of_unglazed_part_of_shading_surface,
var_diffuse_visible_reflectance_of_unglazed_part_of_shading_surface
)
self.assertAlmostEqual(
idf2.shadingpropertyreflectances[0].
fraction_of_shading_surface_that_is_glazed,
var_fraction_of_shading_surface_that_is_glazed)
self.assertEqual(
idf2.shadingpropertyreflectances[0].glazing_construction_name,
var_glazing_construction_name)
def test_create_outputtablesummaryreports(self):
pyidf.validation_level = ValidationLevel.error
obj = OutputTableSummaryReports()
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
def test_create_lead_input(self):
pyidf.validation_level = ValidationLevel.error
obj = LeadInput()
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
def test_create_airflownetworkmultizonecomponentsimpleopening(self):
pyidf.validation_level = ValidationLevel.error
obj = AirflowNetworkMultiZoneComponentSimpleOpening()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_air_mass_flow_coefficient_when_opening_is_closed = 0.0001
obj.air_mass_flow_coefficient_when_opening_is_closed = var_air_mass_flow_coefficient_when_opening_is_closed
# real
var_air_mass_flow_exponent_when_opening_is_closed = 0.75
obj.air_mass_flow_exponent_when_opening_is_closed = var_air_mass_flow_exponent_when_opening_is_closed
# real
var_minimum_density_difference_for_twoway_flow = 0.0001
obj.minimum_density_difference_for_twoway_flow = var_minimum_density_difference_for_twoway_flow
# real
var_discharge_coefficient = 0.0001
obj.discharge_coefficient = var_discharge_coefficient
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.airflownetworkmultizonecomponentsimpleopenings[0].name,
var_name)
self.assertAlmostEqual(
idf2.airflownetworkmultizonecomponentsimpleopenings[0].
air_mass_flow_coefficient_when_opening_is_closed,
var_air_mass_flow_coefficient_when_opening_is_closed)
self.assertAlmostEqual(
idf2.airflownetworkmultizonecomponentsimpleopenings[0].
air_mass_flow_exponent_when_opening_is_closed,
var_air_mass_flow_exponent_when_opening_is_closed)
self.assertAlmostEqual(
idf2.airflownetworkmultizonecomponentsimpleopenings[0].
minimum_density_difference_for_twoway_flow,
var_minimum_density_difference_for_twoway_flow)
self.assertAlmostEqual(
idf2.airflownetworkmultizonecomponentsimpleopenings[0].
discharge_coefficient, var_discharge_coefficient)
def test_create_designspecificationzoneairdistribution(self):
pyidf.validation_level = ValidationLevel.error
obj = DesignSpecificationZoneAirDistribution()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_zone_air_distribution_effectiveness_in_cooling_mode = 0.0001
obj.zone_air_distribution_effectiveness_in_cooling_mode = var_zone_air_distribution_effectiveness_in_cooling_mode
# real
var_zone_air_distribution_effectiveness_in_heating_mode = 0.0001
obj.zone_air_distribution_effectiveness_in_heating_mode = var_zone_air_distribution_effectiveness_in_heating_mode
# object-list
var_zone_air_distribution_effectiveness_schedule_name = "object-list|Zone Air Distribution Effectiveness Schedule Name"
obj.zone_air_distribution_effectiveness_schedule_name = var_zone_air_distribution_effectiveness_schedule_name
# real
var_zone_secondary_recirculation_fraction = 0.0
obj.zone_secondary_recirculation_fraction = var_zone_secondary_recirculation_fraction
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.designspecificationzoneairdistributions[0].name,
var_name)
self.assertAlmostEqual(
idf2.designspecificationzoneairdistributions[0].
zone_air_distribution_effectiveness_in_cooling_mode,
var_zone_air_distribution_effectiveness_in_cooling_mode)
self.assertAlmostEqual(
idf2.designspecificationzoneairdistributions[0].
zone_air_distribution_effectiveness_in_heating_mode,
var_zone_air_distribution_effectiveness_in_heating_mode)
self.assertEqual(
idf2.designspecificationzoneairdistributions[0].
zone_air_distribution_effectiveness_schedule_name,
var_zone_air_distribution_effectiveness_schedule_name)
self.assertAlmostEqual(
idf2.designspecificationzoneairdistributions[0].
zone_secondary_recirculation_fraction,
var_zone_secondary_recirculation_fraction)
def test_create_surfaceconvectionalgorithmoutsideusercurve(self):
pyidf.validation_level = ValidationLevel.error
obj = SurfaceConvectionAlgorithmOutsideUserCurve()
# alpha
var_name = "Name"
obj.name = var_name
# alpha
var_wind_speed_type_for_curve = "WeatherFile"
obj.wind_speed_type_for_curve = var_wind_speed_type_for_curve
# object-list
var_hf_function_of_wind_speed_curve_name = "object-list|Hf Function of Wind Speed Curve Name"
obj.hf_function_of_wind_speed_curve_name = var_hf_function_of_wind_speed_curve_name
# object-list
var_hn_function_of_temperature_difference_curve_name = "object-list|Hn Function of Temperature Difference Curve Name"
obj.hn_function_of_temperature_difference_curve_name = var_hn_function_of_temperature_difference_curve_name
# object-list
var_hn_function_of_temperature_difference_divided_by_height_curve_name = "object-list|Hn Function of Temperature Difference Divided by Height Curve Name"
obj.hn_function_of_temperature_difference_divided_by_height_curve_name = var_hn_function_of_temperature_difference_divided_by_height_curve_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.surfaceconvectionalgorithmoutsideusercurves[0].name, var_name)
self.assertEqual(
idf2.surfaceconvectionalgorithmoutsideusercurves[0].
wind_speed_type_for_curve, var_wind_speed_type_for_curve)
self.assertEqual(
idf2.surfaceconvectionalgorithmoutsideusercurves[0].
hf_function_of_wind_speed_curve_name,
var_hf_function_of_wind_speed_curve_name)
self.assertEqual(
idf2.surfaceconvectionalgorithmoutsideusercurves[0].
hn_function_of_temperature_difference_curve_name,
var_hn_function_of_temperature_difference_curve_name)
self.assertEqual(
idf2.surfaceconvectionalgorithmoutsideusercurves[0].
hn_function_of_temperature_difference_divided_by_height_curve_name,
var_hn_function_of_temperature_difference_divided_by_height_curve_name
)
def test_create_solarcollectorflatplatewater(self):
pyidf.validation_level = ValidationLevel.error
obj = SolarCollectorFlatPlateWater()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_solarcollectorperformance_name = "object-list|SolarCollectorPerformance Name"
obj.solarcollectorperformance_name = var_solarcollectorperformance_name
# object-list
var_surface_name = "object-list|Surface Name"
obj.surface_name = var_surface_name
# node
var_inlet_node_name = "node|Inlet Node Name"
obj.inlet_node_name = var_inlet_node_name
# node
var_outlet_node_name = "node|Outlet Node Name"
obj.outlet_node_name = var_outlet_node_name
# real
var_maximum_flow_rate = 0.0001
obj.maximum_flow_rate = var_maximum_flow_rate
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.solarcollectorflatplatewaters[0].name, var_name)
self.assertEqual(
idf2.solarcollectorflatplatewaters[0].
solarcollectorperformance_name, var_solarcollectorperformance_name)
self.assertEqual(idf2.solarcollectorflatplatewaters[0].surface_name,
var_surface_name)
self.assertEqual(idf2.solarcollectorflatplatewaters[0].inlet_node_name,
var_inlet_node_name)
self.assertEqual(
idf2.solarcollectorflatplatewaters[0].outlet_node_name,
var_outlet_node_name)
self.assertAlmostEqual(
idf2.solarcollectorflatplatewaters[0].maximum_flow_rate,
var_maximum_flow_rate)
def test_create_building(self):
pyidf.validation_level = ValidationLevel.error
obj = Building()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_north_axis = 2.2
obj.north_axis = var_north_axis
# alpha
var_terrain = "Country"
obj.terrain = var_terrain
# real
var_loads_convergence_tolerance_value = 0.25005
obj.loads_convergence_tolerance_value = var_loads_convergence_tolerance_value
# real
var_temperature_convergence_tolerance_value = 0.25005
obj.temperature_convergence_tolerance_value = var_temperature_convergence_tolerance_value
# alpha
var_solar_distribution = "MinimalShadowing"
obj.solar_distribution = var_solar_distribution
# integer
var_maximum_number_of_warmup_days = 1
obj.maximum_number_of_warmup_days = var_maximum_number_of_warmup_days
# integer
var_minimum_number_of_warmup_days = 1
obj.minimum_number_of_warmup_days = var_minimum_number_of_warmup_days
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.buildings[0].name, var_name)
self.assertAlmostEqual(idf2.buildings[0].north_axis, var_north_axis)
self.assertEqual(idf2.buildings[0].terrain, var_terrain)
self.assertAlmostEqual(idf2.buildings[0].loads_convergence_tolerance_value, var_loads_convergence_tolerance_value)
self.assertAlmostEqual(idf2.buildings[0].temperature_convergence_tolerance_value, var_temperature_convergence_tolerance_value)
self.assertEqual(idf2.buildings[0].solar_distribution, var_solar_distribution)
self.assertEqual(idf2.buildings[0].maximum_number_of_warmup_days, var_maximum_number_of_warmup_days)
self.assertEqual(idf2.buildings[0].minimum_number_of_warmup_days, var_minimum_number_of_warmup_days)
def test_create_setpointmanagerreturntemperaturehotwater(self):
pyidf.validation_level = ValidationLevel.error
obj = SetpointManagerReturnTemperatureHotWater()
# alpha
var_name = "Name"
obj.name = var_name
# node
var_plant_loop_supply_outlet_node = "node|Plant Loop Supply Outlet Node"
obj.plant_loop_supply_outlet_node = var_plant_loop_supply_outlet_node
# node
var_plant_loop_supply_inlet_node = "node|Plant Loop Supply Inlet Node"
obj.plant_loop_supply_inlet_node = var_plant_loop_supply_inlet_node
# real
var_minimum_supply_temperature_setpoint = 4.4
obj.minimum_supply_temperature_setpoint = var_minimum_supply_temperature_setpoint
# real
var_maximum_supply_temperature_setpoint = 5.5
obj.maximum_supply_temperature_setpoint = var_maximum_supply_temperature_setpoint
# alpha
var_return_temperature_setpoint_input_type = "Constant"
obj.return_temperature_setpoint_input_type = var_return_temperature_setpoint_input_type
# real
var_return_temperature_setpoint_constant_value = 7.7
obj.return_temperature_setpoint_constant_value = var_return_temperature_setpoint_constant_value
# object-list
var_return_temperature_setpoint_schedule_name = "object-list|Return Temperature Setpoint Schedule Name"
obj.return_temperature_setpoint_schedule_name = var_return_temperature_setpoint_schedule_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].name, var_name)
self.assertEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].plant_loop_supply_outlet_node, var_plant_loop_supply_outlet_node)
self.assertEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].plant_loop_supply_inlet_node, var_plant_loop_supply_inlet_node)
self.assertAlmostEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].minimum_supply_temperature_setpoint, var_minimum_supply_temperature_setpoint)
self.assertAlmostEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].maximum_supply_temperature_setpoint, var_maximum_supply_temperature_setpoint)
self.assertEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].return_temperature_setpoint_input_type, var_return_temperature_setpoint_input_type)
self.assertAlmostEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].return_temperature_setpoint_constant_value, var_return_temperature_setpoint_constant_value)
self.assertEqual(idf2.setpointmanagerreturntemperaturehotwaters[0].return_temperature_setpoint_schedule_name, var_return_temperature_setpoint_schedule_name)
def test_create_refrigerationcondensercascade(self):
pyidf.validation_level = ValidationLevel.error
obj = RefrigerationCondenserCascade()
# alpha
var_name = "Name"
obj.name = var_name
# real
var_rated_condensing_temperature = 2.2
obj.rated_condensing_temperature = var_rated_condensing_temperature
# real
var_rated_approach_temperature_difference = 0.0001
obj.rated_approach_temperature_difference = var_rated_approach_temperature_difference
# real
var_rated_effective_total_heat_rejection_rate = 0.0001
obj.rated_effective_total_heat_rejection_rate = var_rated_effective_total_heat_rejection_rate
# alpha
var_condensing_temperature_control_type = "Fixed"
obj.condensing_temperature_control_type = var_condensing_temperature_control_type
# real
var_condenser_refrigerant_operating_charge_inventory = 6.6
obj.condenser_refrigerant_operating_charge_inventory = var_condenser_refrigerant_operating_charge_inventory
# real
var_condensate_receiver_refrigerant_inventory = 7.7
obj.condensate_receiver_refrigerant_inventory = var_condensate_receiver_refrigerant_inventory
# real
var_condensate_piping_refrigerant_inventory = 8.8
obj.condensate_piping_refrigerant_inventory = var_condensate_piping_refrigerant_inventory
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(idf2.refrigerationcondensercascades[0].name, var_name)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].rated_condensing_temperature, var_rated_condensing_temperature)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].rated_approach_temperature_difference, var_rated_approach_temperature_difference)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].rated_effective_total_heat_rejection_rate, var_rated_effective_total_heat_rejection_rate)
self.assertEqual(idf2.refrigerationcondensercascades[0].condensing_temperature_control_type, var_condensing_temperature_control_type)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].condenser_refrigerant_operating_charge_inventory, var_condenser_refrigerant_operating_charge_inventory)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].condensate_receiver_refrigerant_inventory, var_condensate_receiver_refrigerant_inventory)
self.assertAlmostEqual(idf2.refrigerationcondensercascades[0].condensate_piping_refrigerant_inventory, var_condensate_piping_refrigerant_inventory)
def test_create_setpointmanagermultizoneminimumhumidityaverage(self):
pyidf.validation_level = ValidationLevel.error
obj = SetpointManagerMultiZoneMinimumHumidityAverage()
# alpha
var_name = "Name"
obj.name = var_name
# object-list
var_hvac_air_loop_name = "object-list|HVAC Air Loop Name"
obj.hvac_air_loop_name = var_hvac_air_loop_name
# real
var_minimum_setpoint_humidity_ratio = 0.0001
obj.minimum_setpoint_humidity_ratio = var_minimum_setpoint_humidity_ratio
# real
var_maximum_setpoint_humidity_ratio = 0.0001
obj.maximum_setpoint_humidity_ratio = var_maximum_setpoint_humidity_ratio
# node
var_setpoint_node_or_nodelist_name = "node|Setpoint Node or NodeList Name"
obj.setpoint_node_or_nodelist_name = var_setpoint_node_or_nodelist_name
idf = IDF()
idf.add(obj)
idf.save(self.path, check=False)
with open(self.path, mode='r') as f:
for line in f:
log.debug(line.strip())
idf2 = IDF(self.path)
self.assertEqual(
idf2.setpointmanagermultizoneminimumhumidityaverages[0].name,
var_name)
self.assertEqual(
idf2.setpointmanagermultizoneminimumhumidityaverages[0].
hvac_air_loop_name, var_hvac_air_loop_name)
self.assertAlmostEqual(
idf2.setpointmanagermultizoneminimumhumidityaverages[0].
minimum_setpoint_humidity_ratio,
var_minimum_setpoint_humidity_ratio)
self.assertAlmostEqual(
idf2.setpointmanagermultizoneminimumhumidityaverages[0].
maximum_setpoint_humidity_ratio,
var_maximum_setpoint_humidity_ratio)
self.assertEqual(
idf2.setpointmanagermultizoneminimumhumidityaverages[0].
setpoint_node_or_nodelist_name, var_setpoint_node_or_nodelist_name)
