boost::optional<IdfObject> ForwardTranslator::translateRefrigerationWalkIn( RefrigerationWalkIn & modelObject ) { OptionalModelObject temp; boost::optional<std::string> s; boost::optional<double> d; // Name IdfObject refrigerationWalkIn = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_WalkIn, modelObject); //AvailabilityScheduleName boost::optional<Schedule> availabilitySchedule = modelObject.availabilitySchedule(); if( availabilitySchedule ) { boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule.get()); if( _availabilitySchedule && _availabilitySchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::AvailabilityScheduleName,_availabilitySchedule->name().get()); } } //RatedCoilCoolingCapacity d = modelObject.ratedCoilCoolingCapacity(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedCoilCoolingCapacity,d.get()); } //OperatingTemperature d = modelObject.operatingTemperature(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::OperatingTemperature,d.get()); } //RatedCoolingSourceTemperature d = modelObject.ratedCoolingSourceTemperature(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedCoolingSourceTemperature,d.get()); } //RatedTotalHeatingPower d = modelObject.ratedTotalHeatingPower(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedTotalHeatingPower,d.get()); } //HeatingPowerScheduleName boost::optional<Schedule> heatingPowerSchedule = modelObject.heatingPowerSchedule(); if( heatingPowerSchedule ) { boost::optional<IdfObject> _heatingPowerSchedule = translateAndMapModelObject(heatingPowerSchedule.get()); if( _heatingPowerSchedule && _heatingPowerSchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::HeatingPowerScheduleName,_heatingPowerSchedule->name().get()); } } //RatedCoolingCoilFanPower d = modelObject.ratedCoolingCoilFanPower(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedCoolingCoilFanPower,d.get()); } //RatedCirculationFanPower d = modelObject.ratedCirculationFanPower(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedCirculationFanPower,d.get()); } //RatedTotalLightingPower d = modelObject.ratedTotalLightingPower(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::RatedTotalLightingPower,d.get()); } //LightingScheduleName boost::optional<Schedule> lightingSchedule = modelObject.lightingSchedule(); if( lightingSchedule ) { boost::optional<IdfObject> _lightingSchedule = translateAndMapModelObject(lightingSchedule.get()); if( _lightingSchedule && _lightingSchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::LightingScheduleName,_lightingSchedule->name().get()); } } //DefrostType s = modelObject.defrostType(); if (s) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostType,s.get()); } //DefrostControlType s = modelObject.defrostControlType(); if (s) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostControlType,s.get()); } //DefrostCycleParameters boost::optional<int> durationofDefrostCycle = modelObject.durationofDefrostCycle(); boost::optional<int> dripDownTime = modelObject.dripDownTime(); std::vector<openstudio::Time> defrostStartTimes = modelObject.getImpl<model::detail::RefrigerationWalkIn_Impl>()->defrostStartTimes(); if( durationofDefrostCycle && dripDownTime && !defrostStartTimes.empty() ) { int defrostTimeHour = *durationofDefrostCycle / 60; int defrostTimeMin = *durationofDefrostCycle % 60; int dripDownTimeHour = *dripDownTime / 60; int dripDownTimeMin = *dripDownTime % 60; std::vector< std::pair<openstudio::Time, double> > defrostDefaultDay; std::vector< std::pair<openstudio::Time, double> > dripDownDefaultDay; for( auto _defrostStartTime = defrostStartTimes.begin(); _defrostStartTime != defrostStartTimes.end(); ++_defrostStartTime ) { defrostDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // defrost off openstudio::Time defrostEndTime(0, _defrostStartTime->hours() + defrostTimeHour, _defrostStartTime->minutes() + defrostTimeMin); defrostDefaultDay.push_back(std::make_pair(defrostEndTime, 1)); // defrost on dripDownDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // drip down off openstudio::Time dripDownEndTime(0, _defrostStartTime->hours() + defrostTimeHour + dripDownTimeHour, _defrostStartTime->minutes() + defrostTimeMin + dripDownTimeMin); dripDownDefaultDay.push_back(std::make_pair(dripDownEndTime, 1)); // drip down on } if( (defrostStartTimes.front().hours() != 0 && defrostStartTimes.front().minutes() != 0) || defrostStartTimes.back().hours() < 24) { openstudio::Time defrostDayEnd(0, 24, 0); defrostDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // defrost off dripDownDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // drip down off } //DefrostScheduleName std::string defrostName(modelObject.name().get() + " Defrost Schedule"); boost::optional<IdfObject> defrostSchedule = this->createSimpleSchedule(defrostName, defrostDefaultDay); if( defrostSchedule ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostScheduleName, defrostName); } //DefrostDripDownScheduleName std::string dripDownName(modelObject.name().get() + " Defrost Drip Down Schedule"); boost::optional<IdfObject> defrostDripDownSchedule = this->createSimpleSchedule(dripDownName, dripDownDefaultDay); if( defrostDripDownSchedule ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostDripDownScheduleName, dripDownName); } } else { //DefrostScheduleName boost::optional<Schedule> defrostSchedule = modelObject.defrostSchedule(); if( defrostSchedule ) { boost::optional<IdfObject> _defrostSchedule = translateAndMapModelObject(defrostSchedule.get()); if( _defrostSchedule && _defrostSchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostScheduleName,_defrostSchedule->name().get()); } } //DefrostDripDownScheduleName boost::optional<Schedule> defrostDripDownSchedule = modelObject.defrostDripDownSchedule(); if( defrostDripDownSchedule ) { boost::optional<IdfObject> _defrostDripDownSchedule = translateAndMapModelObject(defrostDripDownSchedule.get()); if( _defrostDripDownSchedule && _defrostDripDownSchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::DefrostDripDownScheduleName,_defrostDripDownSchedule->name().get()); } } } //DefrostPower d = modelObject.defrostPower(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::DefrostPower,d.get()); } //TemperatureTerminationDefrostFractiontoIce d = modelObject.temperatureTerminationDefrostFractiontoIce(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::TemperatureTerminationDefrostFractiontoIce,d.get()); } //RestockingScheduleName boost::optional<Schedule> restockingSchedule = modelObject.restockingSchedule(); if( restockingSchedule ) { boost::optional<IdfObject> _restockingSchedule = translateAndMapModelObject(restockingSchedule.get()); if( _restockingSchedule && _restockingSchedule->name() ) { refrigerationWalkIn.setString(Refrigeration_WalkInFields::RestockingScheduleName,_restockingSchedule->name().get()); } } //AverageRefrigerantChargeInventory d = modelObject.averageRefrigerantChargeInventory(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::AverageRefrigerantChargeInventory,d.get()); } //InsulatedFloorSurfaceArea d = modelObject.insulatedFloorSurfaceArea(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::InsulatedFloorSurfaceArea,d.get()); } //InsulatedFloorUValue d = modelObject.insulatedFloorUValue(); if (d) { refrigerationWalkIn.setDouble(Refrigeration_WalkInFields::InsulatedFloorUValue,d.get()); } //ZoneBoundaries std::vector<RefrigerationWalkInZoneBoundary> zoneBoundaries = modelObject.zoneBoundaries(); if( !zoneBoundaries.empty() ) { for( const auto & _zoneBoundary : zoneBoundaries ) { IdfExtensibleGroup eg = refrigerationWalkIn.pushExtensibleGroup(); //ZoneName boost::optional<ThermalZone> thermalZone = _zoneBoundary.thermalZone(); if( thermalZone ) { boost::optional<IdfObject> _thermalZone = translateAndMapModelObject(thermalZone.get()); if( _thermalZone && _thermalZone->name() ) { eg.setString(Refrigeration_WalkInExtensibleFields::ZoneName,_thermalZone->name().get()); } } //TotalInsulatedSurfaceAreaFacingZone d = _zoneBoundary.totalInsulatedSurfaceAreaFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::TotalInsulatedSurfaceAreaFacingZone,d.get()); } //InsulatedSurfaceUValueFacingZone d = _zoneBoundary.insulatedSurfaceUValueFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::InsulatedSurfaceUValueFacingZone,d.get()); } //AreaofGlassReachInDoorsFacingZone d = _zoneBoundary.areaofGlassReachInDoorsFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::AreaofGlassReachInDoorsFacingZone,d.get()); } //HeightofGlassReachInDoorsFacingZone d = _zoneBoundary.heightofGlassReachInDoorsFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::HeightofGlassReachInDoorsFacingZone,d.get()); } //GlassReachInDoorUValueFacingZone d = _zoneBoundary.glassReachInDoorUValueFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::GlassReachInDoorUValueFacingZone,d.get()); } //GlassReachInDoorOpeningScheduleNameFacingZone boost::optional<Schedule> glassReachInDoorOpeningScheduleFacingZone = _zoneBoundary.glassReachInDoorOpeningScheduleFacingZone(); if( glassReachInDoorOpeningScheduleFacingZone ) { boost::optional<IdfObject> _glassReachInDoorOpeningScheduleFacingZone = translateAndMapModelObject(glassReachInDoorOpeningScheduleFacingZone.get()); if( _glassReachInDoorOpeningScheduleFacingZone && _glassReachInDoorOpeningScheduleFacingZone->name() ) { eg.setString(Refrigeration_WalkInExtensibleFields::GlassReachInDoorOpeningScheduleNameFacingZone,_glassReachInDoorOpeningScheduleFacingZone->name().get()); } } //AreaofStockingDoorsFacingZone d = _zoneBoundary.areaofStockingDoorsFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::AreaofStockingDoorsFacingZone,d.get()); } //HeightofStockingDoorsFacingZone d = _zoneBoundary.heightofStockingDoorsFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::HeightofStockingDoorsFacingZone,d.get()); } //StockingDoorUValueFacingZone d = _zoneBoundary.stockingDoorUValueFacingZone(); if (d) { eg.setDouble(Refrigeration_WalkInExtensibleFields::StockingDoorUValueFacingZone,d.get()); } //StockingDoorOpeningScheduleNameFacingZone boost::optional<Schedule> stockingDoorOpeningScheduleFacingZone = _zoneBoundary.stockingDoorOpeningScheduleFacingZone(); if( stockingDoorOpeningScheduleFacingZone ) { boost::optional<IdfObject> _stockingDoorOpeningScheduleFacingZone = translateAndMapModelObject(stockingDoorOpeningScheduleFacingZone.get()); if( _stockingDoorOpeningScheduleFacingZone && _stockingDoorOpeningScheduleFacingZone->name() ) { eg.setString(Refrigeration_WalkInExtensibleFields::StockingDoorOpeningScheduleNameFacingZone,_stockingDoorOpeningScheduleFacingZone->name().get()); } } //StockingDoorOpeningProtectionTypeFacingZone s = _zoneBoundary.stockingDoorOpeningProtectionTypeFacingZone(); if (s) { eg.setString(Refrigeration_WalkInExtensibleFields::StockingDoorOpeningProtectionTypeFacingZone,s.get()); } } } return refrigerationWalkIn; }
boost::optional<IdfObject> ForwardTranslator::translateRefrigerationCase( RefrigerationCase & modelObject ) { OptionalModelObject temp; OptionalString optS; boost::optional<std::string> s; boost::optional<double> d; // Name IdfObject object = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_Case, modelObject); // AvailabilityScheduleName boost::optional<Schedule> availabilitySchedule = modelObject.availabilitySchedule(); if( availabilitySchedule ) { boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule.get()); if( _availabilitySchedule && _availabilitySchedule->name() ) { object.setString(Refrigeration_CaseFields::AvailabilityScheduleName,_availabilitySchedule->name().get()); } } //Zone Name boost::optional<ThermalZone> thermalZone = modelObject.thermalZone(); if( thermalZone ) { boost::optional<IdfObject> _thermalZone = translateAndMapModelObject(thermalZone.get()); if( _thermalZone && _thermalZone->name() ) { object.setString(Refrigeration_CaseFields::ZoneName,_thermalZone->name().get()); } } //RatedAmbientTemperature d = modelObject.ratedAmbientTemperature(); if (d) { object.setDouble(Refrigeration_CaseFields::RatedAmbientTemperature,d.get()); } //RatedAmbientRelativeHumidity d = modelObject.ratedAmbientRelativeHumidity(); if (d) { object.setDouble(Refrigeration_CaseFields::RatedAmbientRelativeHumidity,d.get()); } //RatedLatentHeatRatio d = modelObject.ratedLatentHeatRatio(); if (d) { object.setDouble(Refrigeration_CaseFields::RatedLatentHeatRatio,d.get()); } //RatedRuntimeFraction d = modelObject.ratedRuntimeFraction(); if (d) { object.setDouble(Refrigeration_CaseFields::RatedRuntimeFraction,d.get()); } //CaseLength d = modelObject.caseLength(); if (d) { object.setDouble(Refrigeration_CaseFields::CaseLength,d.get()); } //CaseOperatingTemperature d = modelObject.caseOperatingTemperature(); if (d) { object.setDouble(Refrigeration_CaseFields::CaseOperatingTemperature,d.get()); } //LatentCaseCreditCurveType s = modelObject.latentCaseCreditCurveType(); if (s) { object.setString(Refrigeration_CaseFields::LatentCaseCreditCurveType,s.get()); } //LatentCaseCreditCurveName boost::optional<CurveCubic> latentCaseCreditCurve = modelObject.latentCaseCreditCurve(); if( latentCaseCreditCurve ) { boost::optional<IdfObject> _latentCaseCreditCurve = translateAndMapModelObject(latentCaseCreditCurve.get()); if( _latentCaseCreditCurve && _latentCaseCreditCurve->name() ) { object.setString(Refrigeration_CaseFields::LatentCaseCreditCurveName,_latentCaseCreditCurve->name().get()); } } //CaseLightingScheduleName boost::optional<Schedule> caseLightingSchedule = modelObject.caseLightingSchedule(); if( caseLightingSchedule ) { boost::optional<IdfObject> _caseLightingSchedule = translateAndMapModelObject(caseLightingSchedule.get()); if( _caseLightingSchedule && _caseLightingSchedule->name() ) { object.setString(Refrigeration_CaseFields::CaseLightingScheduleName,_caseLightingSchedule->name().get()); } } //FractionofLightingEnergytoCase d = modelObject.fractionofLightingEnergytoCase(); if (d) { object.setDouble(Refrigeration_CaseFields::FractionofLightingEnergytoCase,d.get()); } //AntiSweatHeaterControlType s = modelObject.antiSweatHeaterControlType(); if (s) { object.setString(Refrigeration_CaseFields::AntiSweatHeaterControlType,s.get()); } //HumidityatZeroAntiSweatHeaterEnergy d = modelObject.humidityatZeroAntiSweatHeaterEnergy(); if (d) { object.setDouble(Refrigeration_CaseFields::HumidityatZeroAntiSweatHeaterEnergy,d.get()); } //CaseHeight d = modelObject.caseHeight(); if (d) { object.setDouble(Refrigeration_CaseFields::CaseHeight,d.get()); } //FractionofAntiSweatHeaterEnergytoCase d = modelObject.fractionofAntiSweatHeaterEnergytoCase(); if (d) { object.setDouble(Refrigeration_CaseFields::FractionofAntiSweatHeaterEnergytoCase,d.get()); } //CaseDefrostType s = modelObject.caseDefrostType(); if (s) { object.setString(Refrigeration_CaseFields::CaseDefrostType,s.get()); } //DefrostCycleParameters boost::optional<int> durationofDefrostCycle = modelObject.durationofDefrostCycle(); boost::optional<int> dripDownTime = modelObject.dripDownTime(); std::vector<openstudio::Time> defrostStartTimes = modelObject.getImpl<model::detail::RefrigerationCase_Impl>()->defrostStartTimes(); if( durationofDefrostCycle && dripDownTime && !defrostStartTimes.empty() ) { int defrostTimeHour = *durationofDefrostCycle / 60; int defrostTimeMin = *durationofDefrostCycle % 60; int dripDownTimeHour = *dripDownTime / 60; int dripDownTimeMin = *dripDownTime % 60; std::vector< std::pair<openstudio::Time, double> > defrostDefaultDay; std::vector< std::pair<openstudio::Time, double> > dripDownDefaultDay; for( auto _defrostStartTime = defrostStartTimes.begin(); _defrostStartTime != defrostStartTimes.end(); ++_defrostStartTime ) { defrostDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // defrost off openstudio::Time defrostEndTime(0, _defrostStartTime->hours() + defrostTimeHour, _defrostStartTime->minutes() + defrostTimeMin); defrostDefaultDay.push_back(std::make_pair(defrostEndTime, 1)); // defrost on dripDownDefaultDay.push_back(std::make_pair(*_defrostStartTime, 0)); // drip down off openstudio::Time dripDownEndTime(0, _defrostStartTime->hours() + defrostTimeHour + dripDownTimeHour, _defrostStartTime->minutes() + defrostTimeMin + dripDownTimeMin); dripDownDefaultDay.push_back(std::make_pair(dripDownEndTime, 1)); // drip down on } if( (defrostStartTimes.front().hours() != 0 && defrostStartTimes.front().minutes() != 0) || defrostStartTimes.back().hours() < 24) { openstudio::Time defrostDayEnd(0, 24, 0); defrostDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // defrost off dripDownDefaultDay.push_back(std::make_pair(defrostDayEnd, 0)); // drip down off } //CaseDefrostScheduleName std::string defrostName(modelObject.name().get() + " Defrost Schedule"); boost::optional<IdfObject> defrostSchedule = this->createSimpleSchedule(defrostName, defrostDefaultDay); if( defrostSchedule ) { object.setString(Refrigeration_CaseFields::CaseDefrostScheduleName, defrostName); } //CaseDefrostDripDownScheduleName std::string dripDownName(modelObject.name().get() + " Defrost Drip Down Schedule"); boost::optional<IdfObject> defrostDripDownSchedule = this->createSimpleSchedule(dripDownName, dripDownDefaultDay); if( defrostDripDownSchedule ) { object.setString(Refrigeration_CaseFields::CaseDefrostDripDownScheduleName, dripDownName); } } else { //CaseDefrostScheduleName boost::optional<Schedule> caseDefrostSchedule = modelObject.caseDefrostSchedule(); if( caseDefrostSchedule ) { boost::optional<IdfObject> _caseDefrostSchedule = translateAndMapModelObject(caseDefrostSchedule.get()); if( _caseDefrostSchedule && _caseDefrostSchedule->name() ) { object.setString(Refrigeration_CaseFields::CaseDefrostScheduleName,_caseDefrostSchedule->name().get()); } } //CaseDefrostDripDownScheduleName boost::optional<Schedule> caseDefrostDripDownSchedule = modelObject.caseDefrostDripDownSchedule(); if( caseDefrostDripDownSchedule ) { boost::optional<IdfObject> _caseDefrostDripDownSchedule = translateAndMapModelObject(caseDefrostDripDownSchedule.get()); if( _caseDefrostDripDownSchedule && _caseDefrostDripDownSchedule->name() ) { object.setString(Refrigeration_CaseFields::CaseDefrostDripDownScheduleName,_caseDefrostDripDownSchedule->name().get()); } } } //DefrostEnergyCorrectionCurveType { auto value = modelObject.defrostEnergyCorrectionCurveType(); object.setString(Refrigeration_CaseFields::DefrostEnergyCorrectionCurveType,value); } //DefrostEnergyCorrectionCurveName if( auto defrostEnergyCorrectionCurve = modelObject.defrostEnergyCorrectionCurve() ) { auto type = modelObject.caseDefrostType(); // Only for these types or E+ will halt. if( istringEqual(type,"HotGasWithTemperatureTermination") || istringEqual(type,"ElectricWithTemperatureTermination") || istringEqual(type,"HotFluidWithTemperatureTermination") ) { boost::optional<IdfObject> _defrostEnergyCorrectionCurve = translateAndMapModelObject(defrostEnergyCorrectionCurve.get()); if( _defrostEnergyCorrectionCurve && _defrostEnergyCorrectionCurve->name() ) { object.setString(Refrigeration_CaseFields::DefrostEnergyCorrectionCurveName,_defrostEnergyCorrectionCurve->name().get()); } } } //UnderCaseHVACReturnAirFraction d = modelObject.underCaseHVACReturnAirFraction(); if (d) { object.setDouble(Refrigeration_CaseFields::UnderCaseHVACReturnAirFraction,d.get()); } //RefrigeratedCaseRestockingScheduleName boost::optional<Schedule> refrigeratedCaseRestockingSchedule = modelObject.refrigeratedCaseRestockingSchedule(); if( refrigeratedCaseRestockingSchedule ) { boost::optional<IdfObject> _refrigeratedCaseRestockingSchedule = translateAndMapModelObject(refrigeratedCaseRestockingSchedule.get()); if( _refrigeratedCaseRestockingSchedule && _refrigeratedCaseRestockingSchedule->name() ) { object.setString(Refrigeration_CaseFields::RefrigeratedCaseRestockingScheduleName,_refrigeratedCaseRestockingSchedule->name().get()); } } //CaseCreditFractionScheduleName boost::optional<Schedule> caseCreditFractionSchedule = modelObject.caseCreditFractionSchedule(); if( caseCreditFractionSchedule ) { boost::optional<IdfObject> _caseCreditFractionSchedule = translateAndMapModelObject(caseCreditFractionSchedule.get()); if( _caseCreditFractionSchedule && _caseCreditFractionSchedule->name() ) { object.setString(Refrigeration_CaseFields::CaseCreditFractionScheduleName,_caseCreditFractionSchedule->name().get()); } } //DesignEvaporatorTemperatureorBrineInletTemperature d = modelObject.designEvaporatorTemperatureorBrineInletTemperature(); if (d) { object.setDouble(Refrigeration_CaseFields::DesignEvaporatorTemperatureorBrineInletTemperature,d.get()); } //AverageRefrigerantChargeInventory d = modelObject.averageRefrigerantChargeInventory(); if (d) { object.setDouble(Refrigeration_CaseFields::AverageRefrigerantChargeInventory,d.get()); } boost::optional<double> ratedTotalCoolingCapacity; boost::optional<double> standardCaseFanPower; boost::optional<double> operatingCaseFanPower; boost::optional<double> standardCaseLightingPower; boost::optional<double> installedCaseLightingPower; boost::optional<double> caseAntiSweatHeaterPower; boost::optional<double> minimumAntiSweatHeaterPower; boost::optional<double> caseDefrostPower; std::string const unitType = modelObject.unitType(); if(istringEqual("UnitLength", unitType)) { ratedTotalCoolingCapacity = modelObject.ratedTotalCoolingCapacityperUnitLength(); standardCaseFanPower = modelObject.standardCaseFanPowerperUnitLength(); operatingCaseFanPower = modelObject.operatingCaseFanPowerperUnitLength(); standardCaseLightingPower = modelObject.standardCaseLightingPowerperUnitLength(); installedCaseLightingPower = modelObject.installedCaseLightingPowerperUnitLength(); caseAntiSweatHeaterPower = modelObject.caseAntiSweatHeaterPowerperUnitLength(); minimumAntiSweatHeaterPower = modelObject.minimumAntiSweatHeaterPowerperUnitLength(); caseDefrostPower = modelObject.caseDefrostPowerperUnitLength(); } else { // NumberOfDoors boost::optional<int> numberOfDoors = modelObject.numberOfDoors(); boost::optional<double> caseLength = modelObject.caseLength(); if( !numberOfDoors ) { LOG(Error, "Missing required input 'NumberOfDoors' for Refrigeration:Case named '" << modelObject.name().get() << "'"); } if( !caseLength ) { LOG(Error, "Missing required input 'CaseLength' for Refrigeration:Case named '" << modelObject.name().get() << "'"); } double conversion = numberOfDoors.get() / caseLength.get(); if( ( ratedTotalCoolingCapacity = modelObject.ratedTotalCoolingCapacityperDoor() ) ) { ratedTotalCoolingCapacity = ratedTotalCoolingCapacity.get() * conversion; } if( ( standardCaseFanPower = modelObject.standardCaseFanPowerperDoor() ) ) { standardCaseFanPower = standardCaseFanPower.get() * conversion; } if( ( operatingCaseFanPower = modelObject.operatingCaseFanPowerperDoor() ) ) { operatingCaseFanPower = operatingCaseFanPower.get() * conversion; } if( ( standardCaseLightingPower = modelObject.standardCaseLightingPowerperDoor() ) ) { standardCaseLightingPower = standardCaseLightingPower.get() * conversion; } if( ( installedCaseLightingPower = modelObject.installedCaseLightingPowerperDoor() ) ) { installedCaseLightingPower = installedCaseLightingPower.get() * conversion; } if( ( caseAntiSweatHeaterPower = modelObject.caseAntiSweatHeaterPowerperDoor() ) ) { caseAntiSweatHeaterPower = caseAntiSweatHeaterPower.get() * conversion; } if( ( minimumAntiSweatHeaterPower = modelObject.minimumAntiSweatHeaterPowerperDoor() ) ) { minimumAntiSweatHeaterPower = minimumAntiSweatHeaterPower.get() * conversion; } if( ( caseDefrostPower = modelObject.caseDefrostPowerperDoor() ) ) { caseDefrostPower = caseDefrostPower.get() * conversion; } } //RatedTotalCoolingCapacityperUnitLength if (ratedTotalCoolingCapacity) { object.setDouble(Refrigeration_CaseFields::RatedTotalCoolingCapacityperUnitLength,ratedTotalCoolingCapacity.get()); } //StandardCaseFanPowerperUnitLength if (standardCaseFanPower) { object.setDouble(Refrigeration_CaseFields::StandardCaseFanPowerperUnitLength,standardCaseFanPower.get()); } //OperatingCaseFanPowerperUnitLength if (operatingCaseFanPower) { object.setDouble(Refrigeration_CaseFields::OperatingCaseFanPowerperUnitLength,operatingCaseFanPower.get()); } //StandardCaseLightingPowerperUnitLength if (standardCaseLightingPower) { object.setDouble(Refrigeration_CaseFields::StandardCaseLightingPowerperUnitLength,standardCaseLightingPower.get()); } //InstalledCaseLightingPowerperUnitLength if (installedCaseLightingPower) { object.setDouble(Refrigeration_CaseFields::InstalledCaseLightingPowerperUnitLength,installedCaseLightingPower.get()); } //CaseAntiSweatHeaterPowerperUnitLength if (caseAntiSweatHeaterPower) { object.setDouble(Refrigeration_CaseFields::CaseAntiSweatHeaterPowerperUnitLength,caseAntiSweatHeaterPower.get()); } //MinimumAntiSweatHeaterPowerperUnitLength if (minimumAntiSweatHeaterPower) { object.setDouble(Refrigeration_CaseFields::MinimumAntiSweatHeaterPowerperUnitLength,minimumAntiSweatHeaterPower.get()); } //CaseDefrostPowerperUnitLength if (caseDefrostPower) { object.setDouble(Refrigeration_CaseFields::CaseDefrostPowerperUnitLength,caseDefrostPower.get()); } return object; }