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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_outputdebuggingdata(self): pyidf.validation_level = ValidationLevel.error obj = OutputDebuggingData() # real var_report_debugging_data = 1.1 obj.report_debugging_data = var_report_debugging_data # real var_report_during_warmup = 2.2 obj.report_during_warmup = var_report_during_warmup 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.outputdebuggingdatas[0].report_debugging_data, var_report_debugging_data) self.assertAlmostEqual( idf2.outputdebuggingdatas[0].report_during_warmup, var_report_during_warmup)
def test_create_zonegroup(self): pyidf.validation_level = ValidationLevel.error obj = ZoneGroup() # alpha var_name = "Name" obj.name = var_name # object-list var_zone_list_name = "object-list|Zone List Name" obj.zone_list_name = var_zone_list_name # integer var_zone_list_multiplier = 1 obj.zone_list_multiplier = var_zone_list_multiplier 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.zonegroups[0].name, var_name) self.assertEqual(idf2.zonegroups[0].zone_list_name, var_zone_list_name) self.assertEqual(idf2.zonegroups[0].zone_list_multiplier, var_zone_list_multiplier)
def test_create_zonecontrolthermostatoperativetemperature(self): pyidf.validation_level = ValidationLevel.error obj = ZoneControlThermostatOperativeTemperature() # object-list var_thermostat_name = "object-list|Thermostat Name" obj.thermostat_name = var_thermostat_name # alpha var_radiative_fraction_input_mode = "Constant" obj.radiative_fraction_input_mode = var_radiative_fraction_input_mode # real var_fixed_radiative_fraction = 0.44995 obj.fixed_radiative_fraction = var_fixed_radiative_fraction # object-list var_radiative_fraction_schedule_name = "object-list|Radiative Fraction Schedule Name" obj.radiative_fraction_schedule_name = var_radiative_fraction_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.zonecontrolthermostatoperativetemperatures[0].thermostat_name, var_thermostat_name) self.assertEqual(idf2.zonecontrolthermostatoperativetemperatures[0].radiative_fraction_input_mode, var_radiative_fraction_input_mode) self.assertAlmostEqual(idf2.zonecontrolthermostatoperativetemperatures[0].fixed_radiative_fraction, var_fixed_radiative_fraction) self.assertEqual(idf2.zonecontrolthermostatoperativetemperatures[0].radiative_fraction_schedule_name, var_radiative_fraction_schedule_name)
def test_create_daylightingdevicelightwell(self): pyidf.validation_level = ValidationLevel.error obj = DaylightingDeviceLightWell() # object-list var_exterior_window_name = "object-list|Exterior Window Name" obj.exterior_window_name = var_exterior_window_name # real var_height_of_well = 0.0 obj.height_of_well = var_height_of_well # real var_perimeter_of_bottom_of_well = 0.0001 obj.perimeter_of_bottom_of_well = var_perimeter_of_bottom_of_well # real var_area_of_bottom_of_well = 0.0001 obj.area_of_bottom_of_well = var_area_of_bottom_of_well # real var_visible_reflectance_of_well_walls = 0.5 obj.visible_reflectance_of_well_walls = var_visible_reflectance_of_well_walls 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.daylightingdevicelightwells[0].exterior_window_name, var_exterior_window_name) self.assertAlmostEqual(idf2.daylightingdevicelightwells[0].height_of_well, var_height_of_well) self.assertAlmostEqual(idf2.daylightingdevicelightwells[0].perimeter_of_bottom_of_well, var_perimeter_of_bottom_of_well) self.assertAlmostEqual(idf2.daylightingdevicelightwells[0].area_of_bottom_of_well, var_area_of_bottom_of_well) self.assertAlmostEqual(idf2.daylightingdevicelightwells[0].visible_reflectance_of_well_walls, var_visible_reflectance_of_well_walls)
def test_create_energymanagementsystemsensor(self): pyidf.validation_level = ValidationLevel.error obj = EnergyManagementSystemSensor() # alpha var_name = "Name" obj.name = var_name # alpha var_outputvariable_or_outputmeter_index_key_name = "Output:Variable or Output:Meter Index Key Name" obj.outputvariable_or_outputmeter_index_key_name = var_outputvariable_or_outputmeter_index_key_name # external-list var_outputvariable_or_outputmeter_name = "external-list|Output:Variable or Output:Meter Name" obj.outputvariable_or_outputmeter_name = var_outputvariable_or_outputmeter_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.energymanagementsystemsensors[0].name, var_name) self.assertEqual(idf2.energymanagementsystemsensors[0].outputvariable_or_outputmeter_index_key_name, var_outputvariable_or_outputmeter_index_key_name) self.assertEqual(idf2.energymanagementsystemsensors[0].outputvariable_or_outputmeter_name, var_outputvariable_or_outputmeter_name)
def test_create_externalinterfacefunctionalmockupunitimportfromvariable(self): pyidf.validation_level = ValidationLevel.error obj = ExternalInterfaceFunctionalMockupUnitImportFromVariable() # alpha var_outputvariable_index_key_name = "Output:Variable Index Key Name" obj.outputvariable_index_key_name = var_outputvariable_index_key_name # external-list var_outputvariable_name = "external-list|Output:Variable Name" obj.outputvariable_name = var_outputvariable_name # object-list var_fmu_file_name = "object-list|FMU File Name" obj.fmu_file_name = var_fmu_file_name # alpha var_fmu_instance_name = "FMU Instance Name" obj.fmu_instance_name = var_fmu_instance_name # alpha var_fmu_variable_name = "FMU Variable Name" obj.fmu_variable_name = var_fmu_variable_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.externalinterfacefunctionalmockupunitimportfromvariables[0].outputvariable_index_key_name, var_outputvariable_index_key_name) self.assertEqual(idf2.externalinterfacefunctionalmockupunitimportfromvariables[0].outputvariable_name, var_outputvariable_name) self.assertEqual(idf2.externalinterfacefunctionalmockupunitimportfromvariables[0].fmu_file_name, var_fmu_file_name) self.assertEqual(idf2.externalinterfacefunctionalmockupunitimportfromvariables[0].fmu_instance_name, var_fmu_instance_name) self.assertEqual(idf2.externalinterfacefunctionalmockupunitimportfromvariables[0].fmu_variable_name, var_fmu_variable_name)
def test_create_sitegroundtemperatureundisturbedkusudaachenbach(self): pyidf.validation_level = ValidationLevel.error obj = SiteGroundTemperatureUndisturbedKusudaAchenbach() # 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_temperature = 5.5 obj.average_soil_surface_temperature = var_average_soil_surface_temperature # real var_average_amplitude_of_surface_temperature = 0.0 obj.average_amplitude_of_surface_temperature = var_average_amplitude_of_surface_temperature # real var_phase_shift_of_minimum_surface_temperature = 182.49995 obj.phase_shift_of_minimum_surface_temperature = var_phase_shift_of_minimum_surface_temperature 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.sitegroundtemperatureundisturbedkusudaachenbachs[0].name, var_name) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. soil_thermal_conductivity, var_soil_thermal_conductivity) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. soil_density, var_soil_density) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. soil_specific_heat, var_soil_specific_heat) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. average_soil_surface_temperature, var_average_soil_surface_temperature) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. average_amplitude_of_surface_temperature, var_average_amplitude_of_surface_temperature) self.assertAlmostEqual( idf2.sitegroundtemperatureundisturbedkusudaachenbachs[0]. phase_shift_of_minimum_surface_temperature, var_phase_shift_of_minimum_surface_temperature)
def test_create_availabilitymanagerhightemperatureturnon(self): pyidf.validation_level = ValidationLevel.error obj = AvailabilityManagerHighTemperatureTurnOn() # alpha var_name = "Name" obj.name = var_name # node var_sensor_node_name = "node|Sensor Node Name" obj.sensor_node_name = var_sensor_node_name # real var_temperature = 3.3 obj.temperature = var_temperature 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.availabilitymanagerhightemperatureturnons[0].name, var_name) self.assertEqual( idf2.availabilitymanagerhightemperatureturnons[0].sensor_node_name, var_sensor_node_name) self.assertAlmostEqual( idf2.availabilitymanagerhightemperatureturnons[0].temperature, var_temperature)
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_setpointmanagermultizonemaximumhumidityaverage(self): pyidf.validation_level = ValidationLevel.error obj = SetpointManagerMultiZoneMaximumHumidityAverage() # 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.setpointmanagermultizonemaximumhumidityaverages[0].name, var_name) self.assertEqual(idf2.setpointmanagermultizonemaximumhumidityaverages[0].hvac_air_loop_name, var_hvac_air_loop_name) self.assertAlmostEqual(idf2.setpointmanagermultizonemaximumhumidityaverages[0].minimum_setpoint_humidity_ratio, var_minimum_setpoint_humidity_ratio) self.assertAlmostEqual(idf2.setpointmanagermultizonemaximumhumidityaverages[0].maximum_setpoint_humidity_ratio, var_maximum_setpoint_humidity_ratio) self.assertEqual(idf2.setpointmanagermultizonemaximumhumidityaverages[0].setpoint_node_or_nodelist_name, var_setpoint_node_or_nodelist_name)
def test_create_outputvariabledictionary(self): pyidf.validation_level = ValidationLevel.error obj = OutputVariableDictionary() # alpha var_key_field = "IDF" obj.key_field = var_key_field # alpha var_sort_option = "Name" obj.sort_option = var_sort_option 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.outputvariabledictionarys[0].key_field, var_key_field) self.assertEqual(idf2.outputvariabledictionarys[0].sort_option, var_sort_option)
def test_create_daylightingdelightcomplexfenestration(self): pyidf.validation_level = ValidationLevel.error obj = DaylightingDelightComplexFenestration() # alpha var_name = "Name" obj.name = var_name # alpha var_complex_fenestration_type = "Complex Fenestration Type" obj.complex_fenestration_type = var_complex_fenestration_type # object-list var_building_surface_name = "object-list|Building Surface Name" obj.building_surface_name = var_building_surface_name # object-list var_window_name = "object-list|Window Name" obj.window_name = var_window_name # real var_fenestration_rotation = 5.5 obj.fenestration_rotation = var_fenestration_rotation 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.daylightingdelightcomplexfenestrations[0].name, var_name) self.assertEqual(idf2.daylightingdelightcomplexfenestrations[0].complex_fenestration_type, var_complex_fenestration_type) self.assertEqual(idf2.daylightingdelightcomplexfenestrations[0].building_surface_name, var_building_surface_name) self.assertEqual(idf2.daylightingdelightcomplexfenestrations[0].window_name, var_window_name) self.assertAlmostEqual(idf2.daylightingdelightcomplexfenestrations[0].fenestration_rotation, var_fenestration_rotation)
def test_create_glazeddoorinterzone(self): pyidf.validation_level = ValidationLevel.error obj = GlazedDoorInterzone() # 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 # object-list var_outside_boundary_condition_object = "object-list|Outside Boundary Condition Object" obj.outside_boundary_condition_object = var_outside_boundary_condition_object # real var_multiplier = 1.0 obj.multiplier = var_multiplier # real var_starting_x_coordinate = 6.6 obj.starting_x_coordinate = var_starting_x_coordinate # real var_starting_z_coordinate = 7.7 obj.starting_z_coordinate = var_starting_z_coordinate # real var_length = 8.8 obj.length = var_length # real var_height = 9.9 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.glazeddoorinterzones[0].name, var_name) self.assertEqual(idf2.glazeddoorinterzones[0].construction_name, var_construction_name) self.assertEqual(idf2.glazeddoorinterzones[0].building_surface_name, var_building_surface_name) self.assertEqual( idf2.glazeddoorinterzones[0].outside_boundary_condition_object, var_outside_boundary_condition_object) self.assertAlmostEqual(idf2.glazeddoorinterzones[0].multiplier, var_multiplier) self.assertAlmostEqual( idf2.glazeddoorinterzones[0].starting_x_coordinate, var_starting_x_coordinate) self.assertAlmostEqual( idf2.glazeddoorinterzones[0].starting_z_coordinate, var_starting_z_coordinate) self.assertAlmostEqual(idf2.glazeddoorinterzones[0].length, var_length) self.assertAlmostEqual(idf2.glazeddoorinterzones[0].height, var_height)
def test_create_outputmetercumulativemeterfileonly(self): pyidf.validation_level = ValidationLevel.error obj = OutputMeterCumulativeMeterFileOnly() # external-list var_name = "external-list|Name" obj.name = var_name # alpha var_reporting_frequency = "Timestep" obj.reporting_frequency = var_reporting_frequency 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.outputmetercumulativemeterfileonlys[0].name, var_name) self.assertEqual( idf2.outputmetercumulativemeterfileonlys[0].reporting_frequency, var_reporting_frequency)
def test_create_lifecyclecostuseadjustment(self): pyidf.validation_level = ValidationLevel.error obj = LifeCycleCostUseAdjustment() # alpha var_name = "Name" obj.name = var_name # alpha var_resource = "Electricity" obj.resource = var_resource paras = [] var_year_1_multiplier = 3.3 paras.append(var_year_1_multiplier) 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.lifecyclecostuseadjustments[0].name, var_name) self.assertEqual(idf2.lifecyclecostuseadjustments[0].resource, var_resource) index = obj.extensible_field_index("Year 1 Multiplier") self.assertAlmostEqual( idf2.lifecyclecostuseadjustments[0].extensibles[0][index], var_year_1_multiplier)
def test_create_externalinterfaceschedule(self): pyidf.validation_level = ValidationLevel.error obj = ExternalInterfaceSchedule() # 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 # real var_initial_value = 3.3 obj.initial_value = var_initial_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.externalinterfaceschedules[0].name, var_name) self.assertEqual( idf2.externalinterfaceschedules[0].schedule_type_limits_name, var_schedule_type_limits_name) self.assertAlmostEqual( idf2.externalinterfaceschedules[0].initial_value, var_initial_value)
def test_create_availabilitymanagerassignmentlist(self): pyidf.validation_level = ValidationLevel.error obj = AvailabilityManagerAssignmentList() # alpha var_name = "Name" obj.name = var_name paras = [] var_availability_manager_1_object_type = "AvailabilityManager:Scheduled" paras.append(var_availability_manager_1_object_type) var_availability_manager_1_name = "object-list|Availability Manager 1 Name" paras.append(var_availability_manager_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.availabilitymanagerassignmentlists[0].name, var_name) index = obj.extensible_field_index( "Availability Manager 1 Object Type") self.assertEqual( idf2.availabilitymanagerassignmentlists[0].extensibles[0][index], var_availability_manager_1_object_type) index = obj.extensible_field_index("Availability Manager 1 Name") self.assertEqual( idf2.availabilitymanagerassignmentlists[0].extensibles[0][index], var_availability_manager_1_name)
def test_create_surfacecontaminantsourceandsinkgenericboundarylayerdiffusion(self): pyidf.validation_level = ValidationLevel.error obj = SurfaceContaminantSourceAndSinkGenericBoundaryLayerDiffusion() # alpha var_name = "Name" obj.name = var_name # object-list var_surface_name = "object-list|Surface Name" obj.surface_name = var_surface_name # real var_mass_transfer_coefficient = 0.0 obj.mass_transfer_coefficient = var_mass_transfer_coefficient # object-list var_schedule_name = "object-list|Schedule Name" obj.schedule_name = var_schedule_name # real var_henry_adsorption_constant_or_partition_coefficient = 0.0001 obj.henry_adsorption_constant_or_partition_coefficient = var_henry_adsorption_constant_or_partition_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.surfacecontaminantsourceandsinkgenericboundarylayerdiffusions[0].name, var_name) self.assertEqual(idf2.surfacecontaminantsourceandsinkgenericboundarylayerdiffusions[0].surface_name, var_surface_name) self.assertAlmostEqual(idf2.surfacecontaminantsourceandsinkgenericboundarylayerdiffusions[0].mass_transfer_coefficient, var_mass_transfer_coefficient) self.assertEqual(idf2.surfacecontaminantsourceandsinkgenericboundarylayerdiffusions[0].schedule_name, var_schedule_name) self.assertAlmostEqual(idf2.surfacecontaminantsourceandsinkgenericboundarylayerdiffusions[0].henry_adsorption_constant_or_partition_coefficient, var_henry_adsorption_constant_or_partition_coefficient)
def test_create_surfacepropertyheattransferalgorithmmultiplesurface(self): pyidf.validation_level = ValidationLevel.error obj = SurfacePropertyHeatTransferAlgorithmMultipleSurface() # alpha var_name = "Name" obj.name = var_name # alpha var_surface_type = "AllExteriorSurfaces" obj.surface_type = var_surface_type # alpha var_algorithm = "ConductionTransferFunction" obj.algorithm = var_algorithm 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.surfacepropertyheattransferalgorithmmultiplesurfaces[0].name, var_name) self.assertEqual( idf2.surfacepropertyheattransferalgorithmmultiplesurfaces[0]. surface_type, var_surface_type) self.assertEqual( idf2.surfacepropertyheattransferalgorithmmultiplesurfaces[0]. algorithm, var_algorithm)
def test_create_parametricruncontrol(self): pyidf.validation_level = ValidationLevel.error obj = ParametricRunControl() # alpha var_name = "Name" obj.name = var_name paras = [] var_perform_run_1 = "Yes" paras.append(var_perform_run_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.parametricruncontrols[0].name, var_name) index = obj.extensible_field_index("Perform Run 1") self.assertEqual(idf2.parametricruncontrols[0].extensibles[0][index], var_perform_run_1)
def test_create_airflownetworkdistributioncomponentheatexchanger(self): pyidf.validation_level = ValidationLevel.error obj = AirflowNetworkDistributionComponentHeatExchanger() # object-list var_heatexchanger_name = "object-list|HeatExchanger Name" obj.heatexchanger_name = var_heatexchanger_name # alpha var_heatexchanger_object_type = "HeatExchanger:AirToAir:FlatPlate" obj.heatexchanger_object_type = var_heatexchanger_object_type # real var_air_path_length = 0.0001 obj.air_path_length = var_air_path_length # real var_air_path_hydraulic_diameter = 0.0001 obj.air_path_hydraulic_diameter = var_air_path_hydraulic_diameter 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.airflownetworkdistributioncomponentheatexchangers[0].heatexchanger_name, var_heatexchanger_name) self.assertEqual(idf2.airflownetworkdistributioncomponentheatexchangers[0].heatexchanger_object_type, var_heatexchanger_object_type) self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentheatexchangers[0].air_path_length, var_air_path_length) self.assertAlmostEqual(idf2.airflownetworkdistributioncomponentheatexchangers[0].air_path_hydraulic_diameter, var_air_path_hydraulic_diameter)
def test_create_heatbalancealgorithm(self): pyidf.validation_level = ValidationLevel.error obj = HeatBalanceAlgorithm() # alpha var_algorithm = "ConductionTransferFunction" obj.algorithm = var_algorithm # real var_surface_temperature_upper_limit = 200.0 obj.surface_temperature_upper_limit = var_surface_temperature_upper_limit # real var_minimum_surface_convection_heat_transfer_coefficient_value = 0.0001 obj.minimum_surface_convection_heat_transfer_coefficient_value = var_minimum_surface_convection_heat_transfer_coefficient_value # real var_maximum_surface_convection_heat_transfer_coefficient_value = 1.0 obj.maximum_surface_convection_heat_transfer_coefficient_value = var_maximum_surface_convection_heat_transfer_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.heatbalancealgorithms[0].algorithm, var_algorithm) self.assertAlmostEqual(idf2.heatbalancealgorithms[0].surface_temperature_upper_limit, var_surface_temperature_upper_limit) self.assertAlmostEqual(idf2.heatbalancealgorithms[0].minimum_surface_convection_heat_transfer_coefficient_value, var_minimum_surface_convection_heat_transfer_coefficient_value) self.assertAlmostEqual(idf2.heatbalancealgorithms[0].maximum_surface_convection_heat_transfer_coefficient_value, var_maximum_surface_convection_heat_transfer_coefficient_value)
def test_create_surfacepropertyothersideconditionsmodel(self): pyidf.validation_level = ValidationLevel.error obj = SurfacePropertyOtherSideConditionsModel() # alpha var_name = "Name" obj.name = var_name # alpha var_type_of_modeling = "GapConvectionRadiation" obj.type_of_modeling = var_type_of_modeling 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.surfacepropertyothersideconditionsmodels[0].name, var_name) self.assertEqual( idf2.surfacepropertyothersideconditionsmodels[0].type_of_modeling, var_type_of_modeling)
def test_create_refrigerationcaseandwalkinlist(self): pyidf.validation_level = ValidationLevel.error obj = RefrigerationCaseAndWalkInList() # alpha var_name = "Name" obj.name = var_name paras = [] var_case_or_walkin_1_name = "object-list|Case or WalkIn 1 Name" paras.append(var_case_or_walkin_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.refrigerationcaseandwalkinlists[0].name, var_name) index = obj.extensible_field_index("Case or WalkIn 1 Name") self.assertEqual( idf2.refrigerationcaseandwalkinlists[0].extensibles[0][index], var_case_or_walkin_1_name)
def test_create_nodelist(self): pyidf.validation_level = ValidationLevel.error obj = NodeList() # node var_name = "node|Name" obj.name = var_name paras = [] var_node_name = "node|Node Name" paras.append(var_node_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.nodelists[0].name, var_name) index = obj.extensible_field_index("Node Name") self.assertEqual(idf2.nodelists[0].extensibles[0][index], var_node_name)
def test_create_thermostatsetpointthermalcomfortfangerdualsetpoint(self): pyidf.validation_level = ValidationLevel.error obj = ThermostatSetpointThermalComfortFangerDualSetpoint() # alpha var_name = "Name" obj.name = var_name # object-list var_fanger_thermal_comfort_heating_schedule_name = "object-list|Fanger Thermal Comfort Heating Schedule Name" obj.fanger_thermal_comfort_heating_schedule_name = var_fanger_thermal_comfort_heating_schedule_name # object-list var_fanger_thermal_comfort_cooling_schedule_name = "object-list|Fanger Thermal Comfort Cooling Schedule Name" obj.fanger_thermal_comfort_cooling_schedule_name = var_fanger_thermal_comfort_cooling_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.thermostatsetpointthermalcomfortfangerdualsetpoints[0].name, var_name) self.assertEqual(idf2.thermostatsetpointthermalcomfortfangerdualsetpoints[0].fanger_thermal_comfort_heating_schedule_name, var_fanger_thermal_comfort_heating_schedule_name) self.assertEqual(idf2.thermostatsetpointthermalcomfortfangerdualsetpoints[0].fanger_thermal_comfort_cooling_schedule_name, var_fanger_thermal_comfort_cooling_schedule_name)
def test_create_energymanagementsystemprogram(self): pyidf.validation_level = ValidationLevel.error obj = EnergyManagementSystemProgram() # alpha var_name = "Name" obj.name = var_name paras = [] var_program_line_1 = "Program Line 1" paras.append(var_program_line_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.energymanagementsystemprograms[0].name, var_name) index = obj.extensible_field_index("Program Line 1") self.assertEqual(idf2.energymanagementsystemprograms[0].extensibles[0][index], var_program_line_1)
def test_create_roomairsettingscrossventilation(self): pyidf.validation_level = ValidationLevel.error obj = RoomAirSettingsCrossVentilation() # object-list var_zone_name = "object-list|Zone Name" obj.zone_name = var_zone_name # object-list var_gain_distribution_schedule_name = "object-list|Gain Distribution Schedule Name" obj.gain_distribution_schedule_name = var_gain_distribution_schedule_name # alpha var_airflow_region_used_for_thermal_comfort_evaluation = "Jet" obj.airflow_region_used_for_thermal_comfort_evaluation = var_airflow_region_used_for_thermal_comfort_evaluation 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.roomairsettingscrossventilations[0].zone_name, var_zone_name) self.assertEqual( idf2.roomairsettingscrossventilations[0]. gain_distribution_schedule_name, var_gain_distribution_schedule_name) self.assertEqual( idf2.roomairsettingscrossventilations[0]. airflow_region_used_for_thermal_comfort_evaluation, var_airflow_region_used_for_thermal_comfort_evaluation)
def test_create_geometrytransform(self): pyidf.validation_level = ValidationLevel.error obj = GeometryTransform() # alpha var_plane_of_transform = "XY" obj.plane_of_transform = var_plane_of_transform # real var_current_aspect_ratio = 0.0001 obj.current_aspect_ratio = var_current_aspect_ratio # real var_new_aspect_ratio = 0.0001 obj.new_aspect_ratio = var_new_aspect_ratio 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.geometrytransforms[0].plane_of_transform, var_plane_of_transform) self.assertAlmostEqual(idf2.geometrytransforms[0].current_aspect_ratio, var_current_aspect_ratio) self.assertAlmostEqual(idf2.geometrytransforms[0].new_aspect_ratio, var_new_aspect_ratio)