Merge pull request QMCPACK#4456 from williamfgc/ref-real-complex-QMCMain

Rename QMCAppBase and QMCMain members and one ifdef QMC_COMPLEX

Author: ye-luo

src/QMCApp/QMCAppBase.cpp

@@ -21,7 +21,7 @@ QMCAppBase::QMCAppBase() = default;
 
 QMCAppBase::~QMCAppBase()
 {
-  while (!XmlDocStack.empty())
+  while (!xml_doc_stack_.empty())
   {
     popDocument();
   }
@@ -33,7 +33,7 @@ bool QMCAppBase::pushDocument(const std::string& infile)
   bool success          = adoc->parse(infile);
   if (success)
   {
-    XmlDocStack.push(adoc);
+    xml_doc_stack_.push(adoc);
   }
   else
   {
@@ -45,12 +45,12 @@ bool QMCAppBase::pushDocument(const std::string& infile)
 
 void QMCAppBase::popDocument()
 {
-  if (!XmlDocStack.empty())
+  if (!xml_doc_stack_.empty())
   //Check if the stack is empty
   {
-    Libxml2Document* adoc = XmlDocStack.top();
+    Libxml2Document* adoc = xml_doc_stack_.top();
     delete adoc;
-    XmlDocStack.pop();
+    xml_doc_stack_.pop();
   }
 }
 
@@ -69,15 +69,15 @@ bool QMCAppBase::parse(const std::string& infile)
 
 void QMCAppBase::saveXml()
 {
-  if (!XmlDocStack.empty())
+  if (!xml_doc_stack_.empty())
   {
-    std::string newxml(myProject.currentMainRoot());
+    std::string newxml(my_project_.currentMainRoot());
     newxml.append(".cont.xml");
     app_log() << "\n========================================================="
               << "\n  A new xml input file : " << newxml << std::endl;
-    XmlDocStack.top()->dump(newxml);
+    xml_doc_stack_.top()->dump(newxml);
   }
 }
 
-const std::string& QMCAppBase::getTitle() const { return myProject.getTitle(); }
+const std::string& QMCAppBase::getTitle() const { return my_project_.getTitle(); }
 } // namespace qmcplusplus

src/QMCApp/QMCAppBase.h

@@ -61,13 +61,13 @@ class QMCAppBase
 
 protected:
   ///stack of xml document
-  std::stack<Libxml2Document*> XmlDocStack;
+  std::stack<Libxml2Document*> xml_doc_stack_;
 
   ///project description
-  ProjectData myProject;
+  ProjectData my_project_;
 
   ///random number controller
-  RandomNumberControl myRandomControl;
+  RandomNumberControl my_random_control_;
 
   ///open a new document
   bool pushDocument(const std::string& infile);

src/QMCApp/QMCMain.cpp

@@ -60,7 +60,7 @@ namespace qmcplusplus
 QMCMain::QMCMain(Communicate* c)
     : QMCMainState(c),
       QMCAppBase(),
-      FirstQMC(true)
+      first_qmc_(true)
 #if !defined(REMOVE_TRACEMANAGER)
       ,
       traces_xml(NULL)
@@ -116,13 +116,11 @@ QMCMain::QMCMain(Communicate* c)
   }
   app_summary() << "\n  Precision used in this calculation, see definitions in the manual:"
                 << "\n  Base precision      = " << GET_MACRO_VAL(OHMMS_PRECISION)
-                << "\n  Full precision      = " << GET_MACRO_VAL(OHMMS_PRECISION_FULL)
-                << std::endl;
+                << "\n  Full precision      = " << GET_MACRO_VAL(OHMMS_PRECISION_FULL) << std::endl;
 
   // Record features configured in cmake or selected via command-line arguments to the printout
   app_summary() << std::endl;
-#if !defined(ENABLE_OFFLOAD) && !defined(ENABLE_CUDA) && !defined(ENABLE_HIP) && \
-    !defined(ENABLE_SYCL)
+#if !defined(ENABLE_OFFLOAD) && !defined(ENABLE_CUDA) && !defined(ENABLE_HIP) && !defined(ENABLE_SYCL)
   app_summary() << "  CPU only build" << std::endl;
 #else // GPU case
 #if defined(ENABLE_OFFLOAD)
@@ -141,11 +139,10 @@ QMCMain::QMCMain(Communicate* c)
 #endif
 #endif // GPU case end
 
-#ifdef QMC_COMPLEX
-  app_summary() << "  Complex build. QMC_COMPLEX=ON" << std::endl;
-#else
-  app_summary() << "  Real build. QMC_COMPLEX=OFF" << std::endl;
-#endif
+  if (my_project_.isComplex())
+    app_summary() << "  Complex build. QMC_COMPLEX=ON" << std::endl;
+  else
+    app_summary() << "  Real build. QMC_COMPLEX=OFF" << std::endl;
 
 #ifdef ENABLE_TIMERS
   app_summary() << "  Timer build option is enabled. Current timer level is "
@@ -161,23 +158,23 @@ QMCMain::QMCMain(Communicate* c)
 QMCMain::~QMCMain()
 {
   // free last_driver before clearing P,Psi,H clones
-  last_driver.reset();
+  last_driver_.reset();
   CloneManager::clearClones();
 }
 
 
 bool QMCMain::execute()
 {
   Timer t0;
-  if (XmlDocStack.empty())
+  if (xml_doc_stack_.empty())
   {
     ERRORMSG("No valid input file exists! Aborting QMCMain::execute")
     return false;
   }
 
   std::string simulationType = "realspaceQMC";
   { // mmorales: is this necessary??? Don't want to leave xmlNodes lying around unused
-    xmlNodePtr cur = XmlDocStack.top()->getRoot();
+    xmlNodePtr cur = xml_doc_stack_.top()->getRoot();
     OhmmsAttributeSet simType;
     simType.add(simulationType, "type");
     simType.add(simulationType, "name");
@@ -194,11 +191,11 @@ bool QMCMain::execute()
               << "/*************************************************\n"
               << " ********  This is an AFQMC calculation   ********\n"
               << " *************************************************" << std::endl;
-    xmlNodePtr cur = XmlDocStack.top()->getRoot();
+    xmlNodePtr cur = xml_doc_stack_.top()->getRoot();
 
-    xmlXPathContextPtr m_context = XmlDocStack.top()->getXPathContext();
+    xmlXPathContextPtr m_context = xml_doc_stack_.top()->getXPathContext();
     //initialize the random number generator
-    xmlNodePtr rptr = myRandomControl.initialize(m_context);
+    xmlNodePtr rptr = my_random_control_.initialize(m_context);
 
     auto world = boost::mpi3::environment::get_world_instance();
     afqmc::AFQMCFactory afqmc_fac(world);
@@ -207,7 +204,7 @@ bool QMCMain::execute()
       app_log() << " Error in AFQMCFactory::parse() ." << std::endl;
       return false;
     }
-    cur = XmlDocStack.top()->getRoot();
+    cur = xml_doc_stack_.top()->getRoot();
     return afqmc_fac.execute(cur);
   }
 #else
@@ -250,11 +247,11 @@ bool QMCMain::execute()
   Timer t1;
   curMethod              = std::string("invalid");
   qmc_common.qmc_counter = 0;
-  for (int qa = 0; qa < m_qmcaction.size(); qa++)
+  for (int qa = 0; qa < qmc_action_.size(); qa++)
   {
     if (run_time_manager.isStopNeeded())
       break;
-    xmlNodePtr cur = m_qmcaction[qa].first;
+    xmlNodePtr cur = qmc_action_[qa].first;
     std::string cname((const char*)cur->name);
     if (cname == "qmc" || cname == "optimize")
     {
@@ -279,32 +276,32 @@ bool QMCMain::execute()
     }
   }
   // free if m_qmcation owns the memory of xmlNodePtr before clearing
-  for (auto& qmcactionPair : m_qmcaction)
+  for (auto& qmcactionPair : qmc_action_)
     if (!qmcactionPair.second)
       xmlFreeNode(qmcactionPair.first);
 
-  m_qmcaction.clear();
+  qmc_action_.clear();
   t2->stop();
   app_log() << "  Total Execution time = " << std::setprecision(4) << t1.elapsed() << " secs" << std::endl;
   if (is_manager())
   {
     //generate multiple files
     xmlNodePtr mcptr = NULL;
-    if (m_walkerset.size())
-      mcptr = m_walkerset[0];
+    if (walker_set_.size())
+      mcptr = walker_set_[0];
     //remove input mcwalkerset but one
-    for (int i = 1; i < m_walkerset.size(); i++)
+    for (int i = 1; i < walker_set_.size(); i++)
     {
-      xmlUnlinkNode(m_walkerset[i]);
-      xmlFreeNode(m_walkerset[i]);
+      xmlUnlinkNode(walker_set_[i]);
+      xmlFreeNode(walker_set_[i]);
     }
-    m_walkerset.clear(); //empty the container
+    walker_set_.clear(); //empty the container
     std::ostringstream np_str, v_str;
     np_str << myComm->size();
     HDFVersion cur_version;
     v_str << cur_version[0] << " " << cur_version[1];
     xmlNodePtr newmcptr = xmlNewNode(NULL, (const xmlChar*)"mcwalkerset");
-    xmlNewProp(newmcptr, (const xmlChar*)"fileroot", (const xmlChar*)myProject.currentMainRoot().c_str());
+    xmlNewProp(newmcptr, (const xmlChar*)"fileroot", (const xmlChar*)my_project_.currentMainRoot().c_str());
     xmlNewProp(newmcptr, (const xmlChar*)"node", (const xmlChar*)"-1");
     xmlNewProp(newmcptr, (const xmlChar*)"nprocs", (const xmlChar*)np_str.str().c_str());
     xmlNewProp(newmcptr, (const xmlChar*)"version", (const xmlChar*)v_str.str().c_str());
@@ -315,7 +312,7 @@ bool QMCMain::execute()
     //#endif
     if (mcptr == NULL)
     {
-      xmlAddNextSibling(lastInputNode, newmcptr);
+      xmlAddNextSibling(last_input_node_, newmcptr);
     }
     else
     {
@@ -359,7 +356,7 @@ void QMCMain::executeLoop(xmlNodePtr cur)
     }
   }
   // Destroy the last driver at the end of a loop with no further reuse of a driver needed.
-  last_driver.reset(nullptr);
+  last_driver_.reset(nullptr);
 }
 
 bool QMCMain::executeQMCSection(xmlNodePtr cur, bool reuse)
@@ -375,7 +372,7 @@ bool QMCMain::executeQMCSection(xmlNodePtr cur, bool reuse)
   if (qmcSystem == 0)
     qmcSystem = ptclPool->getWalkerSet(target);
   bool success = runQMC(cur, reuse);
-  FirstQMC     = false;
+  first_qmc_   = false;
   return success;
 }
 
@@ -395,27 +392,27 @@ bool QMCMain::executeQMCSection(xmlNodePtr cur, bool reuse)
  */
 bool QMCMain::validateXML()
 {
-  xmlXPathContextPtr m_context = XmlDocStack.top()->getXPathContext();
+  xmlXPathContextPtr m_context = xml_doc_stack_.top()->getXPathContext();
   OhmmsXPathObject result("//project", m_context);
-  myProject.setCommunicator(myComm);
+  my_project_.setCommunicator(myComm);
   if (result.empty())
   {
     app_warning() << "Project is not defined" << std::endl;
-    myProject.reset();
+    my_project_.reset();
   }
   else
   {
     try
     {
-      myProject.put(result[0]);
+      my_project_.put(result[0]);
     }
     catch (const UniformCommunicateError& ue)
     {
       myComm->barrier_and_abort(ue.what());
     }
   }
   app_summary() << std::endl;
-  myProject.get(app_summary());
+  my_project_.get(app_summary());
   app_summary() << std::endl;
   OhmmsXPathObject ham("//hamiltonian", m_context);
   if (ham.empty())
@@ -447,10 +444,10 @@ bool QMCMain::validateXML()
   }
 
   //initialize the random number generator
-  xmlNodePtr rptr = myRandomControl.initialize(m_context);
+  xmlNodePtr rptr = my_random_control_.initialize(m_context);
   //preserve the input order
-  xmlNodePtr cur = XmlDocStack.top()->getRoot()->children;
-  lastInputNode  = NULL;
+  xmlNodePtr cur   = xml_doc_stack_.top()->getRoot()->children;
+  last_input_node_ = NULL;
   while (cur != NULL)
   {
     std::string cname((const char*)cur->name);
@@ -476,7 +473,7 @@ bool QMCMain::validateXML()
         bool success = pushDocument(include_name);
         if (success)
         {
-          inputnode = processPWH(XmlDocStack.top()->getRoot());
+          inputnode = processPWH(xml_doc_stack_.top()->getRoot());
           popDocument();
         }
         else
@@ -503,11 +500,11 @@ bool QMCMain::validateXML()
     else
     {
       //everything else goes to m_qmcaction
-      m_qmcaction.push_back(std::pair<xmlNodePtr, bool>(cur, true));
+      qmc_action_.push_back(std::pair<xmlNodePtr, bool>(cur, true));
       inputnode = false;
     }
     if (inputnode)
-      lastInputNode = cur;
+      last_input_node_ = cur;
     cur = cur->next;
   }
 
@@ -585,7 +582,7 @@ bool QMCMain::processPWH(xmlNodePtr cur)
     else
     //add to m_qmcaction
     {
-      m_qmcaction.push_back(std::pair<xmlNodePtr, bool>(xmlCopyNode(cur, 1), false));
+      qmc_action_.push_back(std::pair<xmlNodePtr, bool>(xmlCopyNode(cur, 1), false));
     }
     cur = cur->next;
   }
@@ -604,11 +601,11 @@ bool QMCMain::runQMC(xmlNodePtr cur, bool reuse)
   std::unique_ptr<QMCDriverInterface> qmc_driver;
   bool append_run = false;
 
-  if (reuse && last_driver)
-    qmc_driver = std::move(last_driver);
+  if (reuse && last_driver_)
+    qmc_driver = std::move(last_driver_);
   else
   {
-    QMCDriverFactory driver_factory(myProject);
+    QMCDriverFactory driver_factory(my_project_);
     try
     {
       QMCDriverFactory::DriverAssemblyState das = driver_factory.readSection(cur);
@@ -624,24 +621,24 @@ bool QMCMain::runQMC(xmlNodePtr cur, bool reuse)
 
   if (qmc_driver)
   {
-    if (last_branch_engine_legacy_driver)
+    if (last_branch_engine_legacy_driver_)
     {
-      last_branch_engine_legacy_driver->resetRun(cur);
-      qmc_driver->setBranchEngine(std::move(last_branch_engine_legacy_driver));
+      last_branch_engine_legacy_driver_->resetRun(cur);
+      qmc_driver->setBranchEngine(std::move(last_branch_engine_legacy_driver_));
     }
 
     //advance the project id
     //if it is NOT the first qmc node and qmc/@append!='yes'
-    if (!FirstQMC && !append_run)
-      myProject.advance();
+    if (!first_qmc_ && !append_run)
+      my_project_.advance();
 
-    qmc_driver->setStatus(myProject.currentMainRoot(), "", append_run);
+    qmc_driver->setStatus(my_project_.currentMainRoot(), "", append_run);
     // PD:
-    // Q: How does m_walkerset_in end up being non empty?
+    // Q: How does walker_set_in end up being non empty?
     // A: Anytime that we aren't doing a restart.
     // So put walkers is an exceptional call. This code does not tell a useful
     // story of a QMCDriver's life.
-    qmc_driver->putWalkers(m_walkerset_in);
+    qmc_driver->putWalkers(walker_set_in_);
 #if !defined(REMOVE_TRACEMANAGER)
     qmc_driver->putTraces(traces_xml);
 #endif
@@ -652,10 +649,10 @@ bool QMCMain::runQMC(xmlNodePtr cur, bool reuse)
     qmc_driver->run();
     app_log() << "  QMC Execution time = " << std::setprecision(4) << qmcTimer.elapsed() << " secs" << std::endl;
     // transfer the states of a driver before its destruction
-    last_branch_engine_legacy_driver = qmc_driver->getBranchEngine();
+    last_branch_engine_legacy_driver_ = qmc_driver->getBranchEngine();
     // save the driver in a driver loop
     if (reuse)
-      last_driver = std::move(qmc_driver);
+      last_driver_ = std::move(qmc_driver);
     return true;
   }
   else
@@ -676,8 +673,8 @@ bool QMCMain::setMCWalkers(xmlXPathContextPtr context_)
   for (int iconf = 0; iconf < result.size(); iconf++)
   {
     xmlNodePtr mc_ptr = result[iconf];
-    m_walkerset.push_back(mc_ptr);
-    m_walkerset_in.push_back(mc_ptr);
+    walker_set_.push_back(mc_ptr);
+    walker_set_in_.push_back(mc_ptr);
   }
   //use the last mcwalkerset to initialize random numbers if possible
   if (result.size())