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;
}
