source: src/Parser/MpqcParser_Parameters.hpp@ 61d69a4

/*
 * MpqcParser_Parameters.hpp
 *
 *  Created on: Feb 3, 2011
 *      Author: heber
 */

#ifndef MPQCPARSER_PARAMETERS_HPP_
#define MPQCPARSER_PARAMETERS_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iosfwd>
#include <list>
#include <typeinfo>
#include <vector>

#include "CodePatterns/Log.hpp"
#include "CodePatterns/Verbose.hpp"

#include <boost/any.hpp>


class MpqcParser;

class MpqcParser_Parameters
{
  friend class MpqcParser;
  friend class ParserMpqcUnitTest;
  friend std::ostream & operator << (std::ostream& ost, const MpqcParser_Parameters &params);
  friend std::istream & operator >> (std::istream& ist, MpqcParser_Parameters &params);
public:
  MpqcParser_Parameters();
  ~MpqcParser_Parameters();

  enum Theory { CLHF, CLKS, MBPT2, MBPT2_R12, unknownTheory };
  enum IntegrationMethod { IntegralCints, unknownIntegration };

  enum Parameters {
    HessianParam,
    savestateParam,
    do_gradientParam,
    maxiterParam,
    memoryParam,
    stdapproxParam,
    nfzcParam,
    basisParam,
    aux_basisParam,
    integrationParam,
    theoryParam,
    unknownParam};

  bool checkWorldElementsAgainstCurrentBasis() const;
  void setHessian(bool _hessian);
  void setTheory(enum Theory _theory);
  enum IntegrationMethod getIntegration();
  enum Theory getTheory();

  std::string getString(enum Parameters _param);
  int getInt(enum Parameters _param);
  double getDouble(enum Parameters _param);
  bool getBool(enum Parameters _param);

  template <class T> bool setter(enum Parameters _param, T _desired) {
    if (typeid(T) == params[_param].type()) {
      params[_param] = _desired;
      return true;
    } else
      return false;
  }


private:
  void initBasis();
  void initParameters();

  template <class T> void appendParameter(enum Parameters _enum, T _p) {
    boost::any _p_value = _p;
    params[_enum] = _p_value;
  }

  // contains basis and all elements the basis knows about
  typedef std::map<std::string, std::list<std::string> > BasisMapType;
  typedef std::map<enum Theory, std::string> TheoryNamesType;
  typedef std::map<enum IntegrationMethod, std::string> IntegrationNamesType;
  typedef std::map<enum Parameters, std::string> ParamNamesType;

  typedef std::map<enum Parameters, boost::any> parameterlist;

  // is mutable for boost::any_cast not caring about const.
  parameterlist params;

  BasisMapType BasisList;
  TheoryNamesType TheoryNames;
  IntegrationNamesType IntegrationNames;
  ParamNamesType ParamNames;
};

std::ostream & operator << (std::ostream& ost, const MpqcParser_Parameters &params);
std::istream & operator >> (std::istream& ist, MpqcParser_Parameters &params);

#endif /* MPQCPARSER_PARAMETERS_HPP_ */