std::vector<double> ScheduleDay_Impl::values() const { if (!m_cachedValues){ std::vector<double> result; for (const IdfExtensibleGroup& group : extensibleGroups()) { OptionalDouble value = group.getDouble(OS_Schedule_DayExtensibleFields::ValueUntilTime, true); if (value){ result.push_back(*value); }else{ LOG(Error, "Could not read value " << group.groupIndex() << " in " << briefDescription() << "." ); } } m_cachedValues = result; } return m_cachedValues.get(); }
std::vector<ScheduleWeek> ScheduleYear_Impl::scheduleWeeks() const { std::vector<ScheduleWeek> result; for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(this->extensibleGroups())) { OptionalWorkspaceObject object = group.getTarget(2); if (object){ boost::optional<ScheduleWeek> schedule = object->optionalCast<ScheduleWeek>(); if (schedule){ result.push_back(*schedule); }else{ LOG(Error, "Could not read schedule " << group.groupIndex() << " in " << briefDescription() << "." ); } } } return result; }
void NamespaceDef::writeBriefDescription(OutputList &ol) { if (hasBriefDescription()) { DocRoot *rootNode = validatingParseDoc(briefFile(),briefLine(),this,0, briefDescription(),TRUE,FALSE,0,TRUE,FALSE); if (rootNode && !rootNode->isEmpty()) { ol.startParagraph(); ol.pushGeneratorState(); ol.disableAllBut(OutputGenerator::Man); ol.writeString(" - "); ol.popGeneratorState(); ol.writeDoc(rootNode,this,0); ol.pushGeneratorState(); ol.disable(OutputGenerator::RTF); ol.writeString(" \n"); ol.enable(OutputGenerator::RTF); if (hasDetailedDescription()) { ol.disableAllBut(OutputGenerator::Html); ol.startTextLink(0,"details"); ol.parseText(theTranslator->trMore()); ol.endTextLink(); } ol.popGeneratorState(); ol.endParagraph(); } delete rootNode; // FIXME:PARA //ol.pushGeneratorState(); //ol.disable(OutputGenerator::RTF); //ol.newParagraph(); //ol.popGeneratorState(); } ol.writeSynopsis(); }
void DirDef::writeBriefDescription(OutputList &ol) { if (hasBriefDescription()) { DocRoot *rootNode = validatingParseDoc( briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE); if (rootNode && !rootNode->isEmpty()) { ol.startParagraph(); ol.pushGeneratorState(); ol.disableAllBut(OutputGenerator::Man); ol.writeString(" - "); ol.popGeneratorState(); ol.writeDoc(rootNode,this,0); ol.pushGeneratorState(); ol.disable(OutputGenerator::RTF); ol.writeString(" \n"); ol.enable(OutputGenerator::RTF); if (Config_getBool(REPEAT_BRIEF) || !documentation().isEmpty() ) { ol.disableAllBut(OutputGenerator::Html); ol.startTextLink(0,"details"); ol.parseText(theTranslator->trMore()); ol.endTextLink(); } ol.popGeneratorState(); ol.endParagraph(); } delete rootNode; } ol.writeSynopsis(); }
ZoneHVACLowTempRadiantVarFlow::ZoneHVACLowTempRadiantVarFlow(const Model& model, Schedule& availabilitySchedule, HVACComponent& heatingCoil, HVACComponent& coolingCoil) : ZoneHVACComponent(ZoneHVACLowTempRadiantVarFlow::iddObjectType(),model) { OS_ASSERT(getImpl<detail::ZoneHVACLowTempRadiantVarFlow_Impl>()); bool ok = setAvailabilitySchedule(availabilitySchedule); if (!ok) { remove(); LOG_AND_THROW("Unable to set " << briefDescription() << "'s availability schedule to " << availabilitySchedule.briefDescription() << "."); } ok = setHeatingCoil(heatingCoil); OS_ASSERT(ok); ok = setCoolingCoil(coolingCoil); OS_ASSERT(ok); }
bool LayeredConstruction_Impl::setLayer(unsigned layerIndex, const Material& material) { OS_ASSERT(material.model() == model()); layerIndex = mf_clearNullLayers(layerIndex); if (layerIndex >= numLayers()) { LOG(Info,"Asked to change the Material at layer " << layerIndex << " in " << briefDescription() << ", but there are only " << numLayers() << " layers."); return false; } MaterialVector layers = this->layers(); layers[layerIndex] = material; if ((model().strictnessLevel() < StrictnessLevel::Final) || LayeredConstruction::layersAreValid(layers)) { ModelExtensibleGroup group = getExtensibleGroup(layerIndex).cast<ModelExtensibleGroup>(); OS_ASSERT(!group.empty()); bool ok = group.setPointer(0,material.handle()); OS_ASSERT(ok); return true; } return false; }
boost::optional<IdfObject> ForwardTranslator::translateAvailabilityManagerHybridVentilation( AvailabilityManagerHybridVentilation & modelObject) { IdfObject idfObject(IddObjectType::AvailabilityManager_HybridVentilation); m_idfObjects.push_back(idfObject); boost::optional<AirLoopHVAC> airLoopHVAC; if( auto loop = modelObject.loop() ) { airLoopHVAC = loop->optionalCast<model::AirLoopHVAC>(); } // Name if( auto s = modelObject.name() ) { idfObject.setName(*s); } // HVACAirLoopName if( auto loop = modelObject.loop() ) { idfObject.setString(AvailabilityManager_HybridVentilationFields::HVACAirLoopName,loop->name().get()); } // ControlledZoneName if( auto zone = modelObject.controlledZone() ) { idfObject.setString(AvailabilityManager_HybridVentilationFields::ControlledZoneName,zone->name().get()); } else { if( airLoopHVAC ) { auto zones = airLoopHVAC->thermalZones(); if( ! zones.empty() ) { auto default_zone = zones.front(); LOG(Info,modelObject.briefDescription() << " is missing Control Zone Name, defaulting to " << default_zone.briefDescription() << "."); idfObject.setString(AvailabilityManager_HybridVentilationFields::ControlledZoneName,default_zone.name().get()); } } } // VentilationControlModeScheduleName { auto schedule = modelObject.ventilationControlModeSchedule(); idfObject.setString(AvailabilityManager_HybridVentilationFields::VentilationControlModeScheduleName,schedule.name().get()); } // UseWeatherFileRainIndicators { if( modelObject.useWeatherFileRainIndicators() ) { idfObject.setString(AvailabilityManager_HybridVentilationFields::UseWeatherFileRainIndicators,"Yes"); } else { idfObject.setString(AvailabilityManager_HybridVentilationFields::UseWeatherFileRainIndicators,"No"); } } // MaximumWindSpeed { auto value = modelObject.maximumWindSpeed(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumWindSpeed,value); } // MinimumOutdoorTemperature { auto value = modelObject.minimumOutdoorTemperature(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorTemperature,value); } // MaximumOutdoorTemperature { auto value = modelObject.maximumOutdoorTemperature(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorTemperature,value); } // MinimumOutdoorEnthalpy { auto value = modelObject.minimumOutdoorEnthalpy(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorEnthalpy,value); } // MaximumOutdoorEnthalpy { auto value = modelObject.maximumOutdoorEnthalpy(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorEnthalpy,value); } // MinimumOutdoorDewpoint { auto value = modelObject.minimumOutdoorDewpoint(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorDewpoint,value); } // MaximumOutdoorDewpoint { auto value = modelObject.maximumOutdoorDewpoint(); idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorDewpoint,value); } // MinimumOutdoorVentilationAirScheduleName { auto schedule = modelObject.minimumOutdoorVentilationAirSchedule(); idfObject.setString(AvailabilityManager_HybridVentilationFields::MinimumOutdoorVentilationAirScheduleName,schedule.name().get()); } // OpeningFactorFunctionofWindSpeedCurveName if( auto curve = modelObject.openingFactorFunctionofWindSpeedCurve() ) { auto idf = translateAndMapModelObject(curve.get()); OS_ASSERT(idf); idfObject.setString(AvailabilityManager_HybridVentilationFields::OpeningFactorFunctionofWindSpeedCurveName,idf->name().get()); } return idfObject; }
bool DirDef::hasDetailedDescription() const { static bool repeatBrief = Config_getBool(REPEAT_BRIEF); return (!briefDescription().isEmpty() && repeatBrief) || !documentation().isEmpty(); }
bool NamespaceDef::hasDetailedDescription() const { static bool repeatBrief = Config_getBool("REPEAT_BRIEF"); return ((!briefDescription().isEmpty() && repeatBrief) || !documentation().isEmpty()); }
std::vector<SpectralDataField> MaterialPropertyGlazingSpectralData_Impl::spectralDataFields() const { std::vector<SpectralDataField> result; for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups())) { OptionalDouble wavelength = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Wavelength); OptionalDouble transmittance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Transmittance); OptionalDouble frontReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::FrontReflectance); OptionalDouble backReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::BackReflectance); if (wavelength && transmittance && frontReflectance && backReflectance){ result.push_back(SpectralDataField(*wavelength, *transmittance, *frontReflectance, *backReflectance)); }else{ LOG(Error, "Could not read SpectralDataField " << group.groupIndex() << " in " << briefDescription() << "." ); } } return result; }
boost::optional<IdfObject> ForwardTranslator::translateWaterHeaterHeatPump( WaterHeaterHeatPump & modelObject) { IdfObject idfObject(IddObjectType::WaterHeater_HeatPump_PumpedCondenser); m_idfObjects.push_back(idfObject); // Name if( auto s = modelObject.name() ) { idfObject.setName(*s); } if( auto mo = modelObject.availabilitySchedule() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AvailabilityScheduleName,mo->name().get()); } { auto mo = modelObject.compressorSetpointTemperatureSchedule(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorSetpointTemperatureScheduleName,mo.name().get()); } { auto value = modelObject.deadBandTemperatureDifference(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::DeadBandTemperatureDifference,value); } if( modelObject.isCondenserWaterFlowRateAutosized() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterFlowRate,"Autosize"); } else if( auto value = modelObject.condenserWaterFlowRate() ) { idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterFlowRate,value.get()); } if( modelObject.isEvaporatorAirFlowRateAutosized() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::EvaporatorAirFlowRate,"Autosize"); } else if( auto value = modelObject.evaporatorAirFlowRate() ) { idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::EvaporatorAirFlowRate,value.get()); } { auto value = modelObject.inletAirConfiguration(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirConfiguration,value); } if( auto mo = modelObject.inletAirTemperatureSchedule() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirTemperatureScheduleName,mo->name().get()); } if( auto mo = modelObject.inletAirHumiditySchedule() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirHumidityScheduleName,mo->name().get()); } { auto value = modelObject.minimumInletAirTemperatureforCompressorOperation(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::MinimumInletAirTemperatureforCompressorOperation,value); } { auto value = modelObject.compressorLocation(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorLocation,value); } if( auto mo = modelObject.compressorAmbientTemperatureSchedule() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorAmbientTemperatureScheduleName,mo->name().get()); } { auto value = modelObject.fanPlacement(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanPlacement,value); } { auto value = modelObject.onCycleParasiticElectricLoad(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::OnCycleParasiticElectricLoad,value); } { auto value = modelObject.offCycleParasiticElectricLoad(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::OffCycleParasiticElectricLoad,value); } { auto value = modelObject.parasiticHeatRejectionLocation(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::ParasiticHeatRejectionLocation,value); } { auto mo = modelObject.inletAirMixerSchedule(); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirMixerScheduleName,mo.name().get()); } { auto tank = modelObject.tank(); if( auto stratifiedTank = tank.optionalCast<model::WaterHeaterStratified>() ) { auto value = modelObject.controlSensorLocationInStratifiedTank(); if( istringEqual(value,"Heater1") ) { auto height = stratifiedTank->heater1Height(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height); } else if( istringEqual(value,"Heater2") ) { auto height = stratifiedTank->heater2Height(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height); } else if( istringEqual(value,"SourceInlet") ) { if( auto height = stratifiedTank->sourceSideInletHeight() ) { idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height.get()); } } else if( istringEqual(value,"SourceOutlet") ) { auto height = stratifiedTank->sourceSideOutletHeight(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height); } else if( istringEqual(value,"UseInlet") ) { auto height = stratifiedTank->useSideInletHeight(); idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height); } else if( istringEqual(value,"UseOutlet") ) { if( auto height = stratifiedTank->useSideOutletHeight() ) { idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height.get()); } } } } std::string condOutletTankInletNodeName = modelObject.name().get() + " Condenser Outlet - Tank Inlet"; std::string tankOutletCondInletNodeName = modelObject.name().get() + " Tank Outlet - Condenser Inlet"; idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterInletNodeName,tankOutletCondInletNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterOutletNodeName,condOutletTankInletNodeName); std::string airInletNodeName; std::string airOutletNodeName; std::string outdoorAirNodeName; std::string exhaustAirNodeName; std::string inletAirZoneName; std::string inletAirMixerNodeName; std::string outletAirSplitterNodeName; std::string fanInletNodeName; std::string fanOutletNodeName; std::string evapInletNodeName; std::string evapOutletNodeName; auto inletAirConfiguration = modelObject.inletAirConfiguration(); if( istringEqual(modelObject.fanPlacement(),"DrawThrough") ) { if( istringEqual(inletAirConfiguration,"ZoneAirOnly") ) { if( auto thermalZone = modelObject.thermalZone() ) { auto inletNode = modelObject.inletNode(); OS_ASSERT(inletNode); airInletNodeName = inletNode->name().get(); auto outletNode = modelObject.outletNode(); OS_ASSERT(outletNode); airOutletNodeName = outletNode->name().get(); inletAirZoneName = thermalZone->name().get(); fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet"; fanOutletNodeName = airOutletNodeName; evapInletNodeName = airInletNodeName; evapOutletNodeName = fanInletNodeName; } } else if( istringEqual(inletAirConfiguration,"ZoneAndOutdoorAir") ) { if( auto thermalZone = modelObject.thermalZone() ) { auto inletNode = modelObject.inletNode(); OS_ASSERT(inletNode); airInletNodeName = inletNode->name().get(); auto outletNode = modelObject.outletNode(); OS_ASSERT(outletNode); airOutletNodeName = outletNode->name().get(); outdoorAirNodeName = modelObject.name().get() + " Outdoor Air"; exhaustAirNodeName = modelObject.name().get() + " Exhaust Air"; inletAirZoneName = thermalZone->name().get(); inletAirMixerNodeName = modelObject.name().get() + " Mixer Outlet - Evap Inlet"; outletAirSplitterNodeName = modelObject.name().get() + " Fan Outlet - Splitter Inlet"; fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet"; fanOutletNodeName = outletAirSplitterNodeName; evapInletNodeName = inletAirMixerNodeName; evapOutletNodeName = fanInletNodeName; } } else if( istringEqual(inletAirConfiguration,"OutdoorAirOnly") ) { outdoorAirNodeName = modelObject.name().get() + " Outdoor Air"; exhaustAirNodeName = modelObject.name().get() + " Exhaust Air"; fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet"; fanOutletNodeName = exhaustAirNodeName; evapInletNodeName = outdoorAirNodeName; evapOutletNodeName = fanInletNodeName; } else if( istringEqual(inletAirConfiguration,"Schedule") ) { airInletNodeName = modelObject.name().get() + " Inlet"; airOutletNodeName = modelObject.name().get() + " Outlet"; fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet"; fanOutletNodeName = airOutletNodeName; evapInletNodeName = airInletNodeName; evapOutletNodeName = fanInletNodeName; } } else { // BlowThrough if( istringEqual(inletAirConfiguration,"ZoneAirOnly") ) { if( auto thermalZone = modelObject.thermalZone() ) { auto inletNode = modelObject.inletNode(); OS_ASSERT(inletNode); airInletNodeName = inletNode->name().get(); auto outletNode = modelObject.outletNode(); OS_ASSERT(outletNode); airOutletNodeName = outletNode->name().get(); inletAirZoneName = thermalZone->name().get(); fanInletNodeName = airInletNodeName; fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet"; evapInletNodeName = fanOutletNodeName; evapOutletNodeName = airOutletNodeName; } } else if( istringEqual(inletAirConfiguration,"ZoneAndOutdoorAir") ) { if( auto thermalZone = modelObject.thermalZone() ) { auto inletNode = modelObject.inletNode(); OS_ASSERT(inletNode); airInletNodeName = inletNode->name().get(); auto outletNode = modelObject.outletNode(); OS_ASSERT(outletNode); airOutletNodeName = outletNode->name().get(); outdoorAirNodeName = modelObject.name().get() + " Outdoor Air"; exhaustAirNodeName = modelObject.name().get() + " Exhaust Air"; inletAirZoneName = thermalZone->name().get(); inletAirMixerNodeName = modelObject.name().get() + " Mixer Outlet - Fan Inlet"; outletAirSplitterNodeName = modelObject.name().get() + " Evap Outlet - Splitter Inlet"; fanInletNodeName = inletAirMixerNodeName; fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet"; evapInletNodeName = fanOutletNodeName; evapOutletNodeName = outletAirSplitterNodeName; } } else if( istringEqual(inletAirConfiguration,"OutdoorAirOnly") ) { outdoorAirNodeName = modelObject.name().get() + " Outdoor Air"; exhaustAirNodeName = modelObject.name().get() + " Exhaust Air"; fanInletNodeName = outdoorAirNodeName; fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet"; evapInletNodeName = fanOutletNodeName; evapOutletNodeName = exhaustAirNodeName; } else if( istringEqual(inletAirConfiguration,"Schedule") ) { airInletNodeName = modelObject.name().get() + " Inlet"; airOutletNodeName = modelObject.name().get() + " Outlet"; fanInletNodeName = airInletNodeName; fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet"; evapInletNodeName = fanOutletNodeName; evapOutletNodeName = airOutletNodeName; } } { auto mo = modelObject.tank(); if( auto idf = translateAndMapModelObject(mo) ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankName,idf->name().get()); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankObjectType,idf->iddObject().name()); if( mo.iddObjectType() == model::WaterHeaterMixed::iddObjectType() ) { idf->setString(WaterHeater_MixedFields::SourceSideOutletNodeName,tankOutletCondInletNodeName); idf->setString(WaterHeater_MixedFields::SourceSideInletNodeName,condOutletTankInletNodeName); auto waterHeaterMixed = mo.cast<model::WaterHeaterMixed>(); if( auto node = waterHeaterMixed.supplyInletModelObject() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideInletNodeName,node->name().get()); } if( auto node = waterHeaterMixed.supplyOutletModelObject() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideOutletNodeName,node->name().get()); } } else if( mo.iddObjectType() == model::WaterHeaterStratified::iddObjectType() ) { idf->setString(WaterHeater_StratifiedFields::SourceSideOutletNodeName,tankOutletCondInletNodeName); idf->setString(WaterHeater_StratifiedFields::SourceSideInletNodeName,condOutletTankInletNodeName); auto waterHeaterStratified = mo.cast<model::WaterHeaterStratified>(); if( auto node = waterHeaterStratified.supplyInletModelObject() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideInletNodeName,node->name().get()); } if( auto node = waterHeaterStratified.supplyOutletModelObject() ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideOutletNodeName,node->name().get()); } } else { LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of tank: " << mo.briefDescription() ); } } } { auto mo = modelObject.dXCoil(); if( auto idf = translateAndMapModelObject(mo) ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::DXCoilName,idf->name().get()); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::DXCoilObjectType,idf->iddObject().name()); if( mo.iddObjectType() == model::CoilWaterHeatingAirToWaterHeatPump::iddObjectType() ) { idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::CondenserWaterInletNodeName,tankOutletCondInletNodeName); idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::CondenserWaterOutletNodeName,condOutletTankInletNodeName); idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::EvaporatorAirInletNodeName,evapInletNodeName); idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::EvaporatorAirOutletNodeName,evapOutletNodeName); } else { LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of coil: " << mo.briefDescription() ); } } } { auto mo = modelObject.fan(); if( auto idf = translateAndMapModelObject(mo) ) { idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanName,idf->name().get()); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanObjectType,idf->iddObject().name()); if( mo.iddObjectType() == model::FanOnOff::iddObjectType() ) { idf->setString(Fan_OnOffFields::AirInletNodeName,fanInletNodeName); idf->setString(Fan_OnOffFields::AirOutletNodeName,fanOutletNodeName); } else { LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of fan: " << mo.briefDescription() ); } } } idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AirInletNodeName,airInletNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AirOutletNodeName,airOutletNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::OutdoorAirNodeName,outdoorAirNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::ExhaustAirNodeName,exhaustAirNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirZoneName,inletAirZoneName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirMixerNodeName,inletAirMixerNodeName); idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::OutletAirSplitterNodeName,outletAirSplitterNodeName); return idfObject; }
void NamespaceDef::writeDocumentation(OutputList &ol) { QCString pageTitle; if (Config_getBool("OPTIMIZE_OUTPUT_JAVA")) { pageTitle = theTranslator->trPackage(displayName()); } else { pageTitle = theTranslator->trNamespaceReference(displayName()); } startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible); if (getOuterScope()!=Doxygen::globalScope) { writeNavigationPath(ol); } startTitle(ol,getOutputFileBase()); ol.parseText(pageTitle); addGroupListToTitle(ol,this); endTitle(ol,getOutputFileBase(),displayName()); if (Config_getBool("SEARCHENGINE")) { Doxygen::searchIndex->setCurrentDoc(pageTitle,getOutputFileBase()); Doxygen::searchIndex->addWord(localName(),TRUE); } if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <compound kind=\"namespace\">" << endl; Doxygen::tagFile << " <name>" << convertToXML(name()) << "</name>" << endl; Doxygen::tagFile << " <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl; } ol.startTextBlock(); if (Config_getBool("DETAILS_AT_TOP")) { writeDetailedDocumentation(ol); ol.newParagraph(); } else if (!briefDescription().isEmpty()) { ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE); ol.writeString(" \n"); ol.pushGeneratorState(); ol.disableAllBut(OutputGenerator::Html); ol.startTextLink(0,"_details"); ol.parseText(theTranslator->trMore()); ol.endTextLink(); ol.enableAll(); ol.disableAllBut(OutputGenerator::Man); ol.newParagraph(); ol.popGeneratorState(); } ol.disable(OutputGenerator::Man); ol.newParagraph(); ol.enable(OutputGenerator::Man); ol.writeSynopsis(); ol.endTextBlock(); ol.startMemberSections(); classSDict->writeDeclaration(ol,0,0,TRUE); namespaceSDict->writeDeclaration(ol,TRUE); /* write user defined member groups */ MemberGroupSDict::Iterator mgli(*memberGroupSDict); MemberGroup *mg; for (;(mg=mgli.current());++mgli) { mg->writeDeclarations(ol,0,this,0,0); } //allMemberList.writeDeclarations(ol,0,this,0,0,0,0); decDefineMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trDefines(),0); decProtoMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trFuncProtos(),0); decTypedefMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trTypedefs(),0); decEnumMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trEnumerations(),0); decFuncMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trFunctions(),0); decVarMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trVariables(),0); ol.endMemberSections(); if (!Config_getBool("DETAILS_AT_TOP")) { writeDetailedDocumentation(ol); } writeMemberDocumentation(ol); // write Author section (Man only) ol.pushGeneratorState(); ol.disableAllBut(OutputGenerator::Man); ol.startGroupHeader(); ol.parseText(theTranslator->trAuthor(TRUE,TRUE)); ol.endGroupHeader(); ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString("PROJECT_NAME"))); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { writeDocAnchorsToTagFile(); Doxygen::tagFile << " </compound>" << endl; } ol.popGeneratorState(); endFile(ol); if (Config_getBool("SEPARATE_MEMBER_PAGES")) { allMemberList.sort(); writeMemberPages(ol); } }
bool AirTerminalSingleDuctConstantVolumeFourPipeBeam_Impl::setHeatingCoil(const HVACComponent& coilHeatingFourPipeBeam) { bool result = setPointer(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeBeamFields::HeatingCoilName, coilHeatingFourPipeBeam.handle()); if (!result) { if ( !coilHeatingFourPipeBeam.optionalCast<CoilHeatingFourPipeBeam>() ) { LOG(Error, "Cannot set the heating coil to something else than CoilHeatingFourPipeBeam for " << briefDescription()); } } return result; }
bool Definition::hasBriefDescription() const { static bool briefMemberDesc = Config_getBool("BRIEF_MEMBER_DESC"); return !briefDescription().isEmpty() && briefMemberDesc; }
unsigned AirTerminalDualDuctVAVOutdoorAir_Impl::newInletPortAfterBranch(unsigned branchIndex) { LOG(Warn, "newInletPortAfterBranch is not supported for " << briefDescription() << " ."); LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " ."); return std::numeric_limits<unsigned>::max(); }
unsigned AirTerminalDualDuctVAVOutdoorAir_Impl::nextInletPort() const { LOG(Warn, "nextInletPort is not supported for " << briefDescription() << " ."); LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " ."); return std::numeric_limits<unsigned>::max(); }
double MasslessOpaqueMaterial_Impl::thermalResistivity() const { LOG_AND_THROW("Unable to convert thermal resistance to thermal resistivity for " << "MasslessOpaqueMaterial " << briefDescription() << "."); return 0.0; }
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACEnergyRecoveryVentilator( ZoneHVACEnergyRecoveryVentilator & modelObject ) { boost::optional<std::string> s; boost::optional<double> value; boost::optional<ModelObject> temp; // Model Name std::string const baseName = modelObject.name().get(); // Node Names std::string const oaNodeName = baseName + " OA Node"; std::string const supplyFanInletNodeName = baseName + " Supply Fan Inlet Node"; std::string const exhaustFanInletNodeName = baseName + " Exhaust Fan Inlet Node"; std::string const exhaustFanOutletNodeName = baseName + " Exhaust Fan Outlet Node"; auto const zoneExhaustNode = modelObject.inletNode(); auto const zoneInletNode = modelObject.outletNode(); // Name IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneHVAC_EnergyRecoveryVentilator, modelObject); // AvailabilityScheduleName { auto schedule = modelObject.availabilitySchedule(); if( auto _schedule = translateAndMapModelObject(schedule) ) { idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::AvailabilityScheduleName,_schedule->name().get()); } } // Heat Exchanger { auto heatExchanger = modelObject.heatExchanger().cast<HeatExchangerAirToAirSensibleAndLatent>(); if ( heatExchanger.supplyAirOutletTemperatureControl() ) { LOG(Warn,"Overriding supplyAirOutletTemperatureControl to \"No\" for " << heatExchanger.briefDescription() << " because the HX needs to control itself, not through Setpoint Manager."); heatExchanger.setSupplyAirOutletTemperatureControl( false ); } if( auto _heatExchanger = translateAndMapModelObject(heatExchanger) ) { // HeatExchangerName idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::HeatExchangerName,_heatExchanger->name().get() ); // Heat Exchanger Nodes if( _heatExchanger->iddObject().type() == IddObjectType::HeatExchanger_AirToAir_SensibleAndLatent ) { _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirInletNodeName,oaNodeName ); _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirOutletNodeName,supplyFanInletNodeName ); _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirInletNodeName,zoneExhaustNode->name().get() ); _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirOutletNodeName,exhaustFanInletNodeName ); IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList); _oaNodeList.setString(0,oaNodeName); m_idfObjects.push_back(_oaNodeList); } } } // SupplyAirFlowRate if( modelObject.isSupplyAirFlowRateAutosized() ) { idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFlowRate,"AutoSize"); } else if( (value = modelObject.supplyAirFlowRate()) ) { idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFlowRate,value.get()); } // ExhaustAirFlowRate if( modelObject.isExhaustAirFlowRateAutosized() ) { idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFlowRate,"AutoSize"); } else if( (value = modelObject.exhaustAirFlowRate()) ) { idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFlowRate,value.get()); } // Supply Air Fan { auto supplyAirFan = modelObject.supplyAirFan(); if( auto _supplyAirFan = translateAndMapModelObject(supplyAirFan) ) { // SupplyAirFanName idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFanName,_supplyAirFan->name().get() ); // Supply Air Fan Inlet and Outlet Nodes if( _supplyAirFan->iddObject().type() == IddObjectType::Fan_OnOff ) { _supplyAirFan->setString(Fan_OnOffFields::AirInletNodeName,supplyFanInletNodeName ); _supplyAirFan->setString(Fan_OnOffFields::AirOutletNodeName,zoneInletNode->name().get() ); } } } // Exhaust Air Fan { auto exhaustAirFan = modelObject.exhaustAirFan(); if( auto _exhaustAirFan = translateAndMapModelObject(exhaustAirFan) ) { // ExhaustAirFanName idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFanName,_exhaustAirFan->name().get() ); // Exhaust Air Fan Inlet and Outlet Nodes if( _exhaustAirFan->iddObject().type() == IddObjectType::Fan_OnOff ) { _exhaustAirFan->setString(Fan_OnOffFields::AirInletNodeName,exhaustFanInletNodeName ); _exhaustAirFan->setString(Fan_OnOffFields::AirOutletNodeName,exhaustFanOutletNodeName ); } } } // ControllerName if( auto controller = modelObject.controller() ) { if( auto _controller = translateAndMapModelObject(controller.get()) ) { idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ControllerName,_controller->name().get()); // Need to set Humidistat Control Thermal Zone in Controller if( controller->highHumidityControlFlag() ) { if( auto thermalZone = modelObject.thermalZone() ) { if( auto _thermalZone = translateAndMapModelObject(thermalZone.get()) ) { _controller->setString(ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HumidistatControlZoneName,_thermalZone->name().get()); } } } } } // VentilationRateperUnitFloorArea if( (value = modelObject.ventilationRateperUnitFloorArea()) ) { idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::VentilationRateperUnitFloorArea,value.get()); } // VentilationRateperOccupant if( (value = modelObject.ventilationRateperOccupant()) ) { idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::VentilationRateperOccupant,value.get()); } // AvailabilityManagerListName return idfObject; }
double AirGap_Impl::thermalResistivity() const { LOG_AND_THROW("Unable to convert thermal resistance to thermal resistivity for AirGap " << briefDescription() << "."); return 0.0; }
void AirTerminalDualDuctVAVOutdoorAir_Impl::removePortForBranch(unsigned branchIndex) { LOG(Warn, "removePortForBranch is not supported for " << briefDescription() << " ."); LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " ."); }
void GroupDef::writeDocumentation(OutputList &ol) { ol.pushGeneratorState(); startFile(ol,getOutputFileBase(),name(),title); startTitle(ol,getOutputFileBase()); ol.parseText(title); addGroupListToTitle(ol,this); endTitle(ol,getOutputFileBase(),title); if (Config_getBool("SEARCHENGINE")) { Doxygen::searchIndex->setCurrentDoc(title,getOutputFileBase()); static QRegExp we("[a-zA-Z_][a-zA-Z_0-9]*"); int i=0,p=0,l=0; while ((i=we.match(title,p,&l))!=-1) // foreach word in the title { Doxygen::searchIndex->addWord(title.mid(i,l),TRUE); p=i+l; } } if (Config_getBool("HAVE_DOT") && Config_getBool("GROUP_GRAPHS") ) { DotGroupCollaboration graph(this); if (!graph.isTrivial()) { msg("Generating dependency graph for group %s\n",qualifiedName().data()); ol.pushGeneratorState(); ol.disable(OutputGenerator::Man); ol.newParagraph(); ol.startGroupCollaboration(); ol.parseText(theTranslator->trCollaborationDiagram(title)); ol.endGroupCollaboration(graph); ol.popGeneratorState(); } } if (Config_getBool("DETAILS_AT_TOP")) { writeDetailedDocumentation(ol); ol.newParagraph(); } else if (!briefDescription().isEmpty()) { ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE); ol.writeString(" \n"); ol.pushGeneratorState(); ol.disable(OutputGenerator::Latex); ol.disable(OutputGenerator::RTF); ol.disable(OutputGenerator::Man); ol.startTextLink(0,"_details"); ol.parseText(theTranslator->trMore()); ol.endTextLink(); ol.enableAll(); ol.disableAllBut(OutputGenerator::Man); ol.newParagraph(); ol.popGeneratorState(); } if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <compound kind=\"group\">" << endl; Doxygen::tagFile << " <name>" << convertToXML(name()) << "</name>" << endl; Doxygen::tagFile << " <title>" << convertToXML(title) << "</title>" << endl; Doxygen::tagFile << " <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl; } ol.startMemberSections(); // write list of files if (fileList->count()>0) { ol.startMemberHeader(); ol.parseText(theTranslator->trFile(TRUE,FALSE)); ol.endMemberHeader(); ol.startMemberList(); FileDef *fd=fileList->first(); while (fd) { ol.startMemberItem(0); ol.docify(theTranslator->trFile(FALSE,TRUE)+" "); ol.insertMemberAlign(); ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,fd->name()); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <file>" << convertToXML(fd->name()) << "</file>" << endl; } ol.endMemberItem(); if (!fd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC")) { ol.startMemberDescription(); ol.parseDoc(briefFile(),briefLine(),fd,0,fd->briefDescription(),FALSE,FALSE); ol.endMemberDescription(); ol.newParagraph(); } fd=fileList->next(); } ol.endMemberList(); } // write list of namespaces namespaceSDict->writeDeclaration(ol); // write list of groups if (groupList->count()>0) { ol.startMemberHeader(); ol.parseText(theTranslator->trModules()); ol.endMemberHeader(); ol.startMemberList(); GroupDef *gd=groupList->first(); while (gd) { ol.startMemberItem(0); //ol.docify(theTranslator->trGroup(FALSE,TRUE)); //ol.docify(" "); ol.insertMemberAlign(); ol.writeObjectLink(gd->getReference(),gd->getOutputFileBase(),0,gd->groupTitle()); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <subgroup>" << convertToXML(gd->name()) << "</subgroup>" << endl; } ol.endMemberItem(); if (!gd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC")) { ol.startMemberDescription(); ol.parseDoc(briefFile(),briefLine(),gd,0,gd->briefDescription(),FALSE,FALSE); ol.endMemberDescription(); ol.newParagraph(); } gd=groupList->next(); } ol.endMemberList(); } // write list of directories if (dirList->count()>0) { ol.startMemberHeader(); ol.parseText(theTranslator->trDirectories()); ol.endMemberHeader(); ol.startMemberList(); DirDef *dd=dirList->first(); while (dd) { ol.startMemberItem(0); ol.parseText(theTranslator->trDir(FALSE,TRUE)); ol.insertMemberAlign(); ol.writeObjectLink(dd->getReference(),dd->getOutputFileBase(),0,dd->shortName()); ol.endMemberItem(); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <dir>" << convertToXML(dd->displayName()) << "</dir>" << endl; } if (!dd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC")) { ol.startMemberDescription(); ol.parseDoc(briefFile(),briefLine(),dd,0,dd->briefDescription(),FALSE,FALSE); ol.endMemberDescription(); ol.newParagraph(); } dd=dirList->next(); } ol.endMemberList(); } // write list of classes classSDict->writeDeclaration(ol); // write list of members if (allMemberList->count()>0) { /* write user defined member groups */ MemberGroupSDict::Iterator mgli(*memberGroupSDict); MemberGroup *mg; for (; (mg=mgli.current()); ++mgli) { mg->writeDeclarations(ol,0,0,0,this); } //allMemberList->writeDeclarations(ol,0,0,0,this,0,0); decDefineMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trDefines(),0); decProtoMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trFuncProtos(),0); decTypedefMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trTypedefs(),0); decEnumMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trEnumerations(),0); decFuncMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trFunctions(),0); decVarMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trVariables(),0); } ol.endMemberSections(); if (!Config_getBool("DETAILS_AT_TOP")) { writeDetailedDocumentation(ol); } PageDef *pd=0; PageSDict::Iterator pdi(*pageDict); for (pdi.toFirst(); (pd=pdi.current()); ++pdi) { if (!pd->isReference()) { QCString pageName = pd->getOutputFileBase(); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { Doxygen::tagFile << " <page>" << convertToXML(pageName) << "</page>" << endl; } SectionInfo *si=0; if (!pd->title().isEmpty() && !pd->name().isEmpty() && (si=Doxygen::sectionDict[pd->name()])!=0) { ol.startSection(si->label,si->title,SectionInfo::Subsection); ol.docify(si->title); ol.endSection(si->label,SectionInfo::Subsection); } ol.startTextBlock(); ol.parseDoc(pd->docFile(),pd->docLine(),pd,0,pd->documentation(),TRUE,FALSE); ol.endTextBlock(); } } writeMemberDocumentation(ol); if (!Config_getString("GENERATE_TAGFILE").isEmpty()) { writeDocAnchorsToTagFile(); Doxygen::tagFile << " </compound>" << endl; } endFile(ol); ol.popGeneratorState(); if (Config_getBool("SEPARATE_MEMBER_PAGES")) { allMemberList->sort(); writeMemberPages(ol); } }