QMCDriverFactory Class Reference

Collaboration diagram for QMCDriverFactory:

Classes
struct	DriverAssemblyState

Public Member Functions
	QMCDriverFactory (const ProjectData &project_data)
	Application uses this constructor param[in] project_data this is stored as a reference and this state controls later behavior. More...
DriverAssemblyState	readSection (xmlNodePtr cur) const
	default constructor More...
std::unique_ptr< QMCDriverInterface >	createQMCDriver (xmlNodePtr cur, DriverAssemblyState &das, const std::optional< EstimatorManagerInput > &emi, MCWalkerConfiguration &qmc_system, ParticleSetPool &particle_pool, WaveFunctionPool &wave_function_pool, HamiltonianPool &hamiltonian_pool, Communicate *comm) const
	create a new QMCDriver More...

Private Attributes
const ProjectData &	project_data_
	project info for accessing global fileroot and series id More...

Detailed Description

Definition at line 41 of file QMCDriverFactory.h.

---

Class Documentation

qmcplusplus::QMCDriverFactory::DriverAssemblyState

struct qmcplusplus::QMCDriverFactory::DriverAssemblyState

Definition at line 44 of file QMCDriverFactory.h.

Collaboration diagram for QMCDriverFactory::DriverAssemblyState:

Class Members
bool	append_run
bool	enable_profiling
QMCRunType	new_run_type
string	traces_tag
string	walkerlogs_tag
bitset< QMC_MODE_MAX >	what_to_do

Constructor & Destructor Documentation

QMCDriverFactory()

QMCDriverFactory

(

const ProjectData &

project_data

)

Application uses this constructor param[in] project_data this is stored as a reference and this state controls later behavior.

For both the driver factory i.e. driver verion. And the drivers it creates i.e. the section id and max CPU seconds.

Definition at line 49 of file QMCDriverFactory.cpp.

: project_data_(project_data) {}

Member Function Documentation

createQMCDriver()

std::unique_ptr< QMCDriverInterface > createQMCDriver	(	xmlNodePtr	cur,
		DriverAssemblyState &	das,
		const std::optional< EstimatorManagerInput > &	emi,
		MCWalkerConfiguration &	qmc_system,
		ParticleSetPool &	particle_pool,
		WaveFunctionPool &	wave_function_pool,
		HamiltonianPool &	hamiltonian_pool,
		Communicate *	comm
	)		const

create a new QMCDriver

Broken out for unit tests

Definition at line 142 of file QMCDriverFactory.cpp.

References APP_ABORT, qmcplusplus::app_log(), qmcplusplus::app_warning(), qmcplusplus::comm, DMCFactory::create(), VMCFactory::create(), RMCFactory::create(), DMCFactoryNew::create(), VMCFactoryNew::create(), qmcplusplus::emi(), QMCDriverFactory::DriverAssemblyState::enable_profiling, InfoStream::flush(), MCWalkerConfiguration::getSampleStack(), getXMLAttributeValue(), qmcplusplus::GPU_MODE, qmcplusplus::hamiltonian_pool, infoLog, infoSummary, qmcplusplus::MULTIPLE_MODE, QMCDriverFactory::DriverAssemblyState::new_run_type, qmcplusplus::particle_pool, qmcplusplus::QMCWFOptLinearFactoryNew(), Communicate::rank(), QMCHamiltonian::setPrimary(), QMCFixedSampleLinearOptimize::setWaveFunctionNode(), Communicate::size(), QMCDriverFactory::DriverAssemblyState::traces_tag, qmcplusplus::UPDATE_MODE, QMCDriverFactory::DriverAssemblyState::walkerlogs_tag, qmcplusplus::wavefunction_pool, and QMCDriverFactory::DriverAssemblyState::what_to_do.

Referenced by qmcplusplus::testing::createDriver(), and QMCMain::runQMC().

{
  ///////////////////////////////////////////////
  // get primaryPsi and primaryH
  ///////////////////////////////////////////////
  TrialWaveFunction* primaryPsi = 0;
  QMCHamiltonian* primaryH      = 0;
  std::queue<TrialWaveFunction*> targetPsi; //FIFO
  std::queue<QMCHamiltonian*> targetH;      //FIFO
  xmlNodePtr tcur = cur->children;
  std::unique_ptr<QMCDriverInterface> new_driver;
  while (tcur != NULL)
  {
    if (xmlStrEqual(tcur->name, (const xmlChar*)"qmcsystem"))
    {
      const std::string wf_name(getXMLAttributeValue(tcur, "wavefunction"));
      if (!wf_name.empty())
      {
        targetPsi.push(wavefunction_pool.getWaveFunction(wf_name));
      }
      else
      {
        app_warning() << " qmcsystem does not have wavefunction. Assign 0" << std::endl;
        targetPsi.push(0);
      }
      const std::string ham_name(getXMLAttributeValue(tcur, "hamiltonian"));
      if (!ham_name.empty())
      {
        targetH.push(hamiltonian_pool.getHamiltonian(ham_name));
      }
      else
      {
        app_warning() << " qmcsystem does not have hamiltonian. Assign 0" << std::endl;
        targetH.push(0);
      }
    }
    tcur = tcur->next;
  }
  //mark the first targetPsi and targetH as the primaries
  if (targetH.empty())
  {
    primaryPsi = wavefunction_pool.getPrimary();
    primaryH   = hamiltonian_pool.getPrimary();
  }
  else
  {
    primaryPsi = targetPsi.front();
    // targetPsi.pop();
    primaryH = targetH.front();
    //  targetH.pop();
  }
  //set primaryH->Primary
  primaryH->setPrimary(true);

  ////flux is evaluated only with single-configuration VMC
  //if(curRunType ==QMCRunType::VMC && !curQmcModeBits[MULTIPLE_MODE])
  //{
  //  OperatorBase* flux=primaryH->getHamiltonian("Flux");
  //  if(flux == 0) primaryH->addOperator(new ConservedEnergy,"Flux");
  //}
  //else
  //{
  //  primaryH->remove("Flux");
  //}
  //(SPACEWARP_MODE,MULTIPE_MODE,UPDATE_MODE)
  if (das.new_run_type == QMCRunType::VMC || das.new_run_type == QMCRunType::CSVMC)
  {
    //VMCFactory fac(curQmcModeBits[UPDATE_MODE],cur);
    VMCFactory fac(das.what_to_do.to_ulong(), cur);
    new_driver = fac.create(project_data_, qmc_system, *primaryPsi, *primaryH, comm, das.enable_profiling);
    //TESTING CLONE
    //TrialWaveFunction* psiclone=primaryPsi->makeClone(qmc_system);
    //qmcDriver = fac.create(qmc_system,*psiclone,*primaryH,particle_pool,hamiltonian_pool);
  }
  else if (das.new_run_type == QMCRunType::VMC_BATCH)
  {
    VMCFactoryNew fac(cur, das.what_to_do[UPDATE_MODE]);
    new_driver = fac.create(project_data_, emi, qmc_system,
                            MCPopulation(comm->size(), comm->rank(), &qmc_system, primaryPsi, primaryH),
                            qmc_system.getSampleStack(), comm);
  }
  else if (das.new_run_type == QMCRunType::DMC)
  {
    DMCFactory fac(das.what_to_do[UPDATE_MODE], das.what_to_do[GPU_MODE], cur);
    new_driver = fac.create(project_data_, qmc_system, *primaryPsi, *primaryH, comm, das.enable_profiling);
  }
  else if (das.new_run_type == QMCRunType::DMC_BATCH)
  {
    DMCFactoryNew fac(cur, das.what_to_do[UPDATE_MODE]);
    new_driver = fac.create(project_data_, emi, qmc_system,
                            MCPopulation(comm->size(), comm->rank(), &qmc_system, primaryPsi, primaryH), comm);
  }
  else if (das.new_run_type == QMCRunType::RMC)
  {
    RMCFactory fac(das.what_to_do[UPDATE_MODE], cur);
    new_driver = fac.create(project_data_, qmc_system, *primaryPsi, *primaryH, comm);
  }
  else if (das.new_run_type == QMCRunType::LINEAR_OPTIMIZE)
  {
#ifdef MIXED_PRECISION
    APP_ABORT("QMCDriverFactory::createQMCDriver : method=\"linear\" is not safe with CPU mixed precision. Please use "
              "full precision build instead.");
#endif
    QMCFixedSampleLinearOptimize* opt =
        new QMCFixedSampleLinearOptimize(project_data_, qmc_system, *primaryPsi, *primaryH, comm);
    //ZeroVarianceOptimize *opt = new ZeroVarianceOptimize(qmc_system,*primaryPsi,*primaryH );
    opt->setWaveFunctionNode(wavefunction_pool.getWaveFunctionNode("psi0"));
    new_driver.reset(opt);
  }
  else if (das.new_run_type == QMCRunType::LINEAR_OPTIMIZE_BATCH)
  {
#ifdef MIXED_PRECISION
    APP_ABORT("QMCDriverFactory::createQMCDriver : method=\"linear_batch\" is not safe with CPU mixed precision. "
              "Please use full precision build instead.");
#endif
    auto opt = QMCWFOptLinearFactoryNew(cur, project_data_, emi, qmc_system,
                                        MCPopulation(comm->size(), comm->rank(), &qmc_system, primaryPsi, primaryH),
                                        qmc_system.getSampleStack(), comm);
    opt->setWaveFunctionNode(wavefunction_pool.getWaveFunctionNode("psi0"));
    new_driver = std::move(opt);
  }
  else if (das.new_run_type == QMCRunType::WF_TEST)
  {
    app_log() << "Testing wavefunctions." << std::endl;
    QMCDriverInterface* temp_ptr =
        new WaveFunctionTester(project_data_, qmc_system, *primaryPsi, *primaryH, particle_pool, comm);
    new_driver.reset(temp_ptr);
  }
  else
  {
    APP_ABORT("Unhandled run type: " << static_cast<int>(das.new_run_type));
  }
  if (das.what_to_do[MULTIPLE_MODE])
  {
    while (targetH.size())
    {
      new_driver->add_H_and_Psi(targetH.front(), targetPsi.front());
      targetH.pop();
      targetPsi.pop();
    }
  }

  infoSummary.flush();
  infoLog.flush();
  //add trace information
  bool allow_traces = das.traces_tag == "yes" ||
      (das.traces_tag == "none" && (das.new_run_type == QMCRunType::VMC || das.new_run_type == QMCRunType::DMC));
  new_driver->requestTraces(allow_traces);

  //add trace information
  bool allow_walker_logs = das.walkerlogs_tag == "yes" ||
      (das.walkerlogs_tag == "none" && (das.new_run_type == QMCRunType::VMC || das.new_run_type == QMCRunType::DMC || das.new_run_type == QMCRunType::VMC_BATCH || das.new_run_type == QMCRunType::DMC_BATCH));
  new_driver->requestWalkerLogs(allow_walker_logs);

  return new_driver;
}

readSection()

QMCDriverFactory::DriverAssemblyState readSection

(

xmlNodePtr

cur

)

const

default constructor

Read the xml defining the driver for this QMC section.

read the current QMC Section In the application context project data can indicate the input be read in the context of the batched driver architecture. param[in] cur qmc section node param[in] emi std::optional<EstimatorManagerInput> if it is there it is the global estimator manager input.

Copy elision should result in just a move of the DriverAssemblyState

Most (all) of this should be done by calling QMCDriverInput::readXML At some point in driver refactoring this should go there and QMCDriverInput created before the giant switch

Definition at line 60 of file QMCDriverFactory.cpp.

References OhmmsAttributeSet::add(), QMCDriverFactory::DriverAssemblyState::append_run, castXMLCharToChar(), qmcplusplus::DMC, qmcplusplus::DMC_BATCH, QMCDriverFactory::DriverAssemblyState::enable_profiling, InfoStream::flush(), ProjectData::getDriverVersion(), qmcplusplus::if(), infoLog, infoSummary, qmcplusplus::LINEAR_OPTIMIZE, qmcplusplus::LINEAR_OPTIMIZE_BATCH, qmcplusplus::MULTIPLE_MODE, QMCDriverFactory::DriverAssemblyState::new_run_type, QMCDriverFactory::project_data_, OhmmsAttributeSet::put(), qmcplusplus::RMC, qmcplusplus::SPACEWARP_MODE, QMCDriverFactory::DriverAssemblyState::traces_tag, qmcplusplus::UPDATE_MODE, qmcplusplus::VMC, qmcplusplus::VMC_BATCH, QMCDriverFactory::DriverAssemblyState::walkerlogs_tag, qmcplusplus::WF_TEST, and QMCDriverFactory::DriverAssemblyState::what_to_do.

Referenced by QMCMain::runQMC(), and qmcplusplus::TEST_CASE().

{
  DriverAssemblyState das;
  std::string curName(castXMLCharToChar(cur->name));
  std::string update_mode("pbyp");
  std::string qmc_mode;
  std::string multi_tag("no");
  std::string warp_tag("no");
  std::string append_tag("no");
  std::string profiling_tag("no");
  OhmmsAttributeSet aAttrib;
  aAttrib.add(qmc_mode, "method",
              {"", "vmc", "vmc_batch", "dmc", "dmc_batch", "csvmc", "rmc", "linear", "linear_batch", "wftest"});
  aAttrib.add(update_mode, "move");
  aAttrib.add(multi_tag, "multiple");
  aAttrib.add(warp_tag, "warp");
  aAttrib.add(append_tag, "append");
  aAttrib.add(profiling_tag, "profiling");
  aAttrib.add(das.traces_tag, "trace");
  aAttrib.add(das.walkerlogs_tag, "walkerlog");
  aAttrib.put(cur);
  das.append_run                 = (append_tag == "yes");
  das.enable_profiling           = (profiling_tag == "yes");
  das.what_to_do[SPACEWARP_MODE] = (warp_tag == "yes");
  das.what_to_do[MULTIPLE_MODE]  = (multi_tag == "yes");
  das.what_to_do[UPDATE_MODE]    = (update_mode == "pbyp");
  infoSummary.flush();
  infoLog.flush();

  // Really by position if you don't write <qmc name="xxx",,,>
  // you can write <vmc ...> so hacky
  if (curName != "qmc")
    qmc_mode = curName;

  const int nchars = qmc_mode.size();

  using DV = ProjectData::DriverVersion;
  switch (project_data_.getDriverVersion())
  {
  case DV::BATCH:
    if (qmc_mode.find("vmc") < nchars)      // order matters here
      das.new_run_type = QMCRunType::VMC_BATCH;
    else if (qmc_mode.find("dmc") < nchars) // order matters here
      das.new_run_type = QMCRunType::DMC_BATCH;
    else if (qmc_mode.find("linear") < nchars)
      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE_BATCH;
    else
      throw UniformCommunicateError("QMC mode unknown. Valid modes for batched drivers are : vmc, dmc, linear.");
    break;
  // Begin to separate driver version = batch input reading from the legacy input parsing
  case DV::LEGACY:
    if (qmc_mode.find("linear_batch") < nchars) // order matters here
      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE_BATCH;
    else if (qmc_mode.find("linear") < nchars)
      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE;
    else
    {
      if (qmc_mode.find("ptcl") < nchars)
        das.what_to_do[UPDATE_MODE] = 1;
      if (qmc_mode.find("mul") < nchars)
        das.what_to_do[MULTIPLE_MODE] = 1;
      if (qmc_mode.find("warp") < nchars)
        das.what_to_do[SPACEWARP_MODE] = 1;
      if (qmc_mode.find("rmc") < nchars)
        das.new_run_type = QMCRunType::RMC;
      else if (qmc_mode.find("vmc_batch") < nchars) // order matters here
        das.new_run_type = QMCRunType::VMC_BATCH;
      else if (qmc_mode.find("vmc") < nchars)
        das.new_run_type = QMCRunType::VMC;
      else if (qmc_mode.find("dmc_batch") < nchars) // order matters here
        das.new_run_type = QMCRunType::DMC_BATCH;
      else if (qmc_mode.find("dmc") < nchars)
        das.new_run_type = QMCRunType::DMC;
      else if (qmc_mode == "wftest")
        das.new_run_type = QMCRunType::WF_TEST;
      else
        throw std::runtime_error("qmc method cannot be empty!");
    }
  }
  return das;
}

Member Data Documentation

project_data_

const ProjectData& project_data_

private

project info for accessing global fileroot and series id

Definition at line 87 of file QMCDriverFactory.h.

Referenced by QMCDriverFactory::readSection().

---

The documentation for this class was generated from the following files:

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/QMCDriverFactory.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/QMCDriverFactory.cpp