source: src/Parser/Psi3Parser_Parameters.cpp@ 1bef07

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010 University of Bonn. All rights reserved.
 * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
 */

/*
 * Psi3Parser_Parameters.cpp
 *
 *  Created on: Feb 3, 2011
 *      Author: heber
 */

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

#include <iostream>
#include <boost/tokenizer.hpp>
#include <string>

#include "CodePatterns/MemDebug.hpp"

#include "CodePatterns/Log.hpp"

#include "Psi3Parser.hpp"

#include "Psi3Parser_Parameters.hpp"

#include "Parser/Parameters/ContinuousParameter.hpp"
#include "Parser/Parameters/DiscreteParameter.hpp"
#include "Parser/Parameters/StringParameter.hpp"

// TODO: ContinuousValue<bool>::get() must be defined inline otherwise we get multiple definition of virtual thunk compilation errors
template <>
inline const std::string ContinuousValue<bool>::get() const
{
  ASSERT(ValueSet,
      "ContinuousValue<bool>::get() - requesting unset value.");
  if (value)
    return std::string("yes");
  else
    return std::string("no");
}

// TODO: ContinuousValue<bool>::set must be defined inline otherwise we get multiple definition of virtual thunk compilation errors
template <>
inline void ContinuousValue<bool>::set(const std::string _value)
{
  if (_value == std::string("yes")) {
    setValue(true);
  } else if (_value == std::string("no")) {
    setValue(false);
  } else {
    ASSERT(0,
        "void ContinuousValue<bool>::set() - value "+_value+" is neither yes or no.");
  }
}


Psi3Parser_Parameters::Psi3Parser_Parameters()
{
  Init();
}

void Psi3Parser_Parameters::Init()
{
  // add all known basis
  //initBasis();

  // add all parameter names
  {
    ParamNames.clear();
    ParamNames.resize(unknownParam);
    ParamNames[labelParam] = "label";
    ParamNames[jobtypeParam] = "jobtype";
    ParamNames[wavefunctionParam] = "wfn";
    ParamNames[maxiterParam] = "maxiter";
    ParamNames[referenceParam] = "reference";
    ParamNames[basisParam] = "basis";
    ParamNames[freeze_coreParam] = "freeze_core";
    ParamNames[unitsParam] = "units";
    ParamNames[dertypeParam] = "dertype";
    ParamNames[originParam] = "origin";
    ParamNames[multipParam] = "multip";
    ParamNames[chargeParam] = "charge";
    ParamNames[soccParam] = "socc";
    ParamNames[doccParam] = "docc";
    ParamNames[subgroupParam] = "subgroup";
    ParamNames[unique_axisParam] = "unique_axis";
  }

  // create freeze_core parameter
  {
    ValidFreezeCore.clear();
    ValidFreezeCore.resize(unknownFreezeCore);
    ValidFreezeCore[YES]="yes";
    ValidFreezeCore[TRUE]="true";
    ValidFreezeCore[NO]="no";
    ValidFreezeCore[FALSE]="false";
    ValidFreezeCore[SMALL]="small";
    ValidFreezeCore[LARGE]="large";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[freeze_coreParam],
            ValidFreezeCore,
            ValidFreezeCore[YES]));
  }

  // create units parameter
  {
    ValidUnits.clear();
    ValidUnits.resize(unknownUnits);
    ValidUnits[angstrom]="angstrom";
    ValidUnits[bohr]="bohr";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[unitsParam],
            ValidUnits,
            ValidUnits[angstrom]));
  }

  // create dertype parameter
  {
    ValidDerivativeType.clear();
    ValidDerivativeType.resize(unknownDerivativeType);
    ValidDerivativeType[NONE]="none";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[dertypeParam],
            ValidDerivativeType,
            ValidDerivativeType[NONE]));
  }

  // create unique_axis parameter
  {
    ValidUniqueAxis.clear();
    ValidUniqueAxis.resize(unknownUniqueAxis);
    ValidUniqueAxis[X]="x";
    ValidUniqueAxis[Y]="y";
    ValidUniqueAxis[Z]="z";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[unique_axisParam],
            ValidUniqueAxis,
            ValidUniqueAxis[X]));
  }

  // create jobtype parameter
  {
    ValidJobtypes.clear();
    ValidJobtypes.resize(unknownJobtype);
    ValidJobtypes[SP]="sp";
    ValidJobtypes[OPT]="opt";
    ValidJobtypes[DISP]="disp";
    ValidJobtypes[FREQ]="freq";
    ValidJobtypes[SYMM_FREQ]="symm_freq";
    ValidJobtypes[DBOC]="dboc";
    ValidJobtypes[RESPONSE]="response";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[jobtypeParam],
            ValidJobtypes,
            ValidJobtypes[SP]));
  }

  // create wavefunction parameter
  {
    ValidWavefunction.clear();
    ValidWavefunction.resize(unknownWavefunction);
    ValidWavefunction[SCF]="scf";
    ValidWavefunction[MP2]="mp2";
    ValidWavefunction[MP2R12]="mp2r12";
    ValidWavefunction[CIS]="cis";
    ValidWavefunction[DETCI]="detci";
    ValidWavefunction[CASSCF]="casscf";
    ValidWavefunction[RASSCF]="rasscf";
    ValidWavefunction[CCSD]="ccsd";
    ValidWavefunction[CCSD_T]="ccsd_t";
    ValidWavefunction[BCCD]="bccd";
    ValidWavefunction[BCCD_T]="bccd_t";
    ValidWavefunction[EOM_CCSD]="eom_ccsd";
    ValidWavefunction[ZAPTN]="zaptn";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[wavefunctionParam],
            ValidWavefunction,
            ValidWavefunction[SCF]));
  }

  // create reference parameter
  {
    ValidReference.clear();
    ValidReference.resize(unknownReference);
    ValidReference[RHF]="rhf";
    ValidReference[ROHF]="rohf";
    ValidReference[UHF]="uhf";
    ValidReference[TWOCON]="twocon";
    appendParameter(
        new DiscreteParameter<std::string>(
            ParamNames[referenceParam],
            ValidReference,
            ValidReference[RHF]));
  }

  // add all continuous parameters
  {
    appendParameter(new StringParameter(ParamNames[labelParam], std::string("unknown job")));
    appendParameter(new ContinuousParameter<int>(ParamNames[maxiterParam], 80));
    appendParameter(new StringParameter(ParamNames[basisParam], std::string("cc-pVTZ")));
    appendParameter(new StringParameter(ParamNames[originParam], std::string("(0.0\t0.0\t0.0)"))); // TODO: this should be a vector
    appendParameter(new ContinuousParameter<int>(ParamNames[multipParam], 1));
    appendParameter(new ContinuousParameter<int>(ParamNames[chargeParam], 0));
    appendParameter(new StringParameter(ParamNames[soccParam], std::string("()")));
    appendParameter(new StringParameter(ParamNames[doccParam], std::string("()")));
    appendParameter(new StringParameter(ParamNames[subgroupParam], std::string("")));
 }
}

Psi3Parser_Parameters::~Psi3Parser_Parameters()
{}

/** Getter for a specific Parameter.
 *
 * @param param index among enum Parameters
 * @return value of the desired Parameters
 */
const std::string Psi3Parser_Parameters::getParameter(const enum Parameters param) const
{
  return FormatParser_Parameters::getParameter(ParamNames[param])->get();
}

/** Setter for a specific Parameter.
 *
 * @param param index among enum Parameters
 * @param _value value to set desired Parameter to
 */
void Psi3Parser_Parameters::setParameter(const enum Parameters param, const std::string &_value)
{
  const std::string &name = getParameterName(param);
  FormatParser_Parameters::getParameter(name)->set(_value);
}

/** Getter for name of a specific Parameter.
 *
 * @param param index among enum Parameters
 * @return name of the desired Parameter
 */
const std::string &Psi3Parser_Parameters::getParameterName(const enum Parameters param) const
{
  return ParamNames[param];
}

///** Getter for name of a specific Parameter.
// *
// * @param param index among enum Theory
// * @return name of the desired Theory
// */
//const std::string &Psi3Parser_Parameters::getTheoryName(const enum Theory theory) const
//{
//  return ValidTheories[theory];
//}
//
///** Getter for the name of specific of IntegrationMethod.
// *
// * @param param index among enum IntegrationMethod
// * @return value of the desired IntegrationMethod
// */
//const std::string &Psi3Parser_Parameters::getIntegrationMethodName(const enum IntegrationMethod integration) const
//{
//  return ValidIntegrationMethods[integration];
//}


/** Output operator for the contents of Psi3Parser_Parameters::params.
 *
 * @param ost output stream
 * @param params reference to Psi3Parser_Parameters containing params.
 * @return reference to output stream for concatenation
 */
std::ostream & operator << (std::ostream& ost, const Psi3Parser_Parameters &params)
{
  // this is ugly, but with boost::any to safeguard const-ness is plain impossible
  std::ostringstream output;
  for (size_t param = (enum Psi3Parser_Parameters::Parameters)0;
      param < (size_t)Psi3Parser_Parameters::unknownParam; ++param)
    output << params.getParameterName((enum Psi3Parser_Parameters::Parameters)param)
           <<  "=" << params.getParameter((enum Psi3Parser_Parameters::Parameters)param) << ";";
  ost << output.str();
  return ost;
}

/** Input operator for a list of parameters to place into \a params.
 *
 * @param ist input stream
 * @param params parameters to parse into
 * @return input stream for concatenation
 */
std::istream & operator >> (std::istream& ist, Psi3Parser_Parameters &params)
{
  typedef boost::tokenizer<boost::char_separator<char> >
      tokenizer;
  boost::char_separator<char> semicolonsep(";");
  boost::char_separator<char> equalitysep(" =");
  boost::char_separator<char> ticksep("\"");
  std::string line;
  std::getline( ist, line );
  //DoLog(0) && (Log() << Verbose(0) << "INFO: full line of parameters is '" << line << "'" << std::endl);
  tokenizer tokens(line, semicolonsep);
  ASSERT(tokens.begin() != tokens.end(),
      "operator<< on Psi3Parser_Parameters - empty string, need at least ';' in line "+line+"!");
  for (tokenizer::iterator tok_iter = tokens.begin();
        tok_iter != tokens.end(); ++tok_iter) {
    tokenizer paramtokens(*tok_iter, equalitysep);
    if (paramtokens.begin() != paramtokens.end()) {
      tokenizer::iterator tok_paramiter = paramtokens.begin();
      tokenizer::iterator tok_valueiter = tok_paramiter;
      tokenizer::iterator tok_checkiter = ++tok_valueiter;
      ++tok_checkiter;
      // TODO: throw exception instead of ASSERT
      ASSERT(tok_paramiter != paramtokens.end(),
          "operator<< on Psi3Parser_Parameters - missing value before ' =' in token "+*tok_iter+"!");
      ASSERT(tok_valueiter != paramtokens.end(),
          "operator<< on Psi3Parser_Parameters - missing value after ' =' in token "+*tok_iter+"!");
      ASSERT(tok_checkiter == paramtokens.end(),
          "operator<< on Psi3Parser_Parameters - still more tokens after ' =' in token "+*tok_iter+":"
          +*tok_checkiter+"!");
      std::stringstream keystream(*tok_paramiter);
      std::string key;
      keystream >> ws >> key;
      tokenizer ticklesstokens(*tok_valueiter, ticksep);
      ASSERT(ticklesstokens.begin() != ticklesstokens.end(),
          "operator<< on Psi3Parser_Parameters - no tokens present after removing ticks in token "+*tok_valueiter+"!");
      std::stringstream valuestream(*(ticklesstokens.begin()));
      DoLog(2) && (Log() << Verbose(2)
          << "INFO: Token pair is " << key << "," << valuestream.str() << std::endl);

      // TODO: throw exception instead of DoeLog()
      ASSERT(params.haveParameter(key),
          "operator >> on Psi3Parser_Parameters - unknown parameter name '"
          +key+"' with value "+valuestream.str()+"!");
      if (params.haveParameter(key)) {
        Parameter *instance = params.FormatParser_Parameters::getParameter(key);
        instance->set(valuestream.str());
      }
    } else {
      ist.setstate(std::ios::eofbit);
    }
  }
  return ist;
}

/** Checks whether all elements in the world also have parameters in the basis.
 *
 * @return true - all elements parametrized, false - at least one element is missing.
 */
bool Psi3Parser_Parameters::checkWorldElementsAgainstCurrentBasis() const
{
  DoeLog(0) && (eLog() << Verbose(0)
      << "Psi3Parser_Parameters::checkWorldElementsAgainstCurrentBasis() - not implemented yet."
      << std::endl);

  return false;
}