boost::optional<IdfObject> ForwardTranslator::translateRefrigerationTranscriticalSystem( RefrigerationTranscriticalSystem & modelObject ) { OptionalModelObject temp; boost::optional<std::string> s; boost::optional<double> d; std::string name; // Name IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_TranscriticalSystem, modelObject); //MediumTemperatureRefrigeratedCaseAndWalkInListName std::vector<RefrigerationCase> mediumTemperatureCases = modelObject.mediumTemperatureCases(); std::vector<RefrigerationWalkIn> mediumTemperatureWalkins = modelObject.mediumTemperatureWalkins(); if( !mediumTemperatureCases.empty() || !mediumTemperatureWalkins.empty() ) { // Name name = " Medium Temperature Case and Walkin List"; idfObject.setString(Refrigeration_TranscriticalSystemFields::MediumTemperatureRefrigeratedCaseorWalkinorCaseAndWalkInListName, idfObject.name().get() + name); IdfObject _caseAndWalkinList(IddObjectType::Refrigeration_CaseAndWalkInList); m_idfObjects.push_back(_caseAndWalkinList); _caseAndWalkinList.setName(idfObject.name().get() + name); for( auto & mediumTemperatureCase : mediumTemperatureCases ) { boost::optional<IdfObject> _case = translateAndMapModelObject(mediumTemperatureCase); if( _case ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_case->name().get()); } } for( auto & mediumTemperatureWalkin : mediumTemperatureWalkins ) { boost::optional<IdfObject> _walkin = translateAndMapModelObject(mediumTemperatureWalkin); if( _walkin ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_walkin->name().get()); } } } //LowTemperatureRefrigeratedCaseAndWalkInListName std::vector<RefrigerationCase> lowTemperatureCases = modelObject.lowTemperatureCases(); std::vector<RefrigerationWalkIn> lowTemperatureWalkins = modelObject.lowTemperatureWalkins(); if( !lowTemperatureCases.empty() || !lowTemperatureWalkins.empty() ) { // Name name = " Low Temperature Case and Walkin List"; idfObject.setString(Refrigeration_TranscriticalSystemFields::LowTemperatureRefrigeratedCaseorWalkinorCaseAndWalkInListName, idfObject.name().get() + name); IdfObject _caseAndWalkinList(IddObjectType::Refrigeration_CaseAndWalkInList); m_idfObjects.push_back(_caseAndWalkinList); _caseAndWalkinList.setName(idfObject.name().get() + name); for( auto & lowTemperatureCase : lowTemperatureCases ) { boost::optional<IdfObject> _case = translateAndMapModelObject(lowTemperatureCase); if( _case ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_case->name().get()); } } for( auto & lowTemperatureWalkin : lowTemperatureWalkins ) { boost::optional<IdfObject> _walkin = translateAndMapModelObject(lowTemperatureWalkin); if( _walkin ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_walkin->name().get()); } } } // SystemType if ( (!mediumTemperatureCases.empty() || !mediumTemperatureWalkins.empty()) && (!lowTemperatureCases.empty() || !lowTemperatureWalkins.empty()) ) { idfObject.setString(Refrigeration_TranscriticalSystemFields::SystemType,"TwoStage"); } else { idfObject.setString(Refrigeration_TranscriticalSystemFields::SystemType,"SingleStage"); } // RefrigerationGasCoolerName if( boost::optional<RefrigerationGasCoolerAirCooled> refrigerationGasCooler = modelObject.refrigerationGasCooler() ) { boost::optional<IdfObject> _refrigerationGasCooler = translateAndMapModelObject(refrigerationGasCooler.get()); if( _refrigerationGasCooler && _refrigerationGasCooler->name() ) { idfObject.setString(Refrigeration_TranscriticalSystemFields::RefrigerationGasCoolerName,_refrigerationGasCooler->name().get()); } } //HighPressureCompressorListName std::vector<RefrigerationCompressor> highPressureCompressors = modelObject.highPressureCompressors(); if( !highPressureCompressors.empty() ) { // Name name = " High Pressure Compressor List"; idfObject.setString(Refrigeration_TranscriticalSystemFields::HighPressureCompressororCompressorListName, idfObject.name().get() + name); IdfObject _compressorList(IddObjectType::Refrigeration_CompressorList); m_idfObjects.push_back(_compressorList); _compressorList.setName(idfObject.name().get() + name); for( auto & highPressureCompressor : highPressureCompressors ) { boost::optional<IdfObject> _compressor = translateAndMapModelObject(highPressureCompressor); if( _compressor ) { IdfExtensibleGroup eg = _compressorList.pushExtensibleGroup(); eg.setString(Refrigeration_CompressorListExtensibleFields::RefrigerationCompressorName,_compressor->name().get()); } } } //LowPressureCompressorListName std::vector<RefrigerationCompressor> lowPressureCompressors = modelObject.lowPressureCompressors(); if( !lowPressureCompressors.empty() ) { // Name name = " Low Pressure Compressor List"; idfObject.setString(Refrigeration_TranscriticalSystemFields::LowPressureCompressororCompressorListName, idfObject.name().get() + name); IdfObject _compressorList(IddObjectType::Refrigeration_CompressorList); m_idfObjects.push_back(_compressorList); _compressorList.setName(idfObject.name().get() + name); for( auto & lowPressureCompressor : lowPressureCompressors ) { boost::optional<IdfObject> _compressor = translateAndMapModelObject(lowPressureCompressor); if( _compressor ) { IdfExtensibleGroup eg = _compressorList.pushExtensibleGroup(); eg.setString(Refrigeration_CompressorListExtensibleFields::RefrigerationCompressorName,_compressor->name().get()); } } } // ReceiverPressure d = modelObject.receiverPressure(); if (d) { idfObject.setDouble(Refrigeration_TranscriticalSystemFields::ReceiverPressure,d.get()); } // SubcoolerEffectiveness d = modelObject.subcoolerEffectiveness(); if (d) { idfObject.setDouble(Refrigeration_TranscriticalSystemFields::SubcoolerEffectiveness,d.get()); } // RefrigerationSystemWorkingFluidType s = modelObject.refrigerationSystemWorkingFluidType(); if (s) { boost::optional<IdfObject> fluidProperties = createFluidProperties(s.get()); if( fluidProperties ) { boost::optional<std::string> value = fluidProperties.get().getString(FluidProperties_NameFields::FluidName,true); if( value ) { idfObject.setString(Refrigeration_TranscriticalSystemFields::RefrigerationSystemWorkingFluidType,value.get()); } } } // SumUASuctionPipingforMediumTemperatureLoads d = modelObject.sumUASuctionPipingforMediumTemperatureLoads(); if (d) { idfObject.setDouble(Refrigeration_TranscriticalSystemFields::SumUASuctionPipingforMediumTemperatureLoads,d.get()); } // MediumTemperatureSuctionPipingZoneName if( boost::optional<ThermalZone> mediumTemperatureSuctionPipingZone = modelObject.mediumTemperatureSuctionPipingZone() ) { boost::optional<IdfObject> _mediumTemperatureSuctionPipingZone = translateAndMapModelObject(mediumTemperatureSuctionPipingZone.get()); if( _mediumTemperatureSuctionPipingZone && _mediumTemperatureSuctionPipingZone->name() ) { idfObject.setString(Refrigeration_TranscriticalSystemFields::MediumTemperatureSuctionPipingZoneName,_mediumTemperatureSuctionPipingZone->name().get()); } } // SumUASuctionPipingforLowTemperatureLoads d = modelObject.sumUASuctionPipingforLowTemperatureLoads(); if (d) { idfObject.setDouble(Refrigeration_TranscriticalSystemFields::SumUASuctionPipingforLowTemperatureLoads,d.get()); } // LowTemperatureSuctionPipingZoneName if( boost::optional<ThermalZone> lowTemperatureSuctionPipingZone = modelObject.lowTemperatureSuctionPipingZone() ) { boost::optional<IdfObject> _lowTemperatureSuctionPipingZone = translateAndMapModelObject(lowTemperatureSuctionPipingZone.get()); if( _lowTemperatureSuctionPipingZone && _lowTemperatureSuctionPipingZone->name() ) { idfObject.setString(Refrigeration_TranscriticalSystemFields::LowTemperatureSuctionPipingZoneName,_lowTemperatureSuctionPipingZone->name().get()); } } // EndUseSubcategory s = modelObject.endUseSubcategory(); if (s) { idfObject.setString(Refrigeration_TranscriticalSystemFields::EndUseSubcategory,s.get()); } return idfObject; }
boost::optional<IdfObject> ForwardTranslator::translateRefrigerationSystem( RefrigerationSystem & modelObject ) { OptionalModelObject temp; OptionalString optS; boost::optional<std::string> s; boost::optional<double> d; std::string name; // Name IdfObject refrigerationSystem = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_System, modelObject); //Refrigerated Case or Walkin or CaseAndWalkInList Name std::vector<RefrigerationCase> cases = modelObject.cases(); std::vector<RefrigerationWalkIn> walkins = modelObject.walkins(); std::vector<RefrigerationAirChiller> airChillers = modelObject.airChillers(); if( !cases.empty() || !walkins.empty() || !airChillers.empty() ) { // Name name = " Case and Walkin List"; refrigerationSystem.setString(Refrigeration_SystemFields::RefrigeratedCaseorWalkinorCaseAndWalkInListName, refrigerationSystem.name().get() + name); IdfObject _caseAndWalkinList(IddObjectType::Refrigeration_CaseAndWalkInList); m_idfObjects.push_back(_caseAndWalkinList); _caseAndWalkinList.setName(refrigerationSystem.name().get() + name); for( std::vector<RefrigerationCase>::iterator it = cases.begin(); it != cases.end(); ++it ) { boost::optional<IdfObject> _case = translateAndMapModelObject(*it); if( _case ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_case->name().get()); } } for( std::vector<RefrigerationWalkIn>::iterator it = walkins.begin(); it != walkins.end(); ++it ) { boost::optional<IdfObject> _walkin = translateAndMapModelObject(*it); if( _walkin ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_walkin->name().get()); } } for( std::vector<RefrigerationAirChiller>::iterator it = airChillers.begin(); it != airChillers.end(); it++ ) { boost::optional<IdfObject> _airChiller = translateAndMapModelObject(*it); if( _airChiller ) { IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup(); eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_airChiller->name().get()); } } } //Refrigeration Transfer Load or TransferLoad List Name std::vector<RefrigerationSecondarySystem> secondarySystemLoads = modelObject.secondarySystemLoads(); std::vector<RefrigerationCondenserCascade> cascadeCondenserLoads = modelObject.cascadeCondenserLoads(); if( !secondarySystemLoads.empty() || !cascadeCondenserLoads.empty() ) { // Name name = " Transfer Load List"; refrigerationSystem.setString(Refrigeration_SystemFields::RefrigerationTransferLoadorTransferLoadListName, refrigerationSystem.name().get() + name); IdfObject _transferLoadList(IddObjectType::Refrigeration_TransferLoadList); m_idfObjects.push_back(_transferLoadList); _transferLoadList.setName(refrigerationSystem.name().get() + name); for( std::vector<RefrigerationSecondarySystem>::iterator it = secondarySystemLoads.begin(); it != secondarySystemLoads.end(); ++it ) { boost::optional<IdfObject> _secondarySystemLoad = translateAndMapModelObject(*it); if( _secondarySystemLoad ) { IdfExtensibleGroup eg = _transferLoadList.pushExtensibleGroup(); eg.setString(Refrigeration_TransferLoadListExtensibleFields::CascadeCondenserNameorSecondarySystemName,_secondarySystemLoad->name().get()); } } for( std::vector<RefrigerationCondenserCascade>::iterator it = cascadeCondenserLoads.begin(); it != cascadeCondenserLoads.end(); ++it ) { boost::optional<IdfObject> _cascadeCondenserLoad = translateAndMapModelObject(*it); if( _cascadeCondenserLoad ) { IdfExtensibleGroup eg = _transferLoadList.pushExtensibleGroup(); eg.setString(Refrigeration_TransferLoadListExtensibleFields::CascadeCondenserNameorSecondarySystemName,_cascadeCondenserLoad->name().get()); } } } //Refrigeration Condenser Name boost::optional<ModelObject> refrigerationCondenser = modelObject.refrigerationCondenser(); if( refrigerationCondenser ) { boost::optional<IdfObject> _refrigerationCondenser = translateAndMapModelObject(refrigerationCondenser.get()); if( _refrigerationCondenser && _refrigerationCondenser->name() ) { refrigerationSystem.setString(Refrigeration_SystemFields::RefrigerationCondenserName,_refrigerationCondenser->name().get()); } } //Compressor or CompressorList Name std::vector<RefrigerationCompressor> compressors = modelObject.compressors(); if( !compressors.empty() ) { // Name name = " Compressor List"; refrigerationSystem.setString(Refrigeration_SystemFields::CompressororCompressorListName, refrigerationSystem.name().get() + name); IdfObject _compressorList(IddObjectType::Refrigeration_CompressorList); m_idfObjects.push_back(_compressorList); _compressorList.setName(refrigerationSystem.name().get() + name); for( std::vector<RefrigerationCompressor>::iterator it = compressors.begin(); it != compressors.end(); ++it ) { boost::optional<IdfObject> _compressor = translateAndMapModelObject(*it); if( _compressor ) { IdfExtensibleGroup eg = _compressorList.pushExtensibleGroup(); eg.setString(Refrigeration_CompressorListExtensibleFields::RefrigerationCompressorName,_compressor->name().get()); } } } //Minimum Condensing Temperature d = modelObject.minimumCondensingTemperature(); if (d) { refrigerationSystem.setDouble(Refrigeration_SystemFields::MinimumCondensingTemperature,d.get()); } //Refrigeration System Working Fluid Type s = modelObject.refrigerationSystemWorkingFluidType(); if (s) { boost::optional<IdfObject> fluidProperties = createFluidProperties(s.get()); if( fluidProperties ) { boost::optional<std::string> value = fluidProperties.get().getString(FluidProperties_NameFields::FluidName,true); if( value ) { refrigerationSystem.setString(Refrigeration_SystemFields::RefrigerationSystemWorkingFluidType,value.get()); } } } //Suction Temperature Control Type s = modelObject.suctionTemperatureControlType(); if (s) { refrigerationSystem.setString(Refrigeration_SystemFields::SuctionTemperatureControlType,s.get()); } //Mechanical Subcooler Name boost::optional<RefrigerationSubcoolerMechanical> mechanicalSubcooler = modelObject.mechanicalSubcooler(); if( mechanicalSubcooler ) { boost::optional<IdfObject> _mechanicalSubcooler = translateAndMapModelObject(mechanicalSubcooler.get()); if( _mechanicalSubcooler && _mechanicalSubcooler->name() ) { refrigerationSystem.setString(Refrigeration_SystemFields::MechanicalSubcoolerName,_mechanicalSubcooler->name().get()); } } //Liquid Suction Heat Exchanger Subcooler Name boost::optional<RefrigerationSubcoolerLiquidSuction> liquidSuctionHeatExchangerSubcooler = modelObject.liquidSuctionHeatExchangerSubcooler(); if( liquidSuctionHeatExchangerSubcooler ) { boost::optional<IdfObject> _liquidSuctionHeatExchangerSubcooler = translateAndMapModelObject(liquidSuctionHeatExchangerSubcooler.get()); if( _liquidSuctionHeatExchangerSubcooler && _liquidSuctionHeatExchangerSubcooler->name() ) { refrigerationSystem.setString(Refrigeration_SystemFields::LiquidSuctionHeatExchangerSubcoolerName,_liquidSuctionHeatExchangerSubcooler->name().get()); } } //Sum UA Suction Piping d = modelObject.sumUASuctionPiping(); if (d) { refrigerationSystem.setDouble(Refrigeration_SystemFields::SumUASuctionPiping,d.get()); } //Suction Piping Zone Name boost::optional<ThermalZone> suctionPipingZone = modelObject.suctionPipingZone(); if( suctionPipingZone ) { boost::optional<IdfObject> _suctionPipingZone = translateAndMapModelObject(suctionPipingZone.get()); if( _suctionPipingZone && _suctionPipingZone->name() ) { refrigerationSystem.setString(Refrigeration_SystemFields::SuctionPipingZoneName,_suctionPipingZone->name().get()); } } //End-Use Subcategory s = modelObject.endUseSubcategory(); if (s) { refrigerationSystem.setString(Refrigeration_SystemFields::EndUseSubcategory,s.get()); } //Number of Compressor Stages s = modelObject.numberofCompressorStages(); if (s) { refrigerationSystem.setString(Refrigeration_SystemFields::NumberofCompressorStages,s.get()); } //Intercooler Type s = modelObject.intercoolerType(); if (s) { refrigerationSystem.setString(Refrigeration_SystemFields::IntercoolerType,s.get()); } //Shell-and-Coil Intercooler Effectiveness d = modelObject.shellandCoilIntercoolerEffectiveness(); if (d) { refrigerationSystem.setDouble(Refrigeration_SystemFields::ShellandCoilIntercoolerEffectiveness,d.get()); } //High-Stage Compressor or CompressorList Name std::vector<RefrigerationCompressor> highStageCompressors = modelObject.highStageCompressors(); if( !highStageCompressors.empty() ) { // Name name = " High Stage Compressor List"; refrigerationSystem.setString(Refrigeration_SystemFields::HighStageCompressororCompressorListName, refrigerationSystem.name().get() + name); IdfObject _highStageCompressorList(IddObjectType::Refrigeration_CompressorList); m_idfObjects.push_back(_highStageCompressorList); _highStageCompressorList.setName(refrigerationSystem.name().get() + name); for( std::vector<RefrigerationCompressor>::iterator it = highStageCompressors.begin(); it != highStageCompressors.end(); it++ ) { boost::optional<IdfObject> _highStageCompressor = translateAndMapModelObject(*it); if( _highStageCompressor ) { IdfExtensibleGroup eg = _highStageCompressorList.pushExtensibleGroup(); eg.setString(Refrigeration_CompressorListExtensibleFields::RefrigerationCompressorName,_highStageCompressor->name().get()); } } } return refrigerationSystem; }