McAnalyzerFactory.cpp

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include "McAnalyzerFactory.h" // Class header

#include "McEnergyOutput.h"
#include "McEnergyAnalyzer.h"
#include "McEnergyAverage.h"
#include "McPressureAverage.h"
#include "McVirialStressTensorAverage.h"

#ifndef SIMP_NOPAIR
#include "McPairEnergyAverage.h"
#include "McMuExchange.h"
#endif

#ifdef SIMP_BOND
#include "McIntraBondStressAutoCorr.h"
#include "McBondEnergyAverage.h"
#include "McIntraBondTensorAutoCorr.h"
#ifndef SIMP_NOPAIR
#include "McNVTChemicalPotential.h"
#endif
#endif

#ifdef SIMP_EXTERNAL
#include "McExternalEnergyAverage.h"
#endif

#include <mcMd/analyzers/mutable/TypeDistribution.h>
#include <mcMd/analyzers/mutable/SemiGrandDistribution.h>

#include <mcMd/mcSimulation/McSimulation.h>
#include <mcMd/mcSimulation/McSystem.h>

namespace McMd
{

   using namespace Util;

   /*
   * Constructor.
   */
   McAnalyzerFactory::McAnalyzerFactory(McSimulation& simulation, 
                                            McSystem& system)
    : systemFactory_(simulation, system),
      simulationPtr_(&simulation),
      systemPtr_(&system)
   {}

   /* 
   * Return a pointer to a instance of Analyzer subclass className.
   */
   Analyzer* McAnalyzerFactory::factory(const std::string &className) const
   {
      Analyzer* ptr = 0;

      // Try subfactories first (if any) 
      ptr = trySubfactories(className);
      if (ptr) return ptr;

      if (className == "McEnergyOutput") {
         ptr = new McEnergyOutput(system());
      } else
      if (className == "McEnergyAnalyzer") {
         ptr = new McEnergyAnalyzer(system());
      } else
      if (className == "McEnergyAverage") {
         ptr = new McEnergyAverage(system());
      } else
      if (className == "McPressureAverage") {
         ptr = new McPressureAverage(system());
      } else
      if (className == "McVirialStressTensorAverage") {
         ptr = new McVirialStressTensorAverage(system());
      } 

      #ifndef SIMP_NOPAIR
      else
      if (className == "McPairEnergyAverage") {
         ptr = new McPairEnergyAverage(system());
      } else
      if (className == "McMuExchange") {
         ptr = new McMuExchange(system());
      } 
      #endif

      #ifdef SIMP_BOND
      else 
      if (className == "McBondEnergyAverage") {
         ptr = new McBondEnergyAverage(system());
      } else
      if (className == "McIntraBondStressAutoCorr") {
         ptr = new McIntraBondStressAutoCorr(system());
      } else
      if (className == "McIntraBondTensorAutoCorr") {
         ptr = new McIntraBondTensorAutoCorr(system());
      } 
      #ifndef SIMP_NOPAIR
      else
      if (className == "McNVTChemicalPotential") {
         ptr = new McNVTChemicalPotential(system());
      }
      #endif 
      #endif 

      #ifdef SIMP_EXTERNAL
      else
      if (className == "McExternalEnergyAverage") {
         ptr = new McExternalEnergyAverage(system());
      } 
      #endif

      // Semi-grand ensemble
      else
      if (className == "TypeDistribution") {
         ptr = new TypeDistribution(system());
      } else 
      if (className == "SemiGrandDistribution") {
         ptr = new SemiGrandDistribution(system());
      }
 
      // If none of the above are matched, try SystemAnalyzerFactory
      if (!ptr) {
         ptr = systemFactory_.factory(className);
      }

      return ptr;
   }

}