boost::optional<IdfObject> ForwardTranslator::translateRefrigerationSecondarySystem( RefrigerationSecondarySystem & modelObject )
{
  OptionalModelObject temp;
  boost::optional<std::string> s;
  boost::optional<double> d;
  boost::optional<int> i;
  std::string name;

// Name
  IdfObject refrigerationSecondarySystem = createRegisterAndNameIdfObject(openstudio::IddObjectType::Refrigeration_SecondarySystem,
                                                          modelObject);

//RefrigeratedCaseorWalkinorCaseAndWalkInListName
  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";
    refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::RefrigeratedCaseorWalkinorCaseAndWalkInListName, refrigerationSecondarySystem.name().get() + name);

    IdfObject _caseAndWalkinList(IddObjectType::Refrigeration_CaseAndWalkInList);

    m_idfObjects.push_back(_caseAndWalkinList);

    _caseAndWalkinList.setName(refrigerationSecondarySystem.name().get() + name);

    for( auto & elem : cases )
    {
      boost::optional<IdfObject> _case = translateAndMapModelObject(elem);

      if( _case )
      {
        IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup();

        eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_case->name().get()); 
      }
    }

    for( auto & elem : walkins )
    {
      boost::optional<IdfObject> _walkin = translateAndMapModelObject(elem);

      if( _walkin )
      {
        IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup();

        eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_walkin->name().get()); 
      }
    }

    for( auto & elem : airChillers )
    {
      boost::optional<IdfObject> _airChiller = translateAndMapModelObject(elem);

      if( _airChiller )
      {
        IdfExtensibleGroup eg = _caseAndWalkinList.pushExtensibleGroup();

        eg.setString(Refrigeration_CaseAndWalkInListExtensibleFields::CaseorWalkInName,_airChiller->name().get()); 
      }
    }
  }

//CirculatingFluidType
//CirculatingFluidName
  s = modelObject.circulatingFluidName();
  if (s) {
    i = modelObject.glycolConcentration();
    boost::optional<IdfObject> fluidProperties;
    if ( i && (istringEqual(s.get(), "PropyleneGlycol") || istringEqual(s.get(), "EthyleneGlycol")) ) {
      fluidProperties = createFluidProperties(s.get(), i.get());
      refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::CirculatingFluidType,"FluidAlwaysLiquid");
    } else {
      fluidProperties = createFluidProperties(s.get());
      refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::CirculatingFluidType,"FluidPhaseChange");
    }
    if( fluidProperties ) {
      boost::optional<std::string> value = fluidProperties.get().getString(FluidProperties_NameFields::FluidName,true);
      if( value ) {
        refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::CirculatingFluidName,value.get());
      }
    }
  }

//EvaporatorCapacity
  d = modelObject.evaporatorCapacity();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorCapacity,d.get());
  }

//EvaporatorFlowRateforSecondaryFluid
  d = modelObject.evaporatorFlowRateforSecondaryFluid();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorFlowRateforSecondaryFluid,d.get());
  }

//EvaporatorEvaporatingTemperature
  d = modelObject.evaporatorEvaporatingTemperature();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorEvaporatingTemperature,d.get());
  }

//EvaporatorApproachTemperatureDifference
  d = modelObject.evaporatorApproachTemperatureDifference();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorApproachTemperatureDifference,d.get());
  }

//EvaporatorRangeTemperatureDifference
  d = modelObject.evaporatorRangeTemperatureDifference();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorRangeTemperatureDifference,d.get());
  }

//NumberofPumpsinLoop
  i = modelObject.numberofPumpsinLoop();
  if (i) {
    refrigerationSecondarySystem.setInt(Refrigeration_SecondarySystemFields::NumberofPumpsinLoop,d.get());
  }

//TotalPumpFlowRate
  d = modelObject.totalPumpFlowRate();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::TotalPumpFlowRate,d.get());
  }

//TotalPumpPower
  d = modelObject.totalPumpPower();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::TotalPumpPower,d.get());
  }

//TotalPumpHead
  d = modelObject.totalPumpHead();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::TotalPumpHead,d.get());
  }

//PhaseChangeCirculatingRate
  d = modelObject.phaseChangeCirculatingRate();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::PhaseChangeCirculatingRate,d.get());
  }

//PumpDriveType
  s = modelObject.pumpDriveType();
  if (s) {
    refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::PumpDriveType,s.get());
  }

//VariableSpeedPumpCubicCurveName
  boost::optional<CurveCubic> variableSpeedPumpCubicCurve = modelObject.variableSpeedPumpCubicCurve();

  if( variableSpeedPumpCubicCurve )
  {
    boost::optional<IdfObject> _variableSpeedPumpCubicCurve = translateAndMapModelObject(variableSpeedPumpCubicCurve.get());

    if( _variableSpeedPumpCubicCurve && _variableSpeedPumpCubicCurve->name() )
    {
      refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::VariableSpeedPumpCubicCurveName,_variableSpeedPumpCubicCurve->name().get());
    }
  }

//PumpMotorHeattoFluid
  d = modelObject.pumpMotorHeattoFluid();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::PumpMotorHeattoFluid,d.get());
  }

//SumUADistributionPiping
  d = modelObject.sumUADistributionPiping();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::SumUADistributionPiping,d.get());
  }

//DistributionPipingZoneName
  boost::optional<ThermalZone> distributionPipingZone = modelObject.distributionPipingZone();

  if( distributionPipingZone )
  {
    boost::optional<IdfObject> _distributionPipingZone = translateAndMapModelObject(distributionPipingZone.get());

    if( _distributionPipingZone && _distributionPipingZone->name() )
    {
      refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::DistributionPipingZoneName,_distributionPipingZone->name().get());
    }
  }

//SumUAReceiver_SeparatorShell
  d = modelObject.sumUAReceiverSeparatorShell();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::SumUAReceiver_SeparatorShell,d.get());
  }

//Receiver_SeparatorZoneName
  boost::optional<ThermalZone> receiverSeparatorZone = modelObject.receiverSeparatorZone();

  if( receiverSeparatorZone )
  {
    boost::optional<IdfObject> _receiverSeparatorZone = translateAndMapModelObject(receiverSeparatorZone.get());

    if( _receiverSeparatorZone && _receiverSeparatorZone->name() )
    {
      refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::Receiver_SeparatorZoneName,_receiverSeparatorZone->name().get());
    }
  }

//EvaporatorRefrigerantInventory
  d = modelObject.evaporatorRefrigerantInventory();
  if (d) {
    refrigerationSecondarySystem.setDouble(Refrigeration_SecondarySystemFields::EvaporatorRefrigerantInventory,d.get());
  }

//EndUseSubcategory
  s = modelObject.endUseSubcategory();
  if (s) {
    refrigerationSecondarySystem.setString(Refrigeration_SecondarySystemFields::EndUseSubcategory,s.get());
  }

  return refrigerationSecondarySystem;

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

}
コード例 #3
0
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;

}