boost::optional<IdfObject> ForwardTranslator::translateMaterialPropertyGlazingSpectralData( MaterialPropertyGlazingSpectralData & modelObject ) { IdfObject idfObject(openstudio::IddObjectType::MaterialProperty_GlazingSpectralData); m_idfObjects.push_back(idfObject); idfObject.setString(openstudio::MaterialProperty_GlazingSpectralDataFields::Name, modelObject.name().get()); idfObject.clearExtensibleGroups(); for (const auto& spectralDataField : modelObject.spectralDataFields()){ IdfExtensibleGroup group = idfObject.pushExtensibleGroup(); OS_ASSERT(group.numFields() == 4); group.setDouble(MaterialProperty_GlazingSpectralDataExtensibleFields::Wavelength, spectralDataField.wavelength()); group.setDouble(MaterialProperty_GlazingSpectralDataExtensibleFields::transmittance, spectralDataField.transmittance()); group.setDouble(MaterialProperty_GlazingSpectralDataExtensibleFields::frontreflectance, spectralDataField.frontReflectance()); group.setDouble(MaterialProperty_GlazingSpectralDataExtensibleFields::backreflectance, spectralDataField.backReflectance()); } return boost::optional<IdfObject>(idfObject); }
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACLowTempRadiantConstFlow(ZoneHVACLowTempRadiantConstFlow& modelObject) { boost::optional<std::string> s; boost::optional<double> value; boost::optional<ModelObject> temp; IdfObject idfObject(IddObjectType::ZoneHVAC_LowTemperatureRadiant_ConstantFlow); m_idfObjects.push_back(idfObject); //Name std::string baseName = modelObject.name().get(); idfObject.setName(baseName); // AvailabilityScheduleName if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::AvailabilityScheduleName,_schedule->name().get()); } } //field Zone Name boost::optional<std::string> thermalZoneName; if( boost::optional<ThermalZone> zone = modelObject.thermalZone() ) { if( (s = zone->name()) ) { thermalZoneName = s; idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::ZoneName,thermalZoneName.get()); } } //field Surface Name or Radiant Surface Type //create a new surface group object IdfObject _surfaceGroup(IddObjectType::ZoneHVAC_LowTemperatureRadiant_SurfaceGroup); //create a name for the surface group std::string sname = baseName + "" + modelObject.radiantSurfaceType().get(); _surfaceGroup.setName(sname); //attach the surface group to the zone low temp radiant object idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::SurfaceNameorRadiantSurfaceGroupName,sname); //get rid of any existing surface (just to be safe) idfObject.clearExtensibleGroups(); //aggregator for total area; will be used to create weighted area double totalAreaOfSurfaces = 0; //loop through all surfaces, adding up their area for (const Surface& surface : modelObject.surfaces()){ totalAreaOfSurfaces = totalAreaOfSurfaces + surface.grossArea(); } //loop through all the surfaces, adding them and their flow fractions (weighted per-area) for (const Surface& surface : modelObject.surfaces()){ IdfExtensibleGroup group = _surfaceGroup.pushExtensibleGroup(); OS_ASSERT(group.numFields() == 2); group.setString(0, surface.name().get()); group.setDouble(1, (surface.grossArea()/totalAreaOfSurfaces) ); } //add the surface group to the list of idf objects m_idfObjects.push_back(_surfaceGroup); //field Hydronic Tubing Inside Diameter if( (value = modelObject.hydronicTubingInsideDiameter()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HydronicTubingInsideDiameter,value.get()); } //field Hydronic Tubing Length if( (value = modelObject.hydronicTubingLength()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HydronicTubingLength,value.get()); } //field Temperature Control Type if(boost::optional<std::string> tempCtrlType= modelObject.temperatureControlType() ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::TemperatureControlType,tempCtrlType.get()); } //field Rated Flow Rate if( (value = modelObject.ratedFlowRate()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::RatedFlowRate,value.get()); } //field Pump Flow Rate Schedule Name if( boost::optional<Schedule> schedule = modelObject.pumpFlowRateSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::PumpFlowRateScheduleName,_schedule->name().get()); } } //field Rated Pump Head if( (value = modelObject.ratedPumpHead()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::RatedPumpHead,value.get()); } //field Rated Power Consumption if( (value = modelObject.ratedPowerConsumption()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::RatedPowerConsumption,value.get()); } //field Motor Efficiency if( (value = modelObject.motorEfficiency()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::MotorEfficiency,value.get()); } //field Fraction of Motor Inefficiencies to Fluid Stream if( (value = modelObject.fractionofMotorInefficienciestoFluidStream()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::FractionofMotorInefficienciestoFluidStream,value.get()); } HVACComponent heatingCoil = modelObject.heatingCoil(); boost::optional<CoilHeatingLowTempRadiantConstFlow> coilOptionalHeating = heatingCoil.optionalCast<CoilHeatingLowTempRadiantConstFlow>(); // field Heating Water Inlet Node Name if (coilOptionalHeating){ CoilHeatingLowTempRadiantConstFlow coilHeat = *coilOptionalHeating; temp = coilHeat.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingWaterInletNodeName,*s); } } //field Heating Water Outlet Node Name temp = coilHeat.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingWaterOutletNodeName,*s); } } //field Heating High Water Temperature Schedule Name if( boost::optional<Schedule> schedule = coilHeat.heatingHighWaterTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingHighWaterTemperatureScheduleName,_schedule->name().get()); } } //field Heating Low Water Temperature Schedule Name if( boost::optional<Schedule> schedule = coilHeat.heatingLowWaterTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingLowWaterTemperatureScheduleName,_schedule->name().get()); } } //field Heating High Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilHeat.heatingHighControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingHighControlTemperatureScheduleName,_schedule->name().get()); } } //field Heating Low Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilHeat.heatingLowControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::HeatingLowControlTemperatureScheduleName,_schedule->name().get()); } } } HVACComponent coolingCoil = modelObject.coolingCoil(); boost::optional<CoilCoolingLowTempRadiantConstFlow> coilOptionalCooling = coolingCoil.optionalCast<CoilCoolingLowTempRadiantConstFlow>(); // field Cooling Water Inlet Node Name if (coilOptionalCooling){ CoilCoolingLowTempRadiantConstFlow coilCool = *coilOptionalCooling; temp = coilCool.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingWaterInletNodeName,*s); } } //field Cooling Water Outlet Node Name temp = coilCool.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingWaterOutletNodeName,*s); } } //field Cooling High Water Temperature Schedule Name if( boost::optional<Schedule> schedule = coilCool.coolingHighWaterTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingHighWaterTemperatureScheduleName,_schedule->name().get()); } } //field Cooling Low Water Temperature Schedule Name if( boost::optional<Schedule> schedule = coilCool.coolingLowWaterTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingLowWaterTemperatureScheduleName,_schedule->name().get()); } } //field Cooling High Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilCool.coolingHighControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingHighControlTemperatureScheduleName,_schedule->name().get()); } } //field Cooling Low Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilCool.coolingLowControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CoolingLowControlTemperatureScheduleName,_schedule->name().get()); } } //field Condensation Control Type idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CondensationControlType,coilCool.condensationControlType()); //field Condensation Control Dewpoint Offset if( (value = coilCool.condensationControlDewpointOffset()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CondensationControlDewpointOffset,value.get()); } } //field Number of Circuits idfObject.setString(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::NumberofCircuits,modelObject.numberofCircuits()); //field Circuit Length idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_ConstantFlowFields::CircuitLength,modelObject.circuitLength()); return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateShadingSurface( model::ShadingSurface & modelObject ) { boost::optional<IdfObject> idfObject; boost::optional<Schedule> transmittanceSchedule = modelObject.transmittanceSchedule(); Transformation transformation; Point3dVector points; boost::optional<ShadingSurfaceGroup> shadingSurfaceGroup = modelObject.shadingSurfaceGroup(); if (shadingSurfaceGroup){ transformation = shadingSurfaceGroup->transformation(); points = transformation * modelObject.vertices(); if (istringEqual("Space", shadingSurfaceGroup->shadingSurfaceType())){ idfObject = IdfObject(openstudio::IddObjectType::Shading_Zone_Detailed); idfObject->setString(Shading_Zone_DetailedFields::Name, modelObject.name().get()); boost::optional<Space> space = shadingSurfaceGroup->space(); if (space){ boost::optional<Surface> baseSurface; double minDistance = std::numeric_limits<double>::max(); // at this point zone has one space and internal surfaces have already been combined for (const Surface& surface : space->surfaces()){ if (istringEqual(surface.outsideBoundaryCondition(), "Outdoors")){ Point3dVector surfaceVertices = surface.vertices(); for (const Point3d& point : points){ for (const Point3d& surfaceVertex : surfaceVertices){ double distance = getDistance(point, surfaceVertex); if (distance < minDistance){ baseSurface = surface; minDistance = distance; } } } } } if (!baseSurface){ LOG(Error, "Cannot find appropriate base surface for shading surface '" << modelObject.name().get() << "', the shading surface will not be translated"); return boost::none; } idfObject->setString(Shading_Zone_DetailedFields::BaseSurfaceName, baseSurface->name().get()); } if (transmittanceSchedule){ idfObject->setString(Shading_Zone_DetailedFields::TransmittanceScheduleName, transmittanceSchedule->name().get()); } }else if (istringEqual("Site", shadingSurfaceGroup->shadingSurfaceType())){ idfObject = IdfObject(openstudio::IddObjectType::Shading_Site_Detailed); idfObject->setString(Shading_Site_DetailedFields::Name, modelObject.name().get()); if (transmittanceSchedule){ idfObject->setString(Shading_Site_DetailedFields::TransmittanceScheduleName, transmittanceSchedule->name().get()); } }else{ boost::optional<Building> building = modelObject.model().getUniqueModelObject<Building>(); if (building){ transformation = building->transformation().inverse()*transformation; } idfObject = IdfObject(openstudio::IddObjectType::Shading_Building_Detailed); idfObject->setString(Shading_Building_DetailedFields::Name, modelObject.name().get()); if (transmittanceSchedule){ idfObject->setString(Shading_Building_DetailedFields::TransmittanceScheduleName, transmittanceSchedule->name().get()); } } }else{ idfObject = IdfObject(openstudio::IddObjectType::Shading_Building_Detailed); idfObject->setString(Shading_Building_DetailedFields::Name, modelObject.name().get()); if (transmittanceSchedule){ idfObject->setString(Shading_Building_DetailedFields::TransmittanceScheduleName, transmittanceSchedule->name().get()); } } m_idfObjects.push_back(*idfObject); idfObject->clearExtensibleGroups(); for (const Point3d& point : points){ IdfExtensibleGroup group = idfObject->pushExtensibleGroup(); OS_ASSERT(group.numFields() == 3); group.setDouble(0, point.x()); group.setDouble(1, point.y()); group.setDouble(2, point.z()); } // get reflectance properties from construction if possible bool addShadingPropertyObject = false; IdfObject shadingPropertyObject = IdfObject(openstudio::IddObjectType::ShadingProperty_Reflectance); shadingPropertyObject.setString(ShadingProperty_ReflectanceFields::ShadingSurfaceName, modelObject.name().get()); boost::optional<model::ConstructionBase> constructionBase = modelObject.construction(); if (constructionBase){ if (constructionBase->isFenestration()){ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::FractionofShadingSurfaceThatIsGlazed, 1.0); shadingPropertyObject.setString(ShadingProperty_ReflectanceFields::GlazingConstructionName, constructionBase->name().get()); addShadingPropertyObject = true; }else{ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::FractionofShadingSurfaceThatIsGlazed, 0.0); boost::optional<model::Construction> construction = constructionBase->optionalCast<model::Construction>(); if (construction){ std::vector<model::Material> layers = construction->layers(); // we want the outer layer if (!layers.empty()){ if (layers[0].optionalCast<model::StandardOpaqueMaterial>()){ model::StandardOpaqueMaterial outerMaterial = layers[0].cast<model::StandardOpaqueMaterial>(); boost::optional<double> solRefl = outerMaterial.solarReflectance(); if (solRefl){ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::DiffuseSolarReflectanceofUnglazedPartofShadingSurface, *solRefl); addShadingPropertyObject = true; } boost::optional<double> visRefl = outerMaterial.visibleReflectance(); if (visRefl){ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::DiffuseVisibleReflectanceofUnglazedPartofShadingSurface, *visRefl); addShadingPropertyObject = true; } } if (layers[0].optionalCast<model::MasslessOpaqueMaterial>()){ model::MasslessOpaqueMaterial outerMaterial = layers[0].cast<model::MasslessOpaqueMaterial>(); boost::optional<double> solRefl = outerMaterial.solarReflectance(); if (solRefl){ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::DiffuseSolarReflectanceofUnglazedPartofShadingSurface, *solRefl); addShadingPropertyObject = true; } boost::optional<double> visRefl = outerMaterial.visibleReflectance(); if (visRefl){ shadingPropertyObject.setDouble(ShadingProperty_ReflectanceFields::DiffuseVisibleReflectanceofUnglazedPartofShadingSurface, *visRefl); addShadingPropertyObject = true; } } } } } } if (addShadingPropertyObject){ m_idfObjects.push_back(shadingPropertyObject); } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACLowTempRadiantVarFlow(ZoneHVACLowTempRadiantVarFlow& modelObject) { boost::optional<std::string> s; boost::optional<double> value; boost::optional<ModelObject> temp; IdfObject idfObject(IddObjectType::ZoneHVAC_LowTemperatureRadiant_VariableFlow); m_idfObjects.push_back(idfObject); //Name std::string baseName = modelObject.name().get(); idfObject.setName(baseName); // AvailabilityScheduleName if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::AvailabilityScheduleName,_schedule->name().get()); } } //field Zone Name boost::optional<std::string> thermalZoneName; if( boost::optional<ThermalZone> zone = modelObject.thermalZone() ) { if( (s = zone->name()) ) { thermalZoneName = s; idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::ZoneName,thermalZoneName.get()); } } //field Surface Name or Radiant Surface Type //create a new surface group object IdfObject _surfaceGroup(IddObjectType::ZoneHVAC_LowTemperatureRadiant_SurfaceGroup); //create a name for the surface group std::string sname = baseName + "" + modelObject.radiantSurfaceType().get(); _surfaceGroup.setName(sname); //attach the surface group to the zone low temp radiant object idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::SurfaceNameorRadiantSurfaceGroupName,sname); //get rid of any existing surface (just to be safe) idfObject.clearExtensibleGroups(); //aggregator for total area; will be used to create weighted area double totalAreaOfSurfaces = 0; //loop through all surfaces, adding up their area for (const Surface& surface : modelObject.surfaces()){ totalAreaOfSurfaces = totalAreaOfSurfaces + surface.grossArea(); } //loop through all the surfaces, adding them and their flow fractions (weighted per-area) for (const Surface& surface : modelObject.surfaces()){ IdfExtensibleGroup group = _surfaceGroup.pushExtensibleGroup(); OS_ASSERT(group.numFields() == 2); group.setString(0, surface.name().get()); group.setDouble(1, (surface.grossArea()/totalAreaOfSurfaces) ); } //add the surface group to the list of idf objects m_idfObjects.push_back(_surfaceGroup); //field Hydronic Tubing Inside Diameter if( (value = modelObject.hydronicTubingInsideDiameter()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HydronicTubingInsideDiameter,value.get()); } //field Hydronic Tubing Length if( modelObject.isHydronicTubingLengthAutosized() ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HydronicTubingLength,"Autosize"); } else if( (value = modelObject.hydronicTubingLength()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HydronicTubingLength,value.get()); } //field Temperature Control Type if(boost::optional<std::string> tempCtrlType= modelObject.temperatureControlType() ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::TemperatureControlType,tempCtrlType.get()); } // Heating Coil HVACComponent heatingCoil = modelObject.heatingCoil(); boost::optional<CoilHeatingLowTempRadiantVarFlow> coilOptionalHeating = heatingCoil.optionalCast<CoilHeatingLowTempRadiantVarFlow>(); if (coilOptionalHeating) { CoilHeatingLowTempRadiantVarFlow coilHeat = *coilOptionalHeating; // Heating Design Capacity Method - introduced in 8.2.0 and not yet supported in OS idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingDesignCapacityMethod,"HeatingDesignCapacity"); // Heating Design Capacity - introduced in 8.2.0 and not yet supported in OS idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingDesignCapacity,"Autosize"); // field Maximum Hot Water Flow if( coilHeat.isMaximumHotWaterFlowAutosized() ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::MaximumHotWaterFlow,"Autosize"); } else if( (value = coilHeat.maximumHotWaterFlow()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::MaximumHotWaterFlow,value.get()); } // field Heating Water Inlet Node Name temp = coilHeat.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingWaterInletNodeName,*s); } } //field Heating Water Outlet Node Name temp = coilHeat.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingWaterOutletNodeName,*s); } } //field Heating Control Throttling Range if( (value = coilHeat.heatingControlThrottlingRange()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingControlThrottlingRange,value.get()); } //field Heating Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilHeat.heatingControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::HeatingControlTemperatureScheduleName,_schedule->name().get()); } } } // Cooling Coil HVACComponent coolingCoil = modelObject.coolingCoil(); boost::optional<CoilCoolingLowTempRadiantVarFlow> coilOptionalCooling = coolingCoil.optionalCast<CoilCoolingLowTempRadiantVarFlow>(); if (coilOptionalCooling) { CoilCoolingLowTempRadiantVarFlow coilCool = *coilOptionalCooling; // Cooling Design Capacity Method - introduced in 8.2.0 and not yet supported in OS idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingDesignCapacityMethod,"CoolingDesignCapacity"); // Cooling Design Capacity - introduced in 8.2.0 and not yet supported in OS idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingDesignCapacity,"Autosize"); // Field Maximum Cold Water Flow if( coilCool.isMaximumColdWaterFlowAutosized() ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::MaximumColdWaterFlow,"Autosize"); } else if( (value = coilCool.maximumColdWaterFlow()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::MaximumColdWaterFlow,value.get()); } // field Cooling Water Inlet Node Name temp = coilCool.inletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingWaterInletNodeName,*s); } } //field Cooling Water Outlet Node Name temp = coilCool.outletModelObject(); if(temp) { s = temp->name(); if(s) { idfObject.setString(openstudio::ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingWaterOutletNodeName,*s); } } //field Cooling Control Throttling Range if( (value = coilCool.coolingControlThrottlingRange()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingControlThrottlingRange,value.get()); } //field Cooling Control Temperature Schedule Name if( boost::optional<Schedule> schedule = coilCool.coolingControlTemperatureSchedule() ) { if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) ) { idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CoolingControlTemperatureScheduleName,_schedule->name().get()); } } //field Condensation Control Type idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CondensationControlType,coilCool.condensationControlType()); //field Condensation Control Dewpoint Offset if( (value = coilCool.condensationControlDewpointOffset()) ) { idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CondensationControlDewpointOffset,value.get()); } } //field Number of Circuits idfObject.setString(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::NumberofCircuits,modelObject.numberofCircuits()); //field Circuit Length idfObject.setDouble(ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::CircuitLength,modelObject.circuitLength()); return idfObject; }