scnc
/
qmcpack
mirror of https://github.com/QMCPACK/qmcpack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1960 from ye-luo/protect-SPOSet 

Move some SPOSet members under protected and remove OptimizableSPOSet
This commit is contained in:
Paul R. C. Kent 2019-10-01 11:53:23 -04:00 committed by GitHub
parent c5600b1d1e 28770dfc9d
commit b515371dca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 80 additions and 1026 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/QMCWaveFunctions/CMakeLists.txt
View File

@ -28,7 +28,6 @@ SET(WFBASE_SRCS
SPOSetInfo.cpp SPOSetInfo.cpp
SPOSetInputInfo.cpp SPOSetInputInfo.cpp
SPOSet.cpp SPOSet.cpp
OptimizableSPOSet.cpp
CompositeSPOSet.cpp CompositeSPOSet.cpp
HarmonicOscillator/SHOSet.cpp HarmonicOscillator/SHOSet.cpp
HarmonicOscillator/SHOSetBuilder.cpp HarmonicOscillator/SHOSetBuilder.cpp
@ -56,7 +55,6 @@ SET(JASTROW_SRCS
Jastrow/RPAJastrow.cpp Jastrow/RPAJastrow.cpp
LatticeGaussianProduct.cpp LatticeGaussianProduct.cpp
LatticeGaussianProductBuilder.cpp LatticeGaussianProductBuilder.cpp
OptimizableSPOBuilder.cpp
Fermion/SPOSetProxy.cpp Fermion/SPOSetProxy.cpp
Fermion/SPOSetProxyForMSD.cpp Fermion/SPOSetProxyForMSD.cpp
) )

14
src/QMCWaveFunctions/Fermion/DiracDeterminantBase.h
View File

@ -43,9 +43,9 @@ public:
SPOVTimer(*TimerManager.createTimer("DiracDeterminantBase::spoval", timer_level_fine)), SPOVTimer(*TimerManager.createTimer("DiracDeterminantBase::spoval", timer_level_fine)),
SPOVGLTimer(*TimerManager.createTimer("DiracDeterminantBase::spovgl", timer_level_fine)) SPOVGLTimer(*TimerManager.createTimer("DiracDeterminantBase::spovgl", timer_level_fine))
{ {
Optimizable = Phi->Optimizable; Optimizable = Phi->isOptimizable();
is_fermionic = true; is_fermionic = true;
ClassName = "DiracDeterminantBase"; ClassName = "DiracDeterminantBase";
registerTimers(); registerTimers();
} }
@ -76,26 +76,16 @@ public:
virtual inline void checkInVariables(opt_variables_type& active) override virtual inline void checkInVariables(opt_variables_type& active) override
{ {
Phi->checkInVariables(active); Phi->checkInVariables(active);
Phi->checkInVariables(myVars);
} }
virtual inline void checkOutVariables(const opt_variables_type& active) override virtual inline void checkOutVariables(const opt_variables_type& active) override
{ {
Phi->checkOutVariables(active); Phi->checkOutVariables(active);
myVars.clear();
myVars.insertFrom(Phi->myVars);
myVars.getIndex(active);
} }
virtual void resetParameters(const opt_variables_type& active) override virtual void resetParameters(const opt_variables_type& active) override
{ {
Phi->resetParameters(active); Phi->resetParameters(active);
for (int i = 0; i < myVars.size(); ++i)
{
int ii = myVars.Index[i];
if (ii >= 0)
myVars[i] = active[ii];
}
} }
// To be removed with AoS // To be removed with AoS

2
src/QMCWaveFunctions/Fermion/MultiDiracDeterminant.cpp
View File

@ -392,7 +392,7 @@ MultiDiracDeterminant::MultiDiracDeterminant(SPOSetPtr const& spos, int first)
buildTableGradTimer(*TimerManager.createTimer("MultiDiracDeterminant::buildTableGrad")), buildTableGradTimer(*TimerManager.createTimer("MultiDiracDeterminant::buildTableGrad")),
ExtraStuffTimer(*TimerManager.createTimer("MultiDiracDeterminant::ExtraStuff")) ExtraStuffTimer(*TimerManager.createTimer("MultiDiracDeterminant::ExtraStuff"))
{ {
(spos->Optimizable == true) ? Optimizable = true : Optimizable = false; (spos->isOptimizable() == true) ? Optimizable = true : Optimizable = false;
ClassName = "MultiDiracDeterminant"; ClassName = "MultiDiracDeterminant";
IsCloned = false; IsCloned = false;

2
src/QMCWaveFunctions/Fermion/SlaterDetBuilder.cpp
View File

@ -589,7 +589,7 @@ bool SlaterDetBuilder::putDeterminant(xmlNodePtr cur, int spin_group)
targetPsi.setndelay(delay_rank); targetPsi.setndelay(delay_rank);
#endif #endif
slaterdet_0->add(adet, spin_group); slaterdet_0->add(adet, spin_group);
if (psi->Optimizable) if (psi->isOptimizable())
slaterdet_0->Optimizable = true; slaterdet_0->Optimizable = true;
app_log() << std::endl; app_log() << std::endl;

4
src/QMCWaveFunctions/Fermion/SlaterDetOpt.cpp
View File

@ -46,8 +46,8 @@ SlaterDetOpt::SlaterDetOpt(ParticleSet& ptcl, SPOSet* spo_ptr, const int up_or_d
resize(m_nel, m_nmo); resize(m_nel, m_nmo);
m_nlc = Phi->OrbitalSetSize; m_nlc = Phi->getOrbitalSetSize();
m_nb = Phi->BasisSetSize; m_nb = Phi->getBasisSetSize();
// make sure we didn't start with a bad m_nlc // make sure we didn't start with a bad m_nlc
check_index_sanity(); check_index_sanity();

6
src/QMCWaveFunctions/MolecularOrbitals/CuspCorr.cpp
View File

@ -25,7 +25,7 @@ void fillRadFunWithPhiBar(int curOrb_,
{ {
Psi1 = Phi; Psi1 = Phi;
Psi2 = Eta; Psi2 = Eta;
int norb = Psi1->OrbitalSetSize; int norb = Psi1->getOrbitalSetSize();
curOrb = curOrb_; curOrb = curOrb_;
curCenter = curCenter_; curCenter = curCenter_;
@ -56,7 +56,7 @@ void fillRadFunWithPhi(int curOrb_,
{ {
Psi1 = Phi; Psi1 = Phi;
Psi2 = Eta; Psi2 = Eta;
int norb = Psi1->OrbitalSetSize; int norb = Psi1->getOrbitalSetSize();
curOrb = curOrb_; curOrb = curOrb_;
curCenter = curCenter_; curCenter = curCenter_;
Z = Zion; Z = Zion;
@ -177,7 +177,7 @@ RealType execute(int curOrb_,
bool writeout = (thisFile != "NULL"); bool writeout = (thisFile != "NULL");
Psi1 = Phi; Psi1 = Phi;
Psi2 = Eta; Psi2 = Eta;
int norb = Psi1->OrbitalSetSize; int norb = Psi1->getOrbitalSetSize();
ValueVector_t X(5); ValueVector_t X(5);
curOrb = curOrb_; curOrb = curOrb_;
curCenter = curCenter_; curCenter = curCenter_;

2
src/QMCWaveFunctions/MolecularOrbitals/CuspCorr.h
View File

@ -104,7 +104,7 @@ public:
{ {
Psi1 = Phi; Psi1 = Phi;
Psi2 = Eta; Psi2 = Eta;
int norb = Psi1->OrbitalSetSize; int norb = Psi1->getOrbitalSetSize();
val1.resize(norb); val1.resize(norb);
grad1.resize(norb); grad1.resize(norb);

20
src/QMCWaveFunctions/MolecularOrbitals/LCOrbitalSetOpt.h
View File

@ -274,7 +274,7 @@ public:
this->setBasisSet(bs); this->setBasisSet(bs);
// initialize number of molecular orbitals as zero // initialize number of molecular orbitals as zero
this->OrbitalSetSize = 0; setOrbitalSetSize(0);
} }
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
@ -291,7 +291,7 @@ public:
this->setSPOSet(spo); this->setSPOSet(spo);
// initialize number of molecular orbitals as zero // initialize number of molecular orbitals as zero
this->OrbitalSetSize = 0; setOrbitalSetSize(0);
} }
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
@ -358,7 +358,7 @@ public:
m_spo_set = spo; m_spo_set = spo;
// extract the number of single particle orbitals in the basis set // extract the number of single particle orbitals in the basis set
this->BasisSetSize = m_spo_set->OrbitalSetSize; this->BasisSetSize = m_spo_set->getOrbitalSetSize();
} }
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
@ -380,7 +380,7 @@ public:
retval = new LCOrbitalSetOpt(m_basis_set->makeClone(), m_report_level); retval = new LCOrbitalSetOpt(m_basis_set->makeClone(), m_report_level);
retval->C = C; retval->C = C;
retval->setOrbitalSetSize(this->OrbitalSetSize); retval->setOrbitalSetSize(OrbitalSetSize);
retval->init_LCOrbitalSetOpt(0.0); retval->init_LCOrbitalSetOpt(0.0);
retval->m_B = m_B; retval->m_B = m_B;
@ -429,7 +429,7 @@ public:
void setOrbitalSetSize(int norbs) void setOrbitalSetSize(int norbs)
{ {
// record the number of linear combinations (i.e. molecular orbitals) // record the number of linear combinations (i.e. molecular orbitals)
this->OrbitalSetSize = norbs; OrbitalSetSize = norbs;
app_log() << "LCOrbitalSetOpt finished setOrbitalSetSize with norbs = " << norbs << std::endl; app_log() << "LCOrbitalSetOpt finished setOrbitalSetSize with norbs = " << norbs << std::endl;
} }
@ -698,7 +698,7 @@ public:
//app_log() << "this->OrbitalSetSize = " << this->OrbitalSetSize << std::endl; //app_log() << "this->OrbitalSetSize = " << this->OrbitalSetSize << std::endl;
// check sanity // check sanity
this->check_input_dim("logdet # of columns", "LCOrbitalSetOpt::evaluate_notranspose", logdet.cols(), this->check_input_dim("logdet # of columns", "LCOrbitalSetOpt::evaluate_notranspose", logdet.cols(),
this->OrbitalSetSize); OrbitalSetSize);
if (logdet.cols() != dlogdet.cols() || logdet.cols() != d2logdet.cols()) if (logdet.cols() != dlogdet.cols() || logdet.cols() != d2logdet.cols())
throw std::runtime_error("logdet, dlogdet, and d2logdet should have the same number of columns in " throw std::runtime_error("logdet, dlogdet, and d2logdet should have the same number of columns in "
"LCOrbitalSetOpt::evaluate_notranspose"); "LCOrbitalSetOpt::evaluate_notranspose");
@ -724,7 +724,7 @@ public:
inline void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi) inline void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi)
{ {
// check input vector dimension // check input vector dimension
this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), this->OrbitalSetSize); this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), OrbitalSetSize);
// resize temporary arrays if necessary // resize temporary arrays if necessary
if (m_temp_g.size() != BasisSetSize) if (m_temp_g.size() != BasisSetSize)
@ -757,9 +757,9 @@ public:
inline void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi, GradVector_t& dpsi, ValueVector_t& d2psi) inline void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi, GradVector_t& dpsi, ValueVector_t& d2psi)
{ {
// check sanity // check sanity
this->check_input_dim("d2psi", "LCOrbitalSetOpt::evaluate", d2psi.size(), this->OrbitalSetSize); this->check_input_dim("d2psi", "LCOrbitalSetOpt::evaluate", d2psi.size(), OrbitalSetSize);
this->check_input_dim("dpsi", "LCOrbitalSetOpt::evaluate", dpsi.size(), this->OrbitalSetSize); this->check_input_dim("dpsi", "LCOrbitalSetOpt::evaluate", dpsi.size(), OrbitalSetSize);
this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), this->OrbitalSetSize); this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), OrbitalSetSize);
if (psi.size() != dpsi.size() || psi.size() != d2psi.size()) if (psi.size() != dpsi.size() || psi.size() != d2psi.size())
throw std::runtime_error("psi, dpsi, and d2psi vectors must be the same length in LCOrbitalSetOpt::evaluate"); throw std::runtime_error("psi, dpsi, and d2psi vectors must be the same length in LCOrbitalSetOpt::evaluate");

1
src/QMCWaveFunctions/MolecularOrbitals/LCOrbitalSetWithCorrection.cpp
View File

@ -192,7 +192,6 @@ LCOrbitalSet<BS, false>* LCOrbitalSetWithCorrection<BS, false>::clone2LCOrbitalS
newSPO->C = C; newSPO->C = C;
newSPO->Occ.resize(Occ.size()); newSPO->Occ.resize(Occ.size());
newSPO->Occ = Occ; newSPO->Occ = Occ;
newSPO->className = "LCOrbitalSet";
return newSPO; return newSPO;
} }

31
src/QMCWaveFunctions/OptimizableSPOBuilder.cpp
View File

@ -1,31 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois/NCSA Open Source License.
// See LICENSE file in top directory for details.
//
// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
//
// File developed by: Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
// Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
// Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
// Jaron T. Krogel, krogeljt@ornl.gov, Oak Ridge National Laboratory
//
// File created by: Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
//////////////////////////////////////////////////////////////////////////////////////
#include "QMCWaveFunctions/OptimizableSPOBuilder.h"
#include "OhmmsData/AttributeSet.h"
namespace qmcplusplus
{
OptimizableSPOBuilder::OptimizableSPOBuilder(ParticleSet& p, PtclPoolType& psets, Communicate* comm, xmlNodePtr cur)
: SPOSetBuilder(comm), targetPtcl(&p)
{}
SPOSet* OptimizableSPOBuilder::createSPOSetFromXML(xmlNodePtr cur)
{
OptimizableSPOSet* spo = new OptimizableSPOSet();
return spo;
}
} // namespace qmcplusplus

43
src/QMCWaveFunctions/OptimizableSPOBuilder.h
View File

@ -1,43 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois/NCSA Open Source License.
// See LICENSE file in top directory for details.
//
// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
//
// File developed by: Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
// Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
// Jaron T. Krogel, krogeljt@ornl.gov, Oak Ridge National Laboratory
// Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
//
// File created by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
//////////////////////////////////////////////////////////////////////////////////////
#ifndef OPTIMIZABLE_SPO_BUILDER_H
#define OPTIMIZABLE_SPO_BUILDER_H
#include "QMCWaveFunctions/SPOSetBuilder.h"
#include "QMCWaveFunctions/OptimizableSPOSet.h"
namespace qmcplusplus
{
class OptimizableSPOBuilder : public SPOSetBuilder
{
protected:
typedef std::map<std::string, ParticleSet*> PtclPoolType;
typedef std::map<std::string, SPOSet*> SPOPoolType;
ParticleSet* targetPtcl;
public:
OptimizableSPOBuilder(ParticleSet& p, PtclPoolType& psets, Communicate* comm, xmlNodePtr cur);
/** initialize the Antisymmetric wave function for electrons
*@param cur the current xml node
*/
SPOSet* createSPOSetFromXML(xmlNodePtr cur);
// SPOSet* createSPOSetFromXML(xmlNodePtr cur, SPOPool_t& spo_pool);
};
} // namespace qmcplusplus
#endif

618
src/QMCWaveFunctions/OptimizableSPOSet.cpp
View File

@ -1,618 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois/NCSA Open Source License.
// See LICENSE file in top directory for details.
//
// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
//
// File developed by: Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
// Miguel Morales, moralessilva2@llnl.gov, Lawrence Livermore National Laboratory
// Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
// Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
// Ye Luo, yeluo@anl.gov, Argonne National Laboratory
// Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
//
// File created by: Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
//////////////////////////////////////////////////////////////////////////////////////
#include "Message/Communicate.h"
#include "QMCWaveFunctions/OptimizableSPOSet.h"
#include "Numerics/OhmmsBlas.h"
#include "OhmmsData/AttributeSet.h"
namespace qmcplusplus
{
void OptimizableSPOSet::addParameter(std::string id, int iorb, int basis) {}
bool OptimizableSPOSet::put(xmlNodePtr node, SPOPool_t& spo_pool)
{
std::string gsName, basisName;
bool same_k = false;
bool mapped_k = false;
bool same_orbital = false;
bool lapl = false;
derivScale = 1.0;
OhmmsAttributeSet attrib;
attrib.add(gsName, "gs_sposet");
attrib.add(basisName, "basis_sposet");
attrib.add(same_k, "same_k");
attrib.add(mapped_k, "mapped_k");
attrib.add(same_orbital, "same_orbital");
attrib.add(lapl, "lapl");
attrib.add(N, "size");
attrib.add(derivScale, "scale");
attrib.add(thr, "thr");
attrib.put(node);
if (N == 0)
{
app_error() << "You must specify \"size\" attribute for linearopt sposet.\n";
abort();
}
/////////////////////////////////////
// First, find ground-state SPOSet //
/////////////////////////////////////
if (gsName == "")
{
app_error() << "You must supply \"gs_sposet\". Aborting.\n";
abort();
}
SPOPool_t::iterator iter = spo_pool.find(gsName);
if (iter == spo_pool.end())
{
app_error() << "No sposet named \"" << gsName << "\" found. Abort.\n";
abort();
}
else
{
app_log() << " Found ground-state SPOSet \"" << gsName << "\".\n";
GSOrbitals = iter->second;
}
//////////////////////////////////////
// Now, find basis SPOSet from pool //
//////////////////////////////////////
iter = spo_pool.find(basisName);
if (iter != spo_pool.end())
{
BasisOrbitals = iter->second;
app_log() << " Found basis SPOSet \"" << basisName << "\".\n";
}
if (BasisOrbitals == GSOrbitals)
BasisOrbitals = 0;
if (BasisOrbitals)
M = BasisOrbitals->getOrbitalSetSize();
else
M = GSOrbitals->getOrbitalSetSize() - N;
resize(N, M);
app_log() << " linearopt sposet has " << N << " ground-state orbitals and " << M << " basis orbitals.\n";
//Map K points to orbitals.
ValueMatrix_t allowedOrbs;
allowedOrbs.resize(N, M);
// if (mapped_k)
// {
// std::cerr <<"Not Done"<< std::endl;
// }
// else
if (same_k)
{
int off = BasisOrbitals ? 0 : N;
SPOSet* basOrbs = BasisOrbitals ? BasisOrbitals : GSOrbitals;
for (int igs = 0; igs < N; igs++)
{
PosType k_gs = GSOrbitals->get_k(igs);
for (int ib = 0; ib < M; ib++)
{
PosType k_b = basOrbs->get_k(ib + off);
if (dot(k_gs - k_b, k_gs - k_b) < 1.0e-6)
{
// app_log()<<"Allowing ("<<igs<<","<<ib<<") :";
// for(int ix=0;ix<3;ix++) app_log()<<k_gs[ix]<<" ";
// app_log()<<" : ";
// for(int ix=0;ix<3;ix++) app_log()<<k_b[ix]<<" ";
// app_log()<< std::endl;
allowedOrbs(igs, ib) = 1;
}
else
{
// app_log()<<"Not allowing ("<<igs<<","<<ib<<") :";
// for(int ix=0;ix<3;ix++) app_log()<<k_gs[ix]<<" ";
// app_log()<<" : ";
// for(int ix=0;ix<3;ix++) app_log()<<k_b[ix]<<" ";
// app_log()<< std::endl;
allowedOrbs(igs, ib) = 0;
}
}
}
}
else if (mapped_k)
{
xmlNodePtr xmlCoefs = node->xmlChildrenNode;
while (xmlCoefs != NULL)
{
std::string cname((const char*)xmlCoefs->name);
if (cname == "orbitalmap")
{
std::string type("0");
OhmmsAttributeSet cAttrib;
cAttrib.add(type, "type");
cAttrib.put(xmlCoefs);
if (type != "Array")
{
// app_error() << "Unknown correlation type " + type + " in OptimizableSPOSet." + "Resetting to \"Array\"\n";
xmlNewProp(xmlCoefs, (const xmlChar*)"type", (const xmlChar*)"Array");
}
std::vector<RealType> params;
putContent(params, xmlCoefs);
int indx(0);
if (params.size() == N * M)
for (int igs = 0; igs < N; igs++)
{
for (int ib = 0; ib < M; ib++)
{
allowedOrbs(igs, ib) = params[indx++];
}
}
else
{
app_error() << "Map size is incorrect. parameters given= " << params.size() << " parameters needed= " << M * N
<< std::endl;
}
}
xmlCoefs = xmlCoefs->next;
}
}
else if (same_orbital)
{
if (M < N)
{
app_error() << "Map size is incorrect. N<M for same orbital mapping" << std::endl;
}
allowedOrbs = 0;
for (int igs = 0; igs < N; igs++)
allowedOrbs(igs, igs) = 1;
}
else if (lapl)
{
for (int igs = 0; igs < N; igs++)
for (int ib = 0; ib < (M / N); ib++)
allowedOrbs(igs, igs + N * ib) = 1;
}
else
{
for (int igs = 0; igs < N; igs++)
{
for (int ib = 0; ib < M; ib++)
{
allowedOrbs(igs, ib) = 1;
}
}
}
// Now, look for coefficients element
xmlNodePtr xmlCoefs = node->xmlChildrenNode;
while (xmlCoefs != NULL)
{
std::string cname((const char*)xmlCoefs->name);
if (cname == "coefficients")
{
std::string type("0"), id("0");
int state = -1;
int asize(-1);
OhmmsAttributeSet cAttrib;
cAttrib.add(id, "id");
cAttrib.add(type, "type");
cAttrib.add(asize, "size");
cAttrib.add(state, "state");
cAttrib.put(xmlCoefs);
if (state == -1)
{
app_error() << "You must specify the \"state\" attribute in <linearopt>'s <coefficient>.\n";
}
if (type != "Array")
{
// app_error() << "Unknown correlation type " + type + " in OptimizableSPOSet." + "Resetting to \"Array\"\n";
xmlNewProp(xmlCoefs, (const xmlChar*)"type", (const xmlChar*)"Array");
}
std::vector<RealType> params;
putContent(params, xmlCoefs);
app_log() << "Coefficients for state" << state << ":\n";
// std::cerr << "params.size() = " << params.size() << std::endl;
//If params is missized resize and initialize to zero.
if ((params.size() != asize) && (asize > 0))
{
std::vector<RealType> t_params(params);
params.resize(asize, 0.0);
int ipm(0);
if (t_params.size() > 0)
{
for (int ib = 0; ib < M; ib++)
{
#if defined(QMC_COMPLEX)
if ((allowedOrbs(state, ib).real() > 0) && (std::abs(t_params[ipm]) > thr))
{
params[ib] = t_params[ipm++];
#else
if ((allowedOrbs(state, ib) > 0) && (std::abs(t_params[ipm]) > thr))
{
params[ib] = t_params[ipm++];
#endif
}
else
{
params[ib] = 0;
}
}
}
}
else
{
if (params.size())
asize = params.size();
}
// for (int i=0; i< params.size(); i++) {
ValueMatrix_t& cref(*C);
int indx = 0;
for (int i = 0; i < M; i++)
{
std::stringstream sstr;
#ifndef QMC_COMPLEX
// ParamPointers.push_back(&(C(state,i)));
// ParamIndex.push_back(TinyVector<int,2>(state,i));
sstr << id << "_" << indx;
if (allowedOrbs(state, i))
{
ParamPointers.push_back(&(cref(state, i)));
ParamIndex.push_back(TinyVector<int, 2>(state, i));
if ((indx < asize) && (std::abs(params[indx]) > thr))
cref(state, i) = params[indx];
else
cref(state, i) = 0.0;
myVars.insert(sstr.str(), cref(state, i), true, optimize::SPO_P);
indx++;
}
else
{
cref(state, i) = 0.0;
// myVars.insert(sstr.str(),C(state,i),false,optimize::LINEAR_P);
}
#else
//ParamPointers.push_back(&(C(state,i).real()));
//ParamPointers.push_back(&(C(state,i).imag()));
ParamPointers.push_back(reinterpret_cast<RealType*>(cref[state] + i));
ParamPointers.push_back(reinterpret_cast<RealType*>(cref[state] + i) + 1);
ParamIndex.push_back(TinyVector<int, 2>(state, i));
ParamIndex.push_back(TinyVector<int, 2>(state, i));
sstr << id << "_" << 2 * i + 0;
myVars.insert(sstr.str(), cref(state, i).real(), true, optimize::SPO_P);
sstr << id << "_" << 2 * i + 1;
myVars.insert(sstr.str(), cref(state, i).imag(), true, optimize::SPO_P);
#endif
}
for (int i = 0; i < params.size(); i++)
{
char buf[100];
snprintf(buf, 100, " %12.5f\n", params[i]);
app_log() << buf;
}
}
xmlCoefs = xmlCoefs->next;
}
return true;
}
void OptimizableSPOSet::resetTargetParticleSet(ParticleSet& P)
{
GSOrbitals->resetTargetParticleSet(P);
if (BasisOrbitals)
BasisOrbitals->resetTargetParticleSet(P);
}
void OptimizableSPOSet::setOrbitalSetSize(int norbs) { OrbitalSetSize = norbs; }
void OptimizableSPOSet::checkInVariables(opt_variables_type& active) { active.insertFrom(myVars); }
void OptimizableSPOSet::checkOutVariables(const opt_variables_type& active) { myVars.getIndex(active); }
void OptimizableSPOSet::resetParameters(const opt_variables_type& active)
{
for (int i = 0; i < ParamPointers.size(); i++)
{
int loc=myVars.where(i);
if (loc>=0)
if(std::abs(active[loc])>thr) {
myVars[i]=active[loc];
//FIXME the use of "std::real" needs to be removed after the orbital optimization code is made compatible with complex parameters
*(ParamPointers[i]) = std::real( myVars[i] );
}
}
}
// Obsolete
void OptimizableSPOSet::evaluateDerivatives(ParticleSet& P,
int iat,
const opt_variables_type& active,
ValueMatrix_t& d_phi,
ValueMatrix_t& d_lapl_phi)
{
for (int i = 0; i < d_phi.size(); i++)
for (int j = 0; j < N; j++)
d_phi[i][j] = d_lapl_phi[i][j] = ValueType();
// Evaluate basis states
if (BasisOrbitals)
{
BasisOrbitals->evaluate(P, iat, BasisVal);
std::vector<TinyVector<int, 2>>::iterator iter;
std::vector<TinyVector<int, 2>>& act = ActiveBasis[iat];
for (iter = act.begin(); iter != act.end(); iter++)
{
int elem = (*iter)[0];
int param = (*iter)[1];
int loc = myVars.where(param);
if (loc >= 0)
;
}
}
else
{}
}
void OptimizableSPOSet::evaluate(const ParticleSet& P, int iat, ValueVector_t& psi)
{
GSOrbitals->evaluate(P, iat, GSVal);
if (BasisOrbitals)
{
BasisOrbitals->evaluate(P, iat, BasisVal);
BLAS::gemv_trans(N, M, C->data(), &(BasisVal[0]), &(psi[0]));
}
else
BLAS::gemv_trans(N, M, C->data(), &(GSVal[N]), &(psi[0]));
// for (int i=0; i<N; i++) {
// psi[i] = 0.0;
// for (int j=0; j<M; j++)
// psi[i] += C(i,j)*GSVal[N+j];
// }
for (int i = 0; i < N; i++)
psi[i] += GSVal[i];
}
void OptimizableSPOSet::evaluate(const ParticleSet& P,
int iat,
ValueVector_t& psi,
GradVector_t& dpsi,
ValueVector_t& d2psi)
{
GSOrbitals->evaluate(P, iat, GSVal, GSGrad, GSLapl);
const ValueMatrix_t& cref(*C);
if (BasisOrbitals)
{
BasisOrbitals->evaluate(P, iat, BasisVal, BasisGrad, BasisLapl);
BLAS::gemv_trans(N, M, C->data(), &(BasisVal[0]), &(psi[0]));
BLAS::gemv_trans(N, M, C->data(), &(BasisLapl[0]), &(d2psi[0]));
for (int iorb = 0; iorb < N; iorb++)
{
psi[iorb] += GSVal[iorb];
dpsi[iorb] = GSGrad[iorb];
d2psi[iorb] += GSLapl[iorb];
for (int ibasis = 0; ibasis < M; ibasis++)
for (int dim = 0; dim < OHMMS_DIM; dim++)
dpsi[iorb][dim] += cref(iorb, ibasis) * BasisGrad[ibasis][dim];
}
}
else
{
for (int iorb = 0; iorb < N; iorb++)
{
psi[iorb] = GSVal[iorb];
dpsi[iorb] = GSGrad[iorb];
d2psi[iorb] = GSLapl[iorb];
for (int ibasis = 0; ibasis < M; ibasis++)
{
psi[iorb] += cref(iorb, ibasis) * GSVal[N + ibasis];
for (int dim = 0; dim < OHMMS_DIM; dim++)
dpsi[iorb][dim] += cref(iorb, ibasis) * GSGrad[N + ibasis][dim];
d2psi[iorb] += cref(iorb, ibasis) * GSLapl[N + ibasis];
}
}
// BLAS::gemv_trans (N, M, C.data(), &(GSVal[N]), &(psi[0]));
// BLAS::gemv_trans (N, M, C.data(), &(GSLapl[N]), &(d2psi[0]));
}
// for (int i=0; i<N; i++) {
// psi[i] += GSVal[i];
// d2psi[i] += GSLapl[i];
// }
}
void OptimizableSPOSet::evaluateBasis(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& basis_val,
GradMatrix_t& basis_grad,
ValueMatrix_t& basis_lapl)
{
if (BasisOrbitals)
BasisOrbitals->evaluate_notranspose(P, first, last, basis_val, basis_grad, basis_lapl);
else
{
for (int iat = first; iat < last; iat++)
{
GSOrbitals->evaluate(P, iat, GSVal, GSGrad, GSLapl);
for (int i = 0; i < M; i++)
{
basis_val(iat - first, i) = GSVal[N + i];
basis_grad(iat - first, i) = GSGrad[N + i];
basis_lapl(iat - first, i) = GSLapl[N + i];
}
}
}
}
void OptimizableSPOSet::copyParamsFromMatrix(const opt_variables_type& active,
const Matrix<RealType>& mat,
std::vector<RealType>& destVec)
{
for (int ip = 0; ip < myVars.size(); ip++)
{
int loc = myVars.where(ip);
if (loc >= 0)
{
TinyVector<int, 2> idx = ParamIndex[ip];
destVec[loc] += derivScale * mat(idx[0], idx[1]);
}
}
}
void OptimizableSPOSet::copyParamsFromMatrix(const opt_variables_type& active,
const Matrix<ComplexType>& mat,
std::vector<RealType>& destVec)
{
for (int ip = 0; ip < myVars.size(); ip += 2)
{
int loc = myVars.where(ip);
if (loc >= 0)
{
TinyVector<int, 2> idx = ParamIndex[ip];
assert(ParamIndex[ip + 1][0] == idx[0] && ParamIndex[ip + 1][1] == idx[1]);
destVec[loc] += derivScale * mat(idx[0], idx[1]).real();
loc = myVars.where(ip + 1);
assert(loc >= 0);
destVec[loc] += derivScale * mat(idx[0], idx[1]).imag();
}
}
}
void OptimizableSPOSet::evaluate_notranspose(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& logdet,
GradMatrix_t& dlogdet,
ValueMatrix_t& d2logdet)
{
// std::cerr << "GSValMatrix.size =(" << GSValMatrix.size(0) << ", " << GSValMatrix.size(1) << ")\n";
// std::cerr << "GSGradMatrix.size =(" << GSGradMatrix.size(0) << ", " << GSGradMatrix.size(1) << ")\n";
// std::cerr << "GSLaplMatrix.size =(" << GSLaplMatrix.size(0) << ", " << GSLaplMatrix.size(1) << ")\n";
// std::cerr << "first=" << first << " last=" << last << std::endl;
GSOrbitals->evaluate_notranspose(P, first, last, GSValMatrix, GSGradMatrix, GSLaplMatrix);
if (BasisOrbitals)
{
BasisOrbitals->evaluate_notranspose(P, first, last, BasisValMatrix, BasisGradMatrix, BasisLaplMatrix);
//Note to Ken:
//Use Numerics/MatrixOperators.h
//for C=AB MatrixOperators::product(C,BasisValMatrix,logdet);
//for C=AB^t MatrixOperators::ABt(C,BasisValMatrix,logdet);
BLAS::gemm('T', 'N', N, N, M, 1.0, C->data(), M, BasisValMatrix.data(), M, 0.0, logdet.data(), N);
logdet += GSValMatrix;
BLAS::gemm('T', 'N', N, N, M, 1.0, C->data(), M, BasisLaplMatrix.data(), M, 0.0, d2logdet.data(), N);
d2logdet += GSLaplMatrix;
// Gradient part.
for (int dim = 0; dim < OHMMS_DIM; dim++)
{
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
GradTmpSrc(i, j) = BasisGradMatrix(i, j)[dim];
BLAS::gemm('T', 'N', N, N, M, 1.0, C->data(), M, GradTmpSrc.data(), M, 0.0, GradTmpDest.data(), N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
dlogdet(i, j)[dim] = GradTmpDest(i, j) + GSGradMatrix(i, j)[dim];
}
}
else
{
// HACK HACK HACK
// BLAS::gemm ('T', 'N', N, N, M, 1.0, C.data(),
// M, GSValMatrix.data()+N, M+N, 0.0, logdet.data(), N);
// for (int i=0; i<N; i++)
// for (int j=0; j<N; j++)
// logdet(i,j) += GSValMatrix(i,j);
for (int iel = 0; iel < N; iel++)
for (int iorb = 0; iorb < N; iorb++)
{
logdet(iel, iorb) = GSValMatrix(iel, iorb);
const ValueType* restrict cptr = (*C)[iorb];
for (int ibasis = 0; ibasis < M; ibasis++)
logdet(iel, iorb) += cptr[ibasis] * GSValMatrix(iel, N + ibasis);
}
// logdet += GSValMatrix;
// BLAS::gemm ('T', 'N', N, N, M, 1.0, C.data(),
// M, GSLaplMatrix.data()+N, M+N, 0.0, d2logdet.data(), N);
for (int iel = 0; iel < N; iel++)
for (int iorb = 0; iorb < N; iorb++)
{
const ValueType* restrict cptr = (*C)[iorb];
d2logdet(iel, iorb) = GSLaplMatrix(iel, iorb);
for (int ibasis = 0; ibasis < M; ibasis++)
d2logdet(iel, iorb) += cptr[ibasis] * GSLaplMatrix(iel, N + ibasis);
}
//d2logdet += GSLaplMatrix;
// Gradient part.
for (int i = 0; i < N; i++)
for (int iorb = 0; iorb < N; iorb++)
{
const ValueType* restrict cptr = (*C)[iorb];
dlogdet(i, iorb) = GSGradMatrix(i, iorb);
for (int n = 0; n < M; n++)
dlogdet(i, iorb) += cptr[n] * GSGradMatrix(i, N + n);
}
// for (int dim=0; dim<OHMMS_DIM; dim++) {
// for (int i=0; i<M; i++)
// for (int j=0; j<N; j++)
// GradTmpSrc(i,j) = GSGradMatrix(i,j+N)[dim];
// BLAS::gemm ('T', 'N', N, N, M, 1.0, C.data(), M,
// GradTmpSrc.data(), M, 0.0, GradTmpDest.data(), N);
// for (int i=0; i<N; i++)
// for (int j=0; j<N; j++)
// dlogdet(i,j)[dim] = GradTmpDest(i,j) + GSGradMatrix(i,j)[dim];
//}
}
}
SPOSet* OptimizableSPOSet::makeClone() const
{
SPOSet *gs, *basis(0);
OptimizableSPOSet* clone;
gs = GSOrbitals->makeClone();
if (BasisOrbitals)
basis = BasisOrbitals->makeClone();
clone = new OptimizableSPOSet(N, gs, basis);
clone->IsCloned = true;
clone->C = C; //just pointer
clone->thr = thr;
clone->myVars = myVars;
clone->derivScale = derivScale;
#if 0
clone->ParamPointers.clear();
clone->ParamIndex=ParamIndex;
for(int i=0; i<ParamIndex.size() ; i++)
{
#ifndef QMC_COMPLEX
clone->ParamPointers.push_back(&(clone->C(ParamIndex[i][0],ParamIndex[i][1])));
#else
int ci=ParamIndex[i][0];
int cj=ParamIndex[i][1];
//clone->ParamPointers.push_back(&(clone->C(ParamIndex[i][0],ParamIndex[i][1]).real()));
//clone->ParamPointers.push_back(&(clone->C(ParamIndex[i][0],ParamIndex[i][1]).imag()));
clone->ParamPointers.push_back(reinterpret_cast<RealType*>(clone->C[ci]+cj));
clone->ParamPointers.push_back(reinterpret_cast<RealType*>(clone->C[ci]+cj)+1);
#endif
}
#endif
// for (int i=0; i< N; i++) {
// for (int j=0; j< M; j++) {
// std::stringstream sstr;
// #ifndef QMC_COMPLEX
// clone->ParamPointers.push_back(&(clone->C(i,j)));
// clone->ParamIndex.push_back(TinyVector<int,2>(i,j));
// #else
// clone->ParamPointers.push_back(&(clone->C(i,j).real()));
// clone->ParamPointers.push_back(&(clone->C(i,j).imag()));
// clone->ParamIndex.push_back(TinyVector<int,2>(i,j));
// clone->ParamIndex.push_back(TinyVector<int,2>(i,j));
// #endif
// }
// }
return clone;
}
} // namespace qmcplusplus

226
src/QMCWaveFunctions/OptimizableSPOSet.h
View File

@ -1,226 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////
// This file is distributed under the University of Illinois/NCSA Open Source License.
// See LICENSE file in top directory for details.
//
// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
//
// File developed by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
// Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
// Miguel Morales, moralessilva2@llnl.gov, Lawrence Livermore National Laboratory
// Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
// Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
//
// File created by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
//////////////////////////////////////////////////////////////////////////////////////
#ifndef OPTIMIZABLE_SPO_SET_H
#define OPTIMIZABLE_SPO_SET_H
#include "QMCWaveFunctions/SPOSet.h"
#include "Numerics/OptimizableFunctorBase.h"
#include "Optimize/VariableSet.h"
namespace qmcplusplus
{
class OptimizableSPOSet : public SPOSet
{
protected:
typedef optimize::VariableSet opt_variables_type;
///typedef for name-value lists
typedef optimize::VariableSet::variable_map_type variable_map_type;
// Number of occupied states, number of basis states
int N, M;
///number of basis
IndexType BasisSetSize;
/** pointer to matrix containing the coefficients
*
* makeClone makes a shallow copy
*/
ValueMatrix_t* C;
///if true, do not clean up
bool IsCloned;
RealType derivScale;
RealType thr;
// If BasisOrbitals==NULL, only GSOrbitals is used and it's evaluate
// functions should return N+M orbitals.
SPOSet *GSOrbitals, *BasisOrbitals;
// The first index is the orbital to be optimized, the second is the
// basis element
// ValueMatrix_t OptCoefs;
// This maps the parameter indices to elements in the C
// matrix. Using pointers allows the use of complex C
// while maintaining real optimizable parameters.
std::vector<RealType*> ParamPointers;
// Maps the parameter index in myVars to an index in the C array
std::vector<TinyVector<int, 2>> ParamIndex;
void addParameter(std::string id, int iorb, int basis);
ValueVector_t GSVal, BasisVal, GSLapl, BasisLapl;
GradVector_t GSGrad, BasisGrad;
ValueMatrix_t GSValMatrix, BasisValMatrix, GSLaplMatrix, BasisLaplMatrix, GradTmpSrc, GradTmpDest;
GradMatrix_t GSGradMatrix, BasisGradMatrix;
// Cache the positions to avoid recomputing GSVal, BasisVal, etc.
// if unnecessary.
std::vector<PosType> CachedPos;
public:
///set of variables to be optimized; These are mapped to the
///C matrix. Update: Moved to SPOSet
// opt_variables_type myVars;
// For each occupied orbital, this lists which of the M
// basis functions are used to construct the optimal orbital.
// This must be initialized by the SPOSet builder. If it is not
// initialized, we assume that C is fully dense.
// The first element of the TinyVector is the basis element
// number. The second is the corresponding parameter number.
std::vector<std::vector<TinyVector<int, 2>>> ActiveBasis;
OptimizableSPOSet() : N(0), M(0), derivScale(10.0), thr(0.0), GSOrbitals(0), BasisOrbitals(0)
{
Optimizable = true;
className = "OptimizableSPOSet";
}
OptimizableSPOSet(int num_orbs, SPOSet* gsOrbs, SPOSet* basisOrbs = 0)
: GSOrbitals(gsOrbs), BasisOrbitals(basisOrbs), derivScale(10.0)
{
N = num_orbs;
setOrbitalSetSize(N);
if (BasisOrbitals)
M = BasisOrbitals->getOrbitalSetSize();
else
M = GSOrbitals->getOrbitalSetSize() - N;
resize(N, M);
Optimizable = true;
}
// bool put(xmlNodePtr cur, SPOPool_t &spo_pool);
void resetTargetParticleSet(ParticleSet& P);
void setOrbitalSetSize(int norbs);
void set_active_basis(std::vector<std::vector<int>>& active)
{
//ActiveBasis = active;
}
// Read coefficients, or create the XML element.
bool put(xmlNodePtr node, SPOPool_t& spo_pool);
// This stores new orbital coefficients int C
void resetParameters(const opt_variables_type& optvars);
// Evaluate the derivative of the optimized orbitals with
// respect to the parameters
void evaluateDerivatives(ParticleSet& P,
int iat,
const opt_variables_type& active,
ValueMatrix_t& d_phi,
ValueMatrix_t& d_lapl_phi);
void checkInVariables(opt_variables_type& active);
void checkOutVariables(const opt_variables_type& active);
// Evaluate routines. These call GSOrbitals->evaluate and possibly
// BasisOrbitals->evaluate, then does the matrix product with
// C.
void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi);
void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi, GradVector_t& dpsi, ValueVector_t& d2psi);
void evaluate_notranspose(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& logdet,
GradMatrix_t& dlogdet,
ValueMatrix_t& d2logdet);
void evaluate_notranspose(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& logdet,
GradMatrix_t& dlogdet,
HessMatrix_t& grad_grad_logdet)
{
APP_ABORT("Need specialization of OptimizableOrbitalSet::evaluate_notranspose() for grad_grad_logdet. \n");
}
void evaluate_notranspose(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& logdet,
GradMatrix_t& dlogdet,
HessMatrix_t& grad_grad_logdet,
GGGMatrix_t& grad_grad_grad_logdet)
{
APP_ABORT("Need specialization of OptimazableOrbitalSet::evaluate_notranspose() for grad_grad_grad_logdet. \n");
}
void evaluateBasis(const ParticleSet& P,
int first,
int last,
ValueMatrix_t& basis_val,
GradMatrix_t& basis_grad,
ValueMatrix_t& basis_lapl);
void copyParamsFromMatrix(const opt_variables_type& active,
const Matrix<RealType>& mat,
std::vector<RealType>& destVec);
void copyParamsFromMatrix(const opt_variables_type& active,
const Matrix<ComplexType>& mat,
std::vector<RealType>& destVec);
void resize(int n, int m)
{
N = n;
M = m;
if (BasisOrbitals)
{
GSVal.resize(N);
GSGrad.resize(N);
GSLapl.resize(N);
BasisVal.resize(M);
BasisGrad.resize(M);
BasisLapl.resize(M);
GSValMatrix.resize(N, N);
GSGradMatrix.resize(N, N);
GSLaplMatrix.resize(N, N);
BasisValMatrix.resize(M, N);
BasisGradMatrix.resize(M, N);
BasisLaplMatrix.resize(M, N);
}
else
{
GSVal.resize(N + M);
GSGrad.resize(N + M);
GSLapl.resize(N + M);
GSValMatrix.resize(N, N + M);
GSGradMatrix.resize(N, N + M);
GSLaplMatrix.resize(N, N + M);
}
GradTmpSrc.resize(M, N);
GradTmpDest.resize(N, N);
if (C == nullptr)
C = new ValueMatrix_t(N, M);
else
C->resize(N, M);
ActiveBasis.resize(N);
BasisSetSize = M;
}
// Make a copy of myself
SPOSet* makeClone() const;
};
} // namespace qmcplusplus
#endif

7
src/QMCWaveFunctions/SPOSet.cpp
View File

@ -26,11 +26,10 @@
namespace qmcplusplus namespace qmcplusplus
{ {
SPOSet::SPOSet() SPOSet::SPOSet(bool ion_deriv, bool optimizable)
: OrbitalSetSize(0), : OrbitalSetSize(0),
Optimizable(false), ionDerivs(ion_deriv),
ionDerivs(false), Optimizable(optimizable)
builder_index(-1)
#if !defined(ENABLE_SOA) #if !defined(ENABLE_SOA)
, ,
Identity(false), Identity(false),

27
src/QMCWaveFunctions/SPOSet.h
View File

@ -62,16 +62,6 @@ public:
typedef ParticleSet::Walker_t Walker_t; typedef ParticleSet::Walker_t Walker_t;
typedef std::map<std::string, SPOSet*> SPOPool_t; typedef std::map<std::string, SPOSet*> SPOPool_t;
///index in the builder list of sposets
int builder_index;
///true if SPO is optimizable
bool Optimizable;
///number of Single-particle orbitals
IndexType OrbitalSetSize;
/// Optimizable variables
opt_variables_type myVars;
///name of the class
std::string className;
/** name of the object /** name of the object
* *
* Several user classes can own SPOSet and use objectName as counter * Several user classes can own SPOSet and use objectName as counter
@ -96,7 +86,7 @@ public:
#endif #endif
/** constructor */ /** constructor */
SPOSet(); SPOSet(bool ion_deriv = false, bool optimizable = false);
/** destructor /** destructor
* *
@ -110,6 +100,9 @@ public:
#endif #endif
} }
// accessor function to Optimizable
inline bool isOptimizable() const { return Optimizable; }
/** return the size of the orbital set /** return the size of the orbital set
* Ye: this needs to be replaced by getOrbitalSetSize(); * Ye: this needs to be replaced by getOrbitalSetSize();
*/ */
@ -472,8 +465,18 @@ protected:
bool putFromXML(xmlNodePtr coeff_ptr); bool putFromXML(xmlNodePtr coeff_ptr);
bool putFromH5(const std::string& fname, xmlNodePtr coeff_ptr); bool putFromH5(const std::string& fname, xmlNodePtr coeff_ptr);
#endif #endif
protected:
///true, if the derived class has non-zero ionic derivatives. ///true, if the derived class has non-zero ionic derivatives.
bool ionDerivs; const bool ionDerivs;
///true if SPO is optimizable
const bool Optimizable;
///number of Single-particle orbitals
IndexType OrbitalSetSize;
/// Optimizable variables
opt_variables_type myVars;
///name of the class
std::string className;
}; };
#if defined(ENABLE_SMARTPOINTER) #if defined(ENABLE_SMARTPOINTER)

1
src/QMCWaveFunctions/SPOSetBuilder.cpp
View File

@ -53,7 +53,6 @@ SPOSet* SPOSetBuilder::createSPOSet(xmlNodePtr cur)
if (sposet) if (sposet)
{ {
//sposet->put(cur); //initialize C and other internal containers //sposet->put(cur); //initialize C and other internal containers
sposet->builder_index = sposets.size();
sposets.push_back(sposet); sposets.push_back(sposet);
} }
else else

6
src/QMCWaveFunctions/SPOSetBuilderFactory.cpp
View File

@ -36,7 +36,6 @@
#endif #endif
#endif #endif
#include "QMCWaveFunctions/CompositeSPOSet.h" #include "QMCWaveFunctions/CompositeSPOSet.h"
#include "QMCWaveFunctions/OptimizableSPOBuilder.h"
#include "Utilities/ProgressReportEngine.h" #include "Utilities/ProgressReportEngine.h"
#include "Utilities/IteratorUtility.h" #include "Utilities/IteratorUtility.h"
#include "OhmmsData/AttributeSet.h" #include "OhmmsData/AttributeSet.h"
@ -181,11 +180,6 @@ SPOSetBuilder* SPOSetBuilderFactory::createSPOSetBuilder(xmlNodePtr rootNode)
app_log() << "Harmonic Oscillator SPO set" << std::endl; app_log() << "Harmonic Oscillator SPO set" << std::endl;
bb = new SHOSetBuilder(targetPtcl, myComm); bb = new SHOSetBuilder(targetPtcl, myComm);
} }
else if (type == "linearopt")
{
//app_log()<<"Optimizable SPO set"<< std::endl;
bb = new OptimizableSPOBuilder(targetPtcl, ptclPool, myComm, rootNode);
}
#if OHMMS_DIM == 3 #if OHMMS_DIM == 3
else if (type.find("spline") < type.size()) else if (type.find("spline") < type.size())
{ {

8
src/QMCWaveFunctions/lcao/CuspCorrection.cpp
View File

@ -163,8 +163,8 @@ void splitPhiEta(int center, const std::vector<bool>& corrCenter, LCAOrbitalSet&
Phi.myBasisSet->queryOrbitalsForSType(correct_this_center, is_s_orbital); Phi.myBasisSet->queryOrbitalsForSType(correct_this_center, is_s_orbital);
int nOrbs = Phi.OrbitalSetSize; int nOrbs = Phi.getOrbitalSetSize();
int bss = Phi.BasisSetSize; int bss = Phi.getBasisSetSize();
for (int i = 0; i < bss; i++) for (int i = 0; i < bss; i++)
{ {
@ -191,8 +191,8 @@ void removeSTypeOrbitals(const std::vector<bool>& corrCenter, LCAOrbitalSet& Phi
Phi.myBasisSet->queryOrbitalsForSType(corrCenter, is_s_orbital); Phi.myBasisSet->queryOrbitalsForSType(corrCenter, is_s_orbital);
int nOrbs = Phi.OrbitalSetSize; int nOrbs = Phi.getOrbitalSetSize();
int bss = Phi.BasisSetSize; int bss = Phi.getBasisSetSize();
for (int i = 0; i < bss; i++) for (int i = 0; i < bss; i++)
{ {

2
src/QMCWaveFunctions/lcao/CuspCorrection.h
View File

@ -114,7 +114,7 @@ public:
: targetPtcl(targetP), sourcePtcl(sourceP), curOrb(0), curCenter(0) : targetPtcl(targetP), sourcePtcl(sourceP), curOrb(0), curCenter(0)
{ {
Psi1 = Phi; Psi1 = Phi;
int norb = Psi1->OrbitalSetSize; int norb = Psi1->getOrbitalSetSize();
val1.resize(norb); val1.resize(norb);
grad1.resize(norb); grad1.resize(norb);
lap1.resize(norb); lap1.resize(norb);

24
src/QMCWaveFunctions/lcao/CuspCorrectionConstruction.cpp
View File

@ -33,14 +33,14 @@ void applyCuspCorrection(const Matrix<CuspCorrectionParameters>& info,
ScopedTimer cuspApplyTimerWrapper(cuspApplyTimer); ScopedTimer cuspApplyTimerWrapper(cuspApplyTimer);
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet); LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
phi.setOrbitalSetSize(lcwc.OrbitalSetSize); phi.setOrbitalSetSize(lcwc.getOrbitalSetSize());
phi.BasisSetSize = lcwc.BasisSetSize; phi.BasisSetSize = lcwc.getBasisSetSize();
phi.setIdentity(false); phi.setIdentity(false);
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet); LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
eta.setOrbitalSetSize(lcwc.OrbitalSetSize); eta.setOrbitalSetSize(lcwc.getOrbitalSetSize());
eta.BasisSetSize = lcwc.BasisSetSize; eta.BasisSetSize = lcwc.getBasisSetSize();
eta.setIdentity(false); eta.setIdentity(false);
@ -201,14 +201,14 @@ void generateCuspInfo(int orbital_set_size,
ScopedTimer createCuspTimerWrapper(cuspCreateTimer); ScopedTimer createCuspTimerWrapper(cuspCreateTimer);
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet); LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
phi.setOrbitalSetSize(lcwc.OrbitalSetSize); phi.setOrbitalSetSize(lcwc.getOrbitalSetSize());
phi.BasisSetSize = lcwc.BasisSetSize; phi.BasisSetSize = lcwc.getBasisSetSize();
phi.setIdentity(false); phi.setIdentity(false);
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet); LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
eta.setOrbitalSetSize(lcwc.OrbitalSetSize); eta.setOrbitalSetSize(lcwc.getOrbitalSetSize());
eta.BasisSetSize = lcwc.BasisSetSize; eta.BasisSetSize = lcwc.getBasisSetSize();
eta.setIdentity(false); eta.setIdentity(false);

18
src/QMCWaveFunctions/lcao/LCAOrbitalBuilder.cpp
View File

@ -443,15 +443,19 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
if (myBasisSet == nullptr) if (myBasisSet == nullptr)
PRE.error("Missing basisset.", true); PRE.error("Missing basisset.", true);
if (optimize == "yes")
app_log() << " SPOSet " << spo_name << " is optimizable\n";
LCAOrbitalSet* lcos = nullptr; LCAOrbitalSet* lcos = nullptr;
#if !defined(QMC_COMPLEX) #if !defined(QMC_COMPLEX)
LCAOrbitalSetWithCorrection* lcwc = nullptr; LCAOrbitalSetWithCorrection* lcwc = nullptr;
if (doCuspCorrection) if (doCuspCorrection)
lcos = lcwc = new LCAOrbitalSetWithCorrection(sourcePtcl, targetPtcl, myBasisSet); lcos = lcwc = new LCAOrbitalSetWithCorrection(sourcePtcl, targetPtcl, myBasisSet, optimize == "yes");
else else
lcos = new LCAOrbitalSet(myBasisSet); lcos = new LCAOrbitalSet(myBasisSet, optimize == "yes");
#else #else
lcos = new LCAOrbitalSet(myBasisSet); lcos = new LCAOrbitalSet(myBasisSet, optimize == "yes");
#endif #endif
loadMO(*lcos, cur); loadMO(*lcos, cur);
@ -464,7 +468,7 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
if (id == "") if (id == "")
id = spo_name; id = spo_name;
int orbital_set_size = lcos->OrbitalSetSize; int orbital_set_size = lcos->getOrbitalSetSize();
Matrix<CuspCorrectionParameters> info(num_centers, orbital_set_size); Matrix<CuspCorrectionParameters> info(num_centers, orbital_set_size);
bool valid = false; bool valid = false;
@ -494,12 +498,6 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
} }
#endif #endif
if (optimize == "yes")
{
lcos->Optimizable = true;
app_log() << " SPOSet " << spo_name << " is optimizable\n";
}
return lcos; return lcos;
} }

6
src/QMCWaveFunctions/lcao/LCAOrbitalSet.cpp
View File

@ -16,11 +16,9 @@
namespace qmcplusplus namespace qmcplusplus
{ {
LCAOrbitalSet::LCAOrbitalSet(basis_type* bs) LCAOrbitalSet::LCAOrbitalSet(basis_type* bs, bool optimize)
: myBasisSet(nullptr), params_supplied(false), BasisSetSize(0), Identity(true) : SPOSet(true, optimize), myBasisSet(nullptr), params_supplied(false), BasisSetSize(0), Identity(true)
{ {
//This SPOSet has an explicit ion dependence, so set this flag.
ionDerivs=true;
if (bs != nullptr) if (bs != nullptr)
setBasisSet(bs); setBasisSet(bs);
} }

8
src/QMCWaveFunctions/lcao/LCAOrbitalSet.h
View File

@ -73,7 +73,7 @@ public:
/** constructor /** constructor
* @param bs pointer to the BasisSet * @param bs pointer to the BasisSet
*/ */
LCAOrbitalSet(basis_type* bs = nullptr); LCAOrbitalSet(basis_type* bs, bool optimize);
LCAOrbitalSet(const LCAOrbitalSet& in) = default; LCAOrbitalSet(const LCAOrbitalSet& in) = default;
@ -109,16 +109,11 @@ public:
const size_t NP2, const size_t NP2,
const std::vector<std::vector<int>>& lookup_tbl); const std::vector<std::vector<int>>& lookup_tbl);
void checkInVariables(opt_variables_type& active) void checkInVariables(opt_variables_type& active)
{ {
if (Optimizable) if (Optimizable)
{
if (myVars.size()) if (myVars.size())
active.insertFrom(myVars); active.insertFrom(myVars);
else
Optimizable = false;
}
} }
void checkOutVariables(const opt_variables_type& active) void checkOutVariables(const opt_variables_type& active)
@ -127,7 +122,6 @@ public:
myVars.getIndex(active); myVars.getIndex(active);
} }
///reset ///reset
void resetParameters(const opt_variables_type& active) void resetParameters(const opt_variables_type& active)
{ {

4
src/QMCWaveFunctions/lcao/LCAOrbitalSetWithCorrection.cpp
View File

@ -15,8 +15,8 @@
namespace qmcplusplus namespace qmcplusplus
{ {
LCAOrbitalSetWithCorrection::LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs) LCAOrbitalSetWithCorrection::LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs, bool optimize)
: LCAOrbitalSet(bs), cusp(ions, els) : LCAOrbitalSet(bs, optimize), cusp(ions, els)
{} {}
void LCAOrbitalSetWithCorrection::setOrbitalSetSize(int norbs) void LCAOrbitalSetWithCorrection::setOrbitalSetSize(int norbs)

2
src/QMCWaveFunctions/lcao/LCAOrbitalSetWithCorrection.h
View File

@ -34,7 +34,7 @@ struct LCAOrbitalSetWithCorrection : public LCAOrbitalSet
* @param bs pointer to the BasisSet * @param bs pointer to the BasisSet
* @param rl report level * @param rl report level
*/ */
LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs = nullptr); LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs, bool optimize);
LCAOrbitalSetWithCorrection(const LCAOrbitalSetWithCorrection& in) = default; LCAOrbitalSetWithCorrection(const LCAOrbitalSetWithCorrection& in) = default;

4
src/QMCWaveFunctions/tests/test_cusp_corr.cpp
View File

@ -108,14 +108,14 @@ TEST_CASE("CuspCorrection He", "[wavefunction]")
typedef NGOBuilder::CenteredOrbitalType COT; typedef NGOBuilder::CenteredOrbitalType COT;
OrbType bs_phi(lcob->myBasisSet); OrbType bs_phi(lcob->myBasisSet);
bs_phi.setOrbitalSetSize(lcob->OrbitalSetSize); bs_phi.setOrbitalSetSize(lcob->getOrbitalSetSize());
bs_phi.BasisSetSize = lcob->BasisSetSize; bs_phi.BasisSetSize = lcob->BasisSetSize;
bs_phi.setIdentity(false); bs_phi.setIdentity(false);
*(bs_phi.C) = *(lcob->C); *(bs_phi.C) = *(lcob->C);
OrbType bs_eta(lcob->myBasisSet); OrbType bs_eta(lcob->myBasisSet);
bs_eta.setOrbitalSetSize(lcob->OrbitalSetSize); bs_eta.setOrbitalSetSize(lcob->getOrbitalSetSize());
bs_eta.BasisSetSize = lcob->BasisSetSize; bs_eta.BasisSetSize = lcob->BasisSetSize;
bs_eta.setIdentity(false); bs_eta.setIdentity(false);
*(bs_eta.C) = *(lcob->C); *(bs_eta.C) = *(lcob->C);

12
src/QMCWaveFunctions/tests/test_soa_cusp_corr.cpp
View File

@ -129,14 +129,14 @@ TEST_CASE("applyCuspInfo", "[wavefunction]")
REQUIRE(lcob != NULL); REQUIRE(lcob != NULL);
LCAOrbitalSet phi = LCAOrbitalSet(lcob->myBasisSet); LCAOrbitalSet phi = LCAOrbitalSet(lcob->myBasisSet, lcob->isOptimizable());
phi.setOrbitalSetSize(lcob->OrbitalSetSize); phi.setOrbitalSetSize(lcob->getOrbitalSetSize());
phi.BasisSetSize = lcob->BasisSetSize; phi.BasisSetSize = lcob->getBasisSetSize();
phi.setIdentity(false); phi.setIdentity(false);
LCAOrbitalSet eta = LCAOrbitalSet(lcob->myBasisSet); LCAOrbitalSet eta = LCAOrbitalSet(lcob->myBasisSet, lcob->isOptimizable());
eta.setOrbitalSetSize(lcob->OrbitalSetSize); eta.setOrbitalSetSize(lcob->getOrbitalSetSize());
eta.BasisSetSize = lcob->BasisSetSize; eta.BasisSetSize = lcob->getBasisSetSize();
eta.setIdentity(false); eta.setIdentity(false);
*(eta.C) = *(lcob->C); *(eta.C) = *(lcob->C);

6
tests/molecules/He_ae/CMakeLists.txt
View File

@ -1,6 +1,8 @@
# Deterministic test for QMC optimizer # Deterministic test for QMC optimizer
IF (NOT MIXED_PRECISION) IF (MIXED_PRECISION OR (QMC_COMPLEX AND NOT ENABLE_SOA))
MESSAGE_VERBOSE("Skipping optimizer deterministic He tests in mixed precision (QMC_MIXED_PRECISION=1) or complex with aos (QMC_COMPLEX=1 and ENABLE_SOA=0)")
ELSE()
SIMPLE_RUN_AND_CHECK( SIMPLE_RUN_AND_CHECK(
deterministic-He_ae-opt deterministic-He_ae-opt
"${CMAKE_SOURCE_DIR}/tests/molecules/He_ae" "${CMAKE_SOURCE_DIR}/tests/molecules/He_ae"
@ -19,7 +21,5 @@ IF (NOT MIXED_PRECISION)
TRUE TRUE
2 He_VMC_SCALARS # VMC 2 He_VMC_SCALARS # VMC
) )
ELSE()
MESSAGE_VERBOSE("Skipping optimizer deterministic tests in mixed precision (QMC_MIXED_PRECISION=1)")
ENDIF() ENDIF()