text: // Copyright (c) 2005-2014 Code Synthesis Tools CC
  //
  // This program was generated by CodeSynthesis XSD, an XML Schema to
  // C++ data binding compiler.
  //
  // This program is free software; you can redistribute it and/or modify
  // it under the terms of the GNU General Public License version 2 as
  // published by the Free Software Foundation.
  //
  // This program is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program; if not, write to the Free Software
  // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  //
  // In addition, as a special exception, Code Synthesis Tools CC gives
  // permission to link this program with the Xerces-C++ library (or with
  // modified versions of Xerces-C++ that use the same license as Xerces-C++),
  // and distribute linked combinations including the two. You must obey
  // the GNU General Public License version 2 in all respects for all of
  // the code used other than Xerces-C++. If you modify this copy of the
  // program, you may extend this exception to your version of the program,
  // but you are not obligated to do so. If you do not wish to do so, delete
  // this exception statement from your version.
  //
  // Furthermore, Code Synthesis Tools CC makes a special exception for
  // the Free/Libre and Open Source Software (FLOSS) which is described
  // in the accompanying FLOSSE file.
  //
  
  // Begin prologue.
  //
  //
  // End prologue.
  
  #include <xsd/cxx/pre.hxx>
  
  #include "SimFlowPlant_Chiller_AbsorptionIndirect.hxx"
  
  namespace schema
  {
    namespace simxml
    {
      namespace MepModel
      {
        // SimFlowPlant_Chiller_AbsorptionIndirect
        // 
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_Name_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Name () const
        {
          return this->SimFlowPlant_Name_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_Name_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Name ()
        {
          return this->SimFlowPlant_Name_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Name (const SimFlowPlant_Name_type& x)
        {
          this->SimFlowPlant_Name_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Name (const SimFlowPlant_Name_optional& x)
        {
          this->SimFlowPlant_Name_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Name (::std::auto_ptr< SimFlowPlant_Name_type > x)
        {
          this->SimFlowPlant_Name_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_NomCap_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomCap () const
        {
          return this->SimFlowPlant_NomCap_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_NomCap_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomCap ()
        {
          return this->SimFlowPlant_NomCap_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomCap (const SimFlowPlant_NomCap_type& x)
        {
          this->SimFlowPlant_NomCap_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomCap (const SimFlowPlant_NomCap_optional& x)
        {
          this->SimFlowPlant_NomCap_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_MinPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MinPartLoadRatio () const
        {
          return this->SimFlowPlant_MinPartLoadRatio_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_MinPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MinPartLoadRatio ()
        {
          return this->SimFlowPlant_MinPartLoadRatio_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MinPartLoadRatio (const SimFlowPlant_MinPartLoadRatio_type& x)
        {
          this->SimFlowPlant_MinPartLoadRatio_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MinPartLoadRatio (const SimFlowPlant_MinPartLoadRatio_optional& x)
        {
          this->SimFlowPlant_MinPartLoadRatio_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_MaxPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MaxPartLoadRatio () const
        {
          return this->SimFlowPlant_MaxPartLoadRatio_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_MaxPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MaxPartLoadRatio ()
        {
          return this->SimFlowPlant_MaxPartLoadRatio_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MaxPartLoadRatio (const SimFlowPlant_MaxPartLoadRatio_type& x)
        {
          this->SimFlowPlant_MaxPartLoadRatio_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_MaxPartLoadRatio (const SimFlowPlant_MaxPartLoadRatio_optional& x)
        {
          this->SimFlowPlant_MaxPartLoadRatio_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_OptimumPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_OptimumPartLoadRatio () const
        {
          return this->SimFlowPlant_OptimumPartLoadRatio_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_OptimumPartLoadRatio_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_OptimumPartLoadRatio ()
        {
          return this->SimFlowPlant_OptimumPartLoadRatio_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_OptimumPartLoadRatio (const SimFlowPlant_OptimumPartLoadRatio_type& x)
        {
          this->SimFlowPlant_OptimumPartLoadRatio_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_OptimumPartLoadRatio (const SimFlowPlant_OptimumPartLoadRatio_optional& x)
        {
          this->SimFlowPlant_OptimumPartLoadRatio_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_SizingFactor_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_SizingFactor () const
        {
          return this->SimFlowPlant_SizingFactor_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_SizingFactor_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_SizingFactor ()
        {
          return this->SimFlowPlant_SizingFactor_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_SizingFactor (const SimFlowPlant_SizingFactor_type& x)
        {
          this->SimFlowPlant_SizingFactor_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_SizingFactor (const SimFlowPlant_SizingFactor_optional& x)
        {
          this->SimFlowPlant_SizingFactor_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterInletNodeName () const
        {
          return this->SimFlowPlant_ChilledWaterInletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterInletNodeName ()
        {
          return this->SimFlowPlant_ChilledWaterInletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterInletNodeName (const SimFlowPlant_ChilledWaterInletNodeName_type& x)
        {
          this->SimFlowPlant_ChilledWaterInletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterInletNodeName (const SimFlowPlant_ChilledWaterInletNodeName_optional& x)
        {
          this->SimFlowPlant_ChilledWaterInletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterInletNodeName (::std::auto_ptr< SimFlowPlant_ChilledWaterInletNodeName_type > x)
        {
          this->SimFlowPlant_ChilledWaterInletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletNodeName () const
        {
          return this->SimFlowPlant_ChilledWaterOutletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletNodeName ()
        {
          return this->SimFlowPlant_ChilledWaterOutletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletNodeName (const SimFlowPlant_ChilledWaterOutletNodeName_type& x)
        {
          this->SimFlowPlant_ChilledWaterOutletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletNodeName (const SimFlowPlant_ChilledWaterOutletNodeName_optional& x)
        {
          this->SimFlowPlant_ChilledWaterOutletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletNodeName (::std::auto_ptr< SimFlowPlant_ChilledWaterOutletNodeName_type > x)
        {
          this->SimFlowPlant_ChilledWaterOutletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletNodeName () const
        {
          return this->SimFlowPlant_CondInletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletNodeName ()
        {
          return this->SimFlowPlant_CondInletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletNodeName (const SimFlowPlant_CondInletNodeName_type& x)
        {
          this->SimFlowPlant_CondInletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletNodeName (const SimFlowPlant_CondInletNodeName_optional& x)
        {
          this->SimFlowPlant_CondInletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletNodeName (::std::auto_ptr< SimFlowPlant_CondInletNodeName_type > x)
        {
          this->SimFlowPlant_CondInletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondOutletNodeName () const
        {
          return this->SimFlowPlant_CondOutletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondOutletNodeName ()
        {
          return this->SimFlowPlant_CondOutletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondOutletNodeName (const SimFlowPlant_CondOutletNodeName_type& x)
        {
          this->SimFlowPlant_CondOutletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondOutletNodeName (const SimFlowPlant_CondOutletNodeName_optional& x)
        {
          this->SimFlowPlant_CondOutletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondOutletNodeName (::std::auto_ptr< SimFlowPlant_CondOutletNodeName_type > x)
        {
          this->SimFlowPlant_CondOutletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChillerFlowMode_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChillerFlowMode () const
        {
          return this->SimFlowPlant_ChillerFlowMode_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChillerFlowMode_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChillerFlowMode ()
        {
          return this->SimFlowPlant_ChillerFlowMode_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChillerFlowMode (const SimFlowPlant_ChillerFlowMode_type& x)
        {
          this->SimFlowPlant_ChillerFlowMode_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChillerFlowMode (const SimFlowPlant_ChillerFlowMode_optional& x)
        {
          this->SimFlowPlant_ChillerFlowMode_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChillerFlowMode (::std::auto_ptr< SimFlowPlant_ChillerFlowMode_type > x)
        {
          this->SimFlowPlant_ChillerFlowMode_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignCondInletTemp_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondInletTemp () const
        {
          return this->SimFlowPlant_DesignCondInletTemp_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignCondInletTemp_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondInletTemp ()
        {
          return this->SimFlowPlant_DesignCondInletTemp_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondInletTemp (const SimFlowPlant_DesignCondInletTemp_type& x)
        {
          this->SimFlowPlant_DesignCondInletTemp_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondInletTemp (const SimFlowPlant_DesignCondInletTemp_optional& x)
        {
          this->SimFlowPlant_DesignCondInletTemp_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignChilledWaterFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignChilledWaterFlowRate () const
        {
          return this->SimFlowPlant_DesignChilledWaterFlowRate_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignChilledWaterFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignChilledWaterFlowRate ()
        {
          return this->SimFlowPlant_DesignChilledWaterFlowRate_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignChilledWaterFlowRate (const SimFlowPlant_DesignChilledWaterFlowRate_type& x)
        {
          this->SimFlowPlant_DesignChilledWaterFlowRate_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignChilledWaterFlowRate (const SimFlowPlant_DesignChilledWaterFlowRate_optional& x)
        {
          this->SimFlowPlant_DesignChilledWaterFlowRate_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterOutletTempLowLimit_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletTempLowLimit () const
        {
          return this->SimFlowPlant_ChilledWaterOutletTempLowLimit_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_ChilledWaterOutletTempLowLimit_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletTempLowLimit ()
        {
          return this->SimFlowPlant_ChilledWaterOutletTempLowLimit_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletTempLowLimit (const SimFlowPlant_ChilledWaterOutletTempLowLimit_type& x)
        {
          this->SimFlowPlant_ChilledWaterOutletTempLowLimit_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_ChilledWaterOutletTempLowLimit (const SimFlowPlant_ChilledWaterOutletTempLowLimit_optional& x)
        {
          this->SimFlowPlant_ChilledWaterOutletTempLowLimit_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignCondWaterFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondWaterFlowRate () const
        {
          return this->SimFlowPlant_DesignCondWaterFlowRate_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignCondWaterFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondWaterFlowRate ()
        {
          return this->SimFlowPlant_DesignCondWaterFlowRate_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondWaterFlowRate (const SimFlowPlant_DesignCondWaterFlowRate_type& x)
        {
          this->SimFlowPlant_DesignCondWaterFlowRate_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignCondWaterFlowRate (const SimFlowPlant_DesignCondWaterFlowRate_optional& x)
        {
          this->SimFlowPlant_DesignCondWaterFlowRate_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_NomPumpingPwr_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomPumpingPwr () const
        {
          return this->SimFlowPlant_NomPumpingPwr_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_NomPumpingPwr_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomPumpingPwr ()
        {
          return this->SimFlowPlant_NomPumpingPwr_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomPumpingPwr (const SimFlowPlant_NomPumpingPwr_type& x)
        {
          this->SimFlowPlant_NomPumpingPwr_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_NomPumpingPwr (const SimFlowPlant_NomPumpingPwr_optional& x)
        {
          this->SimFlowPlant_NomPumpingPwr_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondInletTempLowLimit_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletTempLowLimit () const
        {
          return this->SimFlowPlant_CondInletTempLowLimit_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CondInletTempLowLimit_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletTempLowLimit ()
        {
          return this->SimFlowPlant_CondInletTempLowLimit_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletTempLowLimit (const SimFlowPlant_CondInletTempLowLimit_type& x)
        {
          this->SimFlowPlant_CondInletTempLowLimit_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CondInletTempLowLimit (const SimFlowPlant_CondInletTempLowLimit_optional& x)
        {
          this->SimFlowPlant_CondInletTempLowLimit_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName () const
        {
          return this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName ()
        {
          return this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName (const SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_type& x)
        {
          this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName (const SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_optional& x)
        {
          this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName (::std::auto_ptr< SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_type > x)
        {
          this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName () const
        {
          return this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName ()
        {
          return this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName (const SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_type& x)
        {
          this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName (const SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_optional& x)
        {
          this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName (::std::auto_ptr< SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_type > x)
        {
          this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenInletNodeName () const
        {
          return this->SimFlowPlant_GenInletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenInletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenInletNodeName ()
        {
          return this->SimFlowPlant_GenInletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenInletNodeName (const SimFlowPlant_GenInletNodeName_type& x)
        {
          this->SimFlowPlant_GenInletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenInletNodeName (const SimFlowPlant_GenInletNodeName_optional& x)
        {
          this->SimFlowPlant_GenInletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenInletNodeName (::std::auto_ptr< SimFlowPlant_GenInletNodeName_type > x)
        {
          this->SimFlowPlant_GenInletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenOutletNodeName () const
        {
          return this->SimFlowPlant_GenOutletNodeName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenOutletNodeName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenOutletNodeName ()
        {
          return this->SimFlowPlant_GenOutletNodeName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenOutletNodeName (const SimFlowPlant_GenOutletNodeName_type& x)
        {
          this->SimFlowPlant_GenOutletNodeName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenOutletNodeName (const SimFlowPlant_GenOutletNodeName_optional& x)
        {
          this->SimFlowPlant_GenOutletNodeName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenOutletNodeName (::std::auto_ptr< SimFlowPlant_GenOutletNodeName_type > x)
        {
          this->SimFlowPlant_GenOutletNodeName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncCondTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncCondTempCurveName () const
        {
          return this->SimFlowPlant_CapCorrectFuncCondTempCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncCondTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncCondTempCurveName ()
        {
          return this->SimFlowPlant_CapCorrectFuncCondTempCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncCondTempCurveName (const SimFlowPlant_CapCorrectFuncCondTempCurveName_type& x)
        {
          this->SimFlowPlant_CapCorrectFuncCondTempCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncCondTempCurveName (const SimFlowPlant_CapCorrectFuncCondTempCurveName_optional& x)
        {
          this->SimFlowPlant_CapCorrectFuncCondTempCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncCondTempCurveName (::std::auto_ptr< SimFlowPlant_CapCorrectFuncCondTempCurveName_type > x)
        {
          this->SimFlowPlant_CapCorrectFuncCondTempCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName () const
        {
          return this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName ()
        {
          return this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName (const SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_type& x)
        {
          this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName (const SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_optional& x)
        {
          this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName (::std::auto_ptr< SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_type > x)
        {
          this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncGenTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncGenTempCurveName () const
        {
          return this->SimFlowPlant_CapCorrectFuncGenTempCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_CapCorrectFuncGenTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncGenTempCurveName ()
        {
          return this->SimFlowPlant_CapCorrectFuncGenTempCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncGenTempCurveName (const SimFlowPlant_CapCorrectFuncGenTempCurveName_type& x)
        {
          this->SimFlowPlant_CapCorrectFuncGenTempCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncGenTempCurveName (const SimFlowPlant_CapCorrectFuncGenTempCurveName_optional& x)
        {
          this->SimFlowPlant_CapCorrectFuncGenTempCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_CapCorrectFuncGenTempCurveName (::std::auto_ptr< SimFlowPlant_CapCorrectFuncGenTempCurveName_type > x)
        {
          this->SimFlowPlant_CapCorrectFuncGenTempCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName () const
        {
          return this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName ()
        {
          return this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName (const SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_type& x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName (const SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_optional& x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName (::std::auto_ptr< SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_type > x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName () const
        {
          return this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName ()
        {
          return this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName (const SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_type& x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName (const SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_optional& x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName (::std::auto_ptr< SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_type > x)
        {
          this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatSrcType_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatSrcType () const
        {
          return this->SimFlowPlant_GenHeatSrcType_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_GenHeatSrcType_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatSrcType ()
        {
          return this->SimFlowPlant_GenHeatSrcType_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatSrcType (const SimFlowPlant_GenHeatSrcType_type& x)
        {
          this->SimFlowPlant_GenHeatSrcType_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatSrcType (const SimFlowPlant_GenHeatSrcType_optional& x)
        {
          this->SimFlowPlant_GenHeatSrcType_ = x;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_GenHeatSrcType (::std::auto_ptr< SimFlowPlant_GenHeatSrcType_type > x)
        {
          this->SimFlowPlant_GenHeatSrcType_.set (x);
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignGenFluidFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignGenFluidFlowRate () const
        {
          return this->SimFlowPlant_DesignGenFluidFlowRate_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DesignGenFluidFlowRate_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignGenFluidFlowRate ()
        {
          return this->SimFlowPlant_DesignGenFluidFlowRate_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignGenFluidFlowRate (const SimFlowPlant_DesignGenFluidFlowRate_type& x)
        {
          this->SimFlowPlant_DesignGenFluidFlowRate_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DesignGenFluidFlowRate (const SimFlowPlant_DesignGenFluidFlowRate_optional& x)
        {
          this->SimFlowPlant_DesignGenFluidFlowRate_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_TempLowLimitGenInlet_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_TempLowLimitGenInlet () const
        {
          return this->SimFlowPlant_TempLowLimitGenInlet_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_TempLowLimitGenInlet_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_TempLowLimitGenInlet ()
        {
          return this->SimFlowPlant_TempLowLimitGenInlet_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_TempLowLimitGenInlet (const SimFlowPlant_TempLowLimitGenInlet_type& x)
        {
          this->SimFlowPlant_TempLowLimitGenInlet_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_TempLowLimitGenInlet (const SimFlowPlant_TempLowLimitGenInlet_optional& x)
        {
          this->SimFlowPlant_TempLowLimitGenInlet_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DegreeSubcoolingSteamGen_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamGen () const
        {
          return this->SimFlowPlant_DegreeSubcoolingSteamGen_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DegreeSubcoolingSteamGen_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamGen ()
        {
          return this->SimFlowPlant_DegreeSubcoolingSteamGen_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamGen (const SimFlowPlant_DegreeSubcoolingSteamGen_type& x)
        {
          this->SimFlowPlant_DegreeSubcoolingSteamGen_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamGen (const SimFlowPlant_DegreeSubcoolingSteamGen_optional& x)
        {
          this->SimFlowPlant_DegreeSubcoolingSteamGen_ = x;
        }
  
        const SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DegreeSubcoolingSteamCondsLoop_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamCondsLoop () const
        {
          return this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::SimFlowPlant_DegreeSubcoolingSteamCondsLoop_optional& SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamCondsLoop ()
        {
          return this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_;
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamCondsLoop (const SimFlowPlant_DegreeSubcoolingSteamCondsLoop_type& x)
        {
          this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_.set (x);
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_DegreeSubcoolingSteamCondsLoop (const SimFlowPlant_DegreeSubcoolingSteamCondsLoop_optional& x)
        {
          this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ = x;
        }
      }
    }
  }
  
  #include <xsd/cxx/xml/dom/parsing-source.hxx>
  
  #include <xsd/cxx/tree/type-factory-map.hxx>
  
  namespace _xsd
  {
    static
    const ::xsd::cxx::tree::type_factory_plate< 0, char >
    type_factory_plate_init;
  }
  
  namespace schema
  {
    namespace simxml
    {
      namespace MepModel
      {
        // SimFlowPlant_Chiller_AbsorptionIndirect
        //
  
        SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Chiller_AbsorptionIndirect ()
        : ::schema::simxml::MepModel::SimFlowPlant_Chiller (),
          SimFlowPlant_Name_ (this),
          SimFlowPlant_NomCap_ (this),
          SimFlowPlant_MinPartLoadRatio_ (this),
          SimFlowPlant_MaxPartLoadRatio_ (this),
          SimFlowPlant_OptimumPartLoadRatio_ (this),
          SimFlowPlant_SizingFactor_ (this),
          SimFlowPlant_ChilledWaterInletNodeName_ (this),
          SimFlowPlant_ChilledWaterOutletNodeName_ (this),
          SimFlowPlant_CondInletNodeName_ (this),
          SimFlowPlant_CondOutletNodeName_ (this),
          SimFlowPlant_ChillerFlowMode_ (this),
          SimFlowPlant_DesignCondInletTemp_ (this),
          SimFlowPlant_DesignChilledWaterFlowRate_ (this),
          SimFlowPlant_ChilledWaterOutletTempLowLimit_ (this),
          SimFlowPlant_DesignCondWaterFlowRate_ (this),
          SimFlowPlant_NomPumpingPwr_ (this),
          SimFlowPlant_CondInletTempLowLimit_ (this),
          SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_GenInletNodeName_ (this),
          SimFlowPlant_GenOutletNodeName_ (this),
          SimFlowPlant_CapCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncGenTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_GenHeatSrcType_ (this),
          SimFlowPlant_DesignGenFluidFlowRate_ (this),
          SimFlowPlant_TempLowLimitGenInlet_ (this),
          SimFlowPlant_DegreeSubcoolingSteamGen_ (this),
          SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ (this)
        {
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Chiller_AbsorptionIndirect (const RefId_type& RefId)
        : ::schema::simxml::MepModel::SimFlowPlant_Chiller (RefId),
          SimFlowPlant_Name_ (this),
          SimFlowPlant_NomCap_ (this),
          SimFlowPlant_MinPartLoadRatio_ (this),
          SimFlowPlant_MaxPartLoadRatio_ (this),
          SimFlowPlant_OptimumPartLoadRatio_ (this),
          SimFlowPlant_SizingFactor_ (this),
          SimFlowPlant_ChilledWaterInletNodeName_ (this),
          SimFlowPlant_ChilledWaterOutletNodeName_ (this),
          SimFlowPlant_CondInletNodeName_ (this),
          SimFlowPlant_CondOutletNodeName_ (this),
          SimFlowPlant_ChillerFlowMode_ (this),
          SimFlowPlant_DesignCondInletTemp_ (this),
          SimFlowPlant_DesignChilledWaterFlowRate_ (this),
          SimFlowPlant_ChilledWaterOutletTempLowLimit_ (this),
          SimFlowPlant_DesignCondWaterFlowRate_ (this),
          SimFlowPlant_NomPumpingPwr_ (this),
          SimFlowPlant_CondInletTempLowLimit_ (this),
          SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_GenInletNodeName_ (this),
          SimFlowPlant_GenOutletNodeName_ (this),
          SimFlowPlant_CapCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncGenTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_GenHeatSrcType_ (this),
          SimFlowPlant_DesignGenFluidFlowRate_ (this),
          SimFlowPlant_TempLowLimitGenInlet_ (this),
          SimFlowPlant_DegreeSubcoolingSteamGen_ (this),
          SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ (this)
        {
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Chiller_AbsorptionIndirect (const SimFlowPlant_Chiller_AbsorptionIndirect& x,
                                                 ::xml_schema::flags f,
                                                 ::xml_schema::container* c)
        : ::schema::simxml::MepModel::SimFlowPlant_Chiller (x, f, c),
          SimFlowPlant_Name_ (x.SimFlowPlant_Name_, f, this),
          SimFlowPlant_NomCap_ (x.SimFlowPlant_NomCap_, f, this),
          SimFlowPlant_MinPartLoadRatio_ (x.SimFlowPlant_MinPartLoadRatio_, f, this),
          SimFlowPlant_MaxPartLoadRatio_ (x.SimFlowPlant_MaxPartLoadRatio_, f, this),
          SimFlowPlant_OptimumPartLoadRatio_ (x.SimFlowPlant_OptimumPartLoadRatio_, f, this),
          SimFlowPlant_SizingFactor_ (x.SimFlowPlant_SizingFactor_, f, this),
          SimFlowPlant_ChilledWaterInletNodeName_ (x.SimFlowPlant_ChilledWaterInletNodeName_, f, this),
          SimFlowPlant_ChilledWaterOutletNodeName_ (x.SimFlowPlant_ChilledWaterOutletNodeName_, f, this),
          SimFlowPlant_CondInletNodeName_ (x.SimFlowPlant_CondInletNodeName_, f, this),
          SimFlowPlant_CondOutletNodeName_ (x.SimFlowPlant_CondOutletNodeName_, f, this),
          SimFlowPlant_ChillerFlowMode_ (x.SimFlowPlant_ChillerFlowMode_, f, this),
          SimFlowPlant_DesignCondInletTemp_ (x.SimFlowPlant_DesignCondInletTemp_, f, this),
          SimFlowPlant_DesignChilledWaterFlowRate_ (x.SimFlowPlant_DesignChilledWaterFlowRate_, f, this),
          SimFlowPlant_ChilledWaterOutletTempLowLimit_ (x.SimFlowPlant_ChilledWaterOutletTempLowLimit_, f, this),
          SimFlowPlant_DesignCondWaterFlowRate_ (x.SimFlowPlant_DesignCondWaterFlowRate_, f, this),
          SimFlowPlant_NomPumpingPwr_ (x.SimFlowPlant_NomPumpingPwr_, f, this),
          SimFlowPlant_CondInletTempLowLimit_ (x.SimFlowPlant_CondInletTempLowLimit_, f, this),
          SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ (x.SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_, f, this),
          SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ (x.SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_, f, this),
          SimFlowPlant_GenInletNodeName_ (x.SimFlowPlant_GenInletNodeName_, f, this),
          SimFlowPlant_GenOutletNodeName_ (x.SimFlowPlant_GenOutletNodeName_, f, this),
          SimFlowPlant_CapCorrectFuncCondTempCurveName_ (x.SimFlowPlant_CapCorrectFuncCondTempCurveName_, f, this),
          SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ (x.SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_, f, this),
          SimFlowPlant_CapCorrectFuncGenTempCurveName_ (x.SimFlowPlant_CapCorrectFuncGenTempCurveName_, f, this),
          SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ (x.SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_, f, this),
          SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ (x.SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_, f, this),
          SimFlowPlant_GenHeatSrcType_ (x.SimFlowPlant_GenHeatSrcType_, f, this),
          SimFlowPlant_DesignGenFluidFlowRate_ (x.SimFlowPlant_DesignGenFluidFlowRate_, f, this),
          SimFlowPlant_TempLowLimitGenInlet_ (x.SimFlowPlant_TempLowLimitGenInlet_, f, this),
          SimFlowPlant_DegreeSubcoolingSteamGen_ (x.SimFlowPlant_DegreeSubcoolingSteamGen_, f, this),
          SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ (x.SimFlowPlant_DegreeSubcoolingSteamCondsLoop_, f, this)
        {
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::
        SimFlowPlant_Chiller_AbsorptionIndirect (const ::xercesc::DOMElement& e,
                                                 ::xml_schema::flags f,
                                                 ::xml_schema::container* c)
        : ::schema::simxml::MepModel::SimFlowPlant_Chiller (e, f | ::xml_schema::flags::base, c),
          SimFlowPlant_Name_ (this),
          SimFlowPlant_NomCap_ (this),
          SimFlowPlant_MinPartLoadRatio_ (this),
          SimFlowPlant_MaxPartLoadRatio_ (this),
          SimFlowPlant_OptimumPartLoadRatio_ (this),
          SimFlowPlant_SizingFactor_ (this),
          SimFlowPlant_ChilledWaterInletNodeName_ (this),
          SimFlowPlant_ChilledWaterOutletNodeName_ (this),
          SimFlowPlant_CondInletNodeName_ (this),
          SimFlowPlant_CondOutletNodeName_ (this),
          SimFlowPlant_ChillerFlowMode_ (this),
          SimFlowPlant_DesignCondInletTemp_ (this),
          SimFlowPlant_DesignChilledWaterFlowRate_ (this),
          SimFlowPlant_ChilledWaterOutletTempLowLimit_ (this),
          SimFlowPlant_DesignCondWaterFlowRate_ (this),
          SimFlowPlant_NomPumpingPwr_ (this),
          SimFlowPlant_CondInletTempLowLimit_ (this),
          SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ (this),
          SimFlowPlant_GenInletNodeName_ (this),
          SimFlowPlant_GenOutletNodeName_ (this),
          SimFlowPlant_CapCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_CapCorrectFuncGenTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ (this),
          SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ (this),
          SimFlowPlant_GenHeatSrcType_ (this),
          SimFlowPlant_DesignGenFluidFlowRate_ (this),
          SimFlowPlant_TempLowLimitGenInlet_ (this),
          SimFlowPlant_DegreeSubcoolingSteamGen_ (this),
          SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ (this)
        {
          if ((f & ::xml_schema::flags::base) == 0)
          {
            ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
            this->parse (p, f);
          }
        }
  
        void SimFlowPlant_Chiller_AbsorptionIndirect::
        parse (::xsd::cxx::xml::dom::parser< char >& p,
               ::xml_schema::flags f)
        {
          this->::schema::simxml::MepModel::SimFlowPlant_Chiller::parse (p, f);
  
          for (; p.more_content (); p.next_content (false))
          {
            const ::xercesc::DOMElement& i (p.cur_element ());
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (i));
  
            // SimFlowPlant_Name
            //
            if (n.name () == "SimFlowPlant_Name" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_Name_type > r (
                SimFlowPlant_Name_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_Name_)
              {
                this->SimFlowPlant_Name_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_NomCap
            //
            if (n.name () == "SimFlowPlant_NomCap" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_NomCap_)
              {
                this->SimFlowPlant_NomCap_.set (SimFlowPlant_NomCap_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_MinPartLoadRatio
            //
            if (n.name () == "SimFlowPlant_MinPartLoadRatio" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_MinPartLoadRatio_)
              {
                this->SimFlowPlant_MinPartLoadRatio_.set (SimFlowPlant_MinPartLoadRatio_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_MaxPartLoadRatio
            //
            if (n.name () == "SimFlowPlant_MaxPartLoadRatio" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_MaxPartLoadRatio_)
              {
                this->SimFlowPlant_MaxPartLoadRatio_.set (SimFlowPlant_MaxPartLoadRatio_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_OptimumPartLoadRatio
            //
            if (n.name () == "SimFlowPlant_OptimumPartLoadRatio" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_OptimumPartLoadRatio_)
              {
                this->SimFlowPlant_OptimumPartLoadRatio_.set (SimFlowPlant_OptimumPartLoadRatio_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_SizingFactor
            //
            if (n.name () == "SimFlowPlant_SizingFactor" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_SizingFactor_)
              {
                this->SimFlowPlant_SizingFactor_.set (SimFlowPlant_SizingFactor_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_ChilledWaterInletNodeName
            //
            if (n.name () == "SimFlowPlant_ChilledWaterInletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_ChilledWaterInletNodeName_type > r (
                SimFlowPlant_ChilledWaterInletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_ChilledWaterInletNodeName_)
              {
                this->SimFlowPlant_ChilledWaterInletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_ChilledWaterOutletNodeName
            //
            if (n.name () == "SimFlowPlant_ChilledWaterOutletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_ChilledWaterOutletNodeName_type > r (
                SimFlowPlant_ChilledWaterOutletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_ChilledWaterOutletNodeName_)
              {
                this->SimFlowPlant_ChilledWaterOutletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_CondInletNodeName
            //
            if (n.name () == "SimFlowPlant_CondInletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_CondInletNodeName_type > r (
                SimFlowPlant_CondInletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_CondInletNodeName_)
              {
                this->SimFlowPlant_CondInletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_CondOutletNodeName
            //
            if (n.name () == "SimFlowPlant_CondOutletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_CondOutletNodeName_type > r (
                SimFlowPlant_CondOutletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_CondOutletNodeName_)
              {
                this->SimFlowPlant_CondOutletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_ChillerFlowMode
            //
            if (n.name () == "SimFlowPlant_ChillerFlowMode" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_ChillerFlowMode_type > r (
                SimFlowPlant_ChillerFlowMode_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_ChillerFlowMode_)
              {
                this->SimFlowPlant_ChillerFlowMode_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_DesignCondInletTemp
            //
            if (n.name () == "SimFlowPlant_DesignCondInletTemp" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DesignCondInletTemp_)
              {
                this->SimFlowPlant_DesignCondInletTemp_.set (SimFlowPlant_DesignCondInletTemp_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_DesignChilledWaterFlowRate
            //
            if (n.name () == "SimFlowPlant_DesignChilledWaterFlowRate" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DesignChilledWaterFlowRate_)
              {
                this->SimFlowPlant_DesignChilledWaterFlowRate_.set (SimFlowPlant_DesignChilledWaterFlowRate_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_ChilledWaterOutletTempLowLimit
            //
            if (n.name () == "SimFlowPlant_ChilledWaterOutletTempLowLimit" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_ChilledWaterOutletTempLowLimit_)
              {
                this->SimFlowPlant_ChilledWaterOutletTempLowLimit_.set (SimFlowPlant_ChilledWaterOutletTempLowLimit_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_DesignCondWaterFlowRate
            //
            if (n.name () == "SimFlowPlant_DesignCondWaterFlowRate" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DesignCondWaterFlowRate_)
              {
                this->SimFlowPlant_DesignCondWaterFlowRate_.set (SimFlowPlant_DesignCondWaterFlowRate_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_NomPumpingPwr
            //
            if (n.name () == "SimFlowPlant_NomPumpingPwr" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_NomPumpingPwr_)
              {
                this->SimFlowPlant_NomPumpingPwr_.set (SimFlowPlant_NomPumpingPwr_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_CondInletTempLowLimit
            //
            if (n.name () == "SimFlowPlant_CondInletTempLowLimit" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_CondInletTempLowLimit_)
              {
                this->SimFlowPlant_CondInletTempLowLimit_.set (SimFlowPlant_CondInletTempLowLimit_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName
            //
            if (n.name () == "SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_type > r (
                SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_)
              {
                this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName
            //
            if (n.name () == "SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_type > r (
                SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_)
              {
                this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_GenInletNodeName
            //
            if (n.name () == "SimFlowPlant_GenInletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenInletNodeName_type > r (
                SimFlowPlant_GenInletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenInletNodeName_)
              {
                this->SimFlowPlant_GenInletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_GenOutletNodeName
            //
            if (n.name () == "SimFlowPlant_GenOutletNodeName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenOutletNodeName_type > r (
                SimFlowPlant_GenOutletNodeName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenOutletNodeName_)
              {
                this->SimFlowPlant_GenOutletNodeName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_CapCorrectFuncCondTempCurveName
            //
            if (n.name () == "SimFlowPlant_CapCorrectFuncCondTempCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_CapCorrectFuncCondTempCurveName_type > r (
                SimFlowPlant_CapCorrectFuncCondTempCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_CapCorrectFuncCondTempCurveName_)
              {
                this->SimFlowPlant_CapCorrectFuncCondTempCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName
            //
            if (n.name () == "SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_type > r (
                SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_)
              {
                this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_CapCorrectFuncGenTempCurveName
            //
            if (n.name () == "SimFlowPlant_CapCorrectFuncGenTempCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_CapCorrectFuncGenTempCurveName_type > r (
                SimFlowPlant_CapCorrectFuncGenTempCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_CapCorrectFuncGenTempCurveName_)
              {
                this->SimFlowPlant_CapCorrectFuncGenTempCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName
            //
            if (n.name () == "SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_type > r (
                SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_)
              {
                this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName
            //
            if (n.name () == "SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_type > r (
                SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_)
              {
                this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_GenHeatSrcType
            //
            if (n.name () == "SimFlowPlant_GenHeatSrcType" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              ::std::auto_ptr< SimFlowPlant_GenHeatSrcType_type > r (
                SimFlowPlant_GenHeatSrcType_traits::create (i, f, this));
  
              if (!this->SimFlowPlant_GenHeatSrcType_)
              {
                this->SimFlowPlant_GenHeatSrcType_.set (r);
                continue;
              }
            }
  
            // SimFlowPlant_DesignGenFluidFlowRate
            //
            if (n.name () == "SimFlowPlant_DesignGenFluidFlowRate" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DesignGenFluidFlowRate_)
              {
                this->SimFlowPlant_DesignGenFluidFlowRate_.set (SimFlowPlant_DesignGenFluidFlowRate_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_TempLowLimitGenInlet
            //
            if (n.name () == "SimFlowPlant_TempLowLimitGenInlet" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_TempLowLimitGenInlet_)
              {
                this->SimFlowPlant_TempLowLimitGenInlet_.set (SimFlowPlant_TempLowLimitGenInlet_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_DegreeSubcoolingSteamGen
            //
            if (n.name () == "SimFlowPlant_DegreeSubcoolingSteamGen" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DegreeSubcoolingSteamGen_)
              {
                this->SimFlowPlant_DegreeSubcoolingSteamGen_.set (SimFlowPlant_DegreeSubcoolingSteamGen_traits::create (i, f, this));
                continue;
              }
            }
  
            // SimFlowPlant_DegreeSubcoolingSteamCondsLoop
            //
            if (n.name () == "SimFlowPlant_DegreeSubcoolingSteamCondsLoop" && n.namespace_ () == "http://d-alchemy.com/schema/simxml/MepModel")
            {
              if (!this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_)
              {
                this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_.set (SimFlowPlant_DegreeSubcoolingSteamCondsLoop_traits::create (i, f, this));
                continue;
              }
            }
  
            break;
          }
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect* SimFlowPlant_Chiller_AbsorptionIndirect::
        _clone (::xml_schema::flags f,
                ::xml_schema::container* c) const
        {
          return new class SimFlowPlant_Chiller_AbsorptionIndirect (*this, f, c);
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect& SimFlowPlant_Chiller_AbsorptionIndirect::
        operator= (const SimFlowPlant_Chiller_AbsorptionIndirect& x)
        {
          if (this != &x)
          {
            static_cast< ::schema::simxml::MepModel::SimFlowPlant_Chiller& > (*this) = x;
            this->SimFlowPlant_Name_ = x.SimFlowPlant_Name_;
            this->SimFlowPlant_NomCap_ = x.SimFlowPlant_NomCap_;
            this->SimFlowPlant_MinPartLoadRatio_ = x.SimFlowPlant_MinPartLoadRatio_;
            this->SimFlowPlant_MaxPartLoadRatio_ = x.SimFlowPlant_MaxPartLoadRatio_;
            this->SimFlowPlant_OptimumPartLoadRatio_ = x.SimFlowPlant_OptimumPartLoadRatio_;
            this->SimFlowPlant_SizingFactor_ = x.SimFlowPlant_SizingFactor_;
            this->SimFlowPlant_ChilledWaterInletNodeName_ = x.SimFlowPlant_ChilledWaterInletNodeName_;
            this->SimFlowPlant_ChilledWaterOutletNodeName_ = x.SimFlowPlant_ChilledWaterOutletNodeName_;
            this->SimFlowPlant_CondInletNodeName_ = x.SimFlowPlant_CondInletNodeName_;
            this->SimFlowPlant_CondOutletNodeName_ = x.SimFlowPlant_CondOutletNodeName_;
            this->SimFlowPlant_ChillerFlowMode_ = x.SimFlowPlant_ChillerFlowMode_;
            this->SimFlowPlant_DesignCondInletTemp_ = x.SimFlowPlant_DesignCondInletTemp_;
            this->SimFlowPlant_DesignChilledWaterFlowRate_ = x.SimFlowPlant_DesignChilledWaterFlowRate_;
            this->SimFlowPlant_ChilledWaterOutletTempLowLimit_ = x.SimFlowPlant_ChilledWaterOutletTempLowLimit_;
            this->SimFlowPlant_DesignCondWaterFlowRate_ = x.SimFlowPlant_DesignCondWaterFlowRate_;
            this->SimFlowPlant_NomPumpingPwr_ = x.SimFlowPlant_NomPumpingPwr_;
            this->SimFlowPlant_CondInletTempLowLimit_ = x.SimFlowPlant_CondInletTempLowLimit_;
            this->SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_ = x.SimFlowPlant_GenHeatInputFuncPartLoadRatioCurveName_;
            this->SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_ = x.SimFlowPlant_PumpElecInputFuncPartLoadRatioCurveName_;
            this->SimFlowPlant_GenInletNodeName_ = x.SimFlowPlant_GenInletNodeName_;
            this->SimFlowPlant_GenOutletNodeName_ = x.SimFlowPlant_GenOutletNodeName_;
            this->SimFlowPlant_CapCorrectFuncCondTempCurveName_ = x.SimFlowPlant_CapCorrectFuncCondTempCurveName_;
            this->SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_ = x.SimFlowPlant_CapCorrectFuncChilledWaterTempCurveName_;
            this->SimFlowPlant_CapCorrectFuncGenTempCurveName_ = x.SimFlowPlant_CapCorrectFuncGenTempCurveName_;
            this->SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_ = x.SimFlowPlant_GenHeatInputCorrectFuncCondTempCurveName_;
            this->SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_ = x.SimFlowPlant_GenHeatInputCorrectFuncChilledWaterTempCurveName_;
            this->SimFlowPlant_GenHeatSrcType_ = x.SimFlowPlant_GenHeatSrcType_;
            this->SimFlowPlant_DesignGenFluidFlowRate_ = x.SimFlowPlant_DesignGenFluidFlowRate_;
            this->SimFlowPlant_TempLowLimitGenInlet_ = x.SimFlowPlant_TempLowLimitGenInlet_;
            this->SimFlowPlant_DegreeSubcoolingSteamGen_ = x.SimFlowPlant_DegreeSubcoolingSteamGen_;
            this->SimFlowPlant_DegreeSubcoolingSteamCondsLoop_ = x.SimFlowPlant_DegreeSubcoolingSteamCondsLoop_;
          }
  
          return *this;
        }
  
        SimFlowPlant_Chiller_AbsorptionIndirect::
        ~SimFlowPlant_Chiller_AbsorptionIndirect ()
        {
        }
      }
    }
  }
  
  #include <istream>
  #include <xsd/cxx/xml/sax/std-input-source.hxx>
  #include <xsd/cxx/tree/error-handler.hxx>
  
  namespace schema
  {
    namespace simxml
    {
      namespace MepModel
      {
      }
    }
  }
  
  #include <xsd/cxx/post.hxx>
  
  // Begin epilogue.
  //
  //
  // End epilogue.
  
  