mirror of https://github.com/QMCPACK/qmcpack.git
Merge pull request #1960 from ye-luo/protect-SPOSet
Move some SPOSet members under protected and remove OptimizableSPOSet
This commit is contained in:
commit
b515371dca
|
@ -28,7 +28,6 @@ SET(WFBASE_SRCS
|
|||
SPOSetInfo.cpp
|
||||
SPOSetInputInfo.cpp
|
||||
SPOSet.cpp
|
||||
OptimizableSPOSet.cpp
|
||||
CompositeSPOSet.cpp
|
||||
HarmonicOscillator/SHOSet.cpp
|
||||
HarmonicOscillator/SHOSetBuilder.cpp
|
||||
|
@ -56,7 +55,6 @@ SET(JASTROW_SRCS
|
|||
Jastrow/RPAJastrow.cpp
|
||||
LatticeGaussianProduct.cpp
|
||||
LatticeGaussianProductBuilder.cpp
|
||||
OptimizableSPOBuilder.cpp
|
||||
Fermion/SPOSetProxy.cpp
|
||||
Fermion/SPOSetProxyForMSD.cpp
|
||||
)
|
||||
|
|
|
@ -43,9 +43,9 @@ public:
|
|||
SPOVTimer(*TimerManager.createTimer("DiracDeterminantBase::spoval", timer_level_fine)),
|
||||
SPOVGLTimer(*TimerManager.createTimer("DiracDeterminantBase::spovgl", timer_level_fine))
|
||||
{
|
||||
Optimizable = Phi->Optimizable;
|
||||
Optimizable = Phi->isOptimizable();
|
||||
is_fermionic = true;
|
||||
ClassName = "DiracDeterminantBase";
|
||||
ClassName = "DiracDeterminantBase";
|
||||
registerTimers();
|
||||
}
|
||||
|
||||
|
@ -76,26 +76,16 @@ public:
|
|||
virtual inline void checkInVariables(opt_variables_type& active) override
|
||||
{
|
||||
Phi->checkInVariables(active);
|
||||
Phi->checkInVariables(myVars);
|
||||
}
|
||||
|
||||
virtual inline void checkOutVariables(const opt_variables_type& active) override
|
||||
{
|
||||
Phi->checkOutVariables(active);
|
||||
myVars.clear();
|
||||
myVars.insertFrom(Phi->myVars);
|
||||
myVars.getIndex(active);
|
||||
}
|
||||
|
||||
virtual void resetParameters(const opt_variables_type& active) override
|
||||
{
|
||||
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
|
||||
|
|
|
@ -392,7 +392,7 @@ MultiDiracDeterminant::MultiDiracDeterminant(SPOSetPtr const& spos, int first)
|
|||
buildTableGradTimer(*TimerManager.createTimer("MultiDiracDeterminant::buildTableGrad")),
|
||||
ExtraStuffTimer(*TimerManager.createTimer("MultiDiracDeterminant::ExtraStuff"))
|
||||
{
|
||||
(spos->Optimizable == true) ? Optimizable = true : Optimizable = false;
|
||||
(spos->isOptimizable() == true) ? Optimizable = true : Optimizable = false;
|
||||
ClassName = "MultiDiracDeterminant";
|
||||
|
||||
IsCloned = false;
|
||||
|
|
|
@ -589,7 +589,7 @@ bool SlaterDetBuilder::putDeterminant(xmlNodePtr cur, int spin_group)
|
|||
targetPsi.setndelay(delay_rank);
|
||||
#endif
|
||||
slaterdet_0->add(adet, spin_group);
|
||||
if (psi->Optimizable)
|
||||
if (psi->isOptimizable())
|
||||
slaterdet_0->Optimizable = true;
|
||||
|
||||
app_log() << std::endl;
|
||||
|
|
|
@ -46,8 +46,8 @@ SlaterDetOpt::SlaterDetOpt(ParticleSet& ptcl, SPOSet* spo_ptr, const int up_or_d
|
|||
|
||||
resize(m_nel, m_nmo);
|
||||
|
||||
m_nlc = Phi->OrbitalSetSize;
|
||||
m_nb = Phi->BasisSetSize;
|
||||
m_nlc = Phi->getOrbitalSetSize();
|
||||
m_nb = Phi->getBasisSetSize();
|
||||
|
||||
// make sure we didn't start with a bad m_nlc
|
||||
check_index_sanity();
|
||||
|
|
|
@ -25,7 +25,7 @@ void fillRadFunWithPhiBar(int curOrb_,
|
|||
{
|
||||
Psi1 = Phi;
|
||||
Psi2 = Eta;
|
||||
int norb = Psi1->OrbitalSetSize;
|
||||
int norb = Psi1->getOrbitalSetSize();
|
||||
curOrb = curOrb_;
|
||||
curCenter = curCenter_;
|
||||
|
||||
|
@ -56,7 +56,7 @@ void fillRadFunWithPhi(int curOrb_,
|
|||
{
|
||||
Psi1 = Phi;
|
||||
Psi2 = Eta;
|
||||
int norb = Psi1->OrbitalSetSize;
|
||||
int norb = Psi1->getOrbitalSetSize();
|
||||
curOrb = curOrb_;
|
||||
curCenter = curCenter_;
|
||||
Z = Zion;
|
||||
|
@ -177,7 +177,7 @@ RealType execute(int curOrb_,
|
|||
bool writeout = (thisFile != "NULL");
|
||||
Psi1 = Phi;
|
||||
Psi2 = Eta;
|
||||
int norb = Psi1->OrbitalSetSize;
|
||||
int norb = Psi1->getOrbitalSetSize();
|
||||
ValueVector_t X(5);
|
||||
curOrb = curOrb_;
|
||||
curCenter = curCenter_;
|
||||
|
|
|
@ -104,7 +104,7 @@ public:
|
|||
{
|
||||
Psi1 = Phi;
|
||||
Psi2 = Eta;
|
||||
int norb = Psi1->OrbitalSetSize;
|
||||
int norb = Psi1->getOrbitalSetSize();
|
||||
|
||||
val1.resize(norb);
|
||||
grad1.resize(norb);
|
||||
|
|
|
@ -274,7 +274,7 @@ public:
|
|||
this->setBasisSet(bs);
|
||||
|
||||
// initialize number of molecular orbitals as zero
|
||||
this->OrbitalSetSize = 0;
|
||||
setOrbitalSetSize(0);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
@ -291,7 +291,7 @@ public:
|
|||
this->setSPOSet(spo);
|
||||
|
||||
// initialize number of molecular orbitals as zero
|
||||
this->OrbitalSetSize = 0;
|
||||
setOrbitalSetSize(0);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
@ -358,7 +358,7 @@ public:
|
|||
m_spo_set = spo;
|
||||
|
||||
// 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->C = C;
|
||||
retval->setOrbitalSetSize(this->OrbitalSetSize);
|
||||
retval->setOrbitalSetSize(OrbitalSetSize);
|
||||
retval->init_LCOrbitalSetOpt(0.0);
|
||||
|
||||
retval->m_B = m_B;
|
||||
|
@ -429,7 +429,7 @@ public:
|
|||
void setOrbitalSetSize(int norbs)
|
||||
{
|
||||
// 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;
|
||||
}
|
||||
|
||||
|
@ -698,7 +698,7 @@ public:
|
|||
//app_log() << "this->OrbitalSetSize = " << this->OrbitalSetSize << std::endl;
|
||||
// check sanity
|
||||
this->check_input_dim("logdet # of columns", "LCOrbitalSetOpt::evaluate_notranspose", logdet.cols(),
|
||||
this->OrbitalSetSize);
|
||||
OrbitalSetSize);
|
||||
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 "
|
||||
"LCOrbitalSetOpt::evaluate_notranspose");
|
||||
|
@ -724,7 +724,7 @@ public:
|
|||
inline void evaluate(const ParticleSet& P, int iat, ValueVector_t& psi)
|
||||
{
|
||||
// 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
|
||||
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)
|
||||
{
|
||||
// check sanity
|
||||
this->check_input_dim("d2psi", "LCOrbitalSetOpt::evaluate", d2psi.size(), this->OrbitalSetSize);
|
||||
this->check_input_dim("dpsi", "LCOrbitalSetOpt::evaluate", dpsi.size(), this->OrbitalSetSize);
|
||||
this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), this->OrbitalSetSize);
|
||||
this->check_input_dim("d2psi", "LCOrbitalSetOpt::evaluate", d2psi.size(), OrbitalSetSize);
|
||||
this->check_input_dim("dpsi", "LCOrbitalSetOpt::evaluate", dpsi.size(), OrbitalSetSize);
|
||||
this->check_input_dim("psi", "LCOrbitalSetOpt::evaluate", psi.size(), OrbitalSetSize);
|
||||
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");
|
||||
|
||||
|
|
|
@ -192,7 +192,6 @@ LCOrbitalSet<BS, false>* LCOrbitalSetWithCorrection<BS, false>::clone2LCOrbitalS
|
|||
newSPO->C = C;
|
||||
newSPO->Occ.resize(Occ.size());
|
||||
newSPO->Occ = Occ;
|
||||
newSPO->className = "LCOrbitalSet";
|
||||
return newSPO;
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
|
@ -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
|
|
@ -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
|
|
@ -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
|
|
@ -26,11 +26,10 @@
|
|||
|
||||
namespace qmcplusplus
|
||||
{
|
||||
SPOSet::SPOSet()
|
||||
SPOSet::SPOSet(bool ion_deriv, bool optimizable)
|
||||
: OrbitalSetSize(0),
|
||||
Optimizable(false),
|
||||
ionDerivs(false),
|
||||
builder_index(-1)
|
||||
ionDerivs(ion_deriv),
|
||||
Optimizable(optimizable)
|
||||
#if !defined(ENABLE_SOA)
|
||||
,
|
||||
Identity(false),
|
||||
|
|
|
@ -62,16 +62,6 @@ public:
|
|||
typedef ParticleSet::Walker_t Walker_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
|
||||
*
|
||||
* Several user classes can own SPOSet and use objectName as counter
|
||||
|
@ -96,7 +86,7 @@ public:
|
|||
#endif
|
||||
|
||||
/** constructor */
|
||||
SPOSet();
|
||||
SPOSet(bool ion_deriv = false, bool optimizable = false);
|
||||
|
||||
/** destructor
|
||||
*
|
||||
|
@ -110,6 +100,9 @@ public:
|
|||
#endif
|
||||
}
|
||||
|
||||
// accessor function to Optimizable
|
||||
inline bool isOptimizable() const { return Optimizable; }
|
||||
|
||||
/** return the size of the orbital set
|
||||
* Ye: this needs to be replaced by getOrbitalSetSize();
|
||||
*/
|
||||
|
@ -472,8 +465,18 @@ protected:
|
|||
bool putFromXML(xmlNodePtr coeff_ptr);
|
||||
bool putFromH5(const std::string& fname, xmlNodePtr coeff_ptr);
|
||||
#endif
|
||||
|
||||
protected:
|
||||
///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)
|
||||
|
|
|
@ -53,7 +53,6 @@ SPOSet* SPOSetBuilder::createSPOSet(xmlNodePtr cur)
|
|||
if (sposet)
|
||||
{
|
||||
//sposet->put(cur); //initialize C and other internal containers
|
||||
sposet->builder_index = sposets.size();
|
||||
sposets.push_back(sposet);
|
||||
}
|
||||
else
|
||||
|
|
|
@ -36,7 +36,6 @@
|
|||
#endif
|
||||
#endif
|
||||
#include "QMCWaveFunctions/CompositeSPOSet.h"
|
||||
#include "QMCWaveFunctions/OptimizableSPOBuilder.h"
|
||||
#include "Utilities/ProgressReportEngine.h"
|
||||
#include "Utilities/IteratorUtility.h"
|
||||
#include "OhmmsData/AttributeSet.h"
|
||||
|
@ -181,11 +180,6 @@ SPOSetBuilder* SPOSetBuilderFactory::createSPOSetBuilder(xmlNodePtr rootNode)
|
|||
app_log() << "Harmonic Oscillator SPO set" << std::endl;
|
||||
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
|
||||
else if (type.find("spline") < type.size())
|
||||
{
|
||||
|
|
|
@ -163,8 +163,8 @@ void splitPhiEta(int center, const std::vector<bool>& corrCenter, LCAOrbitalSet&
|
|||
|
||||
Phi.myBasisSet->queryOrbitalsForSType(correct_this_center, is_s_orbital);
|
||||
|
||||
int nOrbs = Phi.OrbitalSetSize;
|
||||
int bss = Phi.BasisSetSize;
|
||||
int nOrbs = Phi.getOrbitalSetSize();
|
||||
int bss = Phi.getBasisSetSize();
|
||||
|
||||
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);
|
||||
|
||||
int nOrbs = Phi.OrbitalSetSize;
|
||||
int bss = Phi.BasisSetSize;
|
||||
int nOrbs = Phi.getOrbitalSetSize();
|
||||
int bss = Phi.getBasisSetSize();
|
||||
|
||||
for (int i = 0; i < bss; i++)
|
||||
{
|
||||
|
|
|
@ -114,7 +114,7 @@ public:
|
|||
: targetPtcl(targetP), sourcePtcl(sourceP), curOrb(0), curCenter(0)
|
||||
{
|
||||
Psi1 = Phi;
|
||||
int norb = Psi1->OrbitalSetSize;
|
||||
int norb = Psi1->getOrbitalSetSize();
|
||||
val1.resize(norb);
|
||||
grad1.resize(norb);
|
||||
lap1.resize(norb);
|
||||
|
|
|
@ -33,14 +33,14 @@ void applyCuspCorrection(const Matrix<CuspCorrectionParameters>& info,
|
|||
|
||||
ScopedTimer cuspApplyTimerWrapper(cuspApplyTimer);
|
||||
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet);
|
||||
phi.setOrbitalSetSize(lcwc.OrbitalSetSize);
|
||||
phi.BasisSetSize = lcwc.BasisSetSize;
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
|
||||
phi.setOrbitalSetSize(lcwc.getOrbitalSetSize());
|
||||
phi.BasisSetSize = lcwc.getBasisSetSize();
|
||||
phi.setIdentity(false);
|
||||
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet);
|
||||
eta.setOrbitalSetSize(lcwc.OrbitalSetSize);
|
||||
eta.BasisSetSize = lcwc.BasisSetSize;
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
|
||||
eta.setOrbitalSetSize(lcwc.getOrbitalSetSize());
|
||||
eta.BasisSetSize = lcwc.getBasisSetSize();
|
||||
eta.setIdentity(false);
|
||||
|
||||
|
||||
|
@ -201,14 +201,14 @@ void generateCuspInfo(int orbital_set_size,
|
|||
|
||||
ScopedTimer createCuspTimerWrapper(cuspCreateTimer);
|
||||
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet);
|
||||
phi.setOrbitalSetSize(lcwc.OrbitalSetSize);
|
||||
phi.BasisSetSize = lcwc.BasisSetSize;
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
|
||||
phi.setOrbitalSetSize(lcwc.getOrbitalSetSize());
|
||||
phi.BasisSetSize = lcwc.getBasisSetSize();
|
||||
phi.setIdentity(false);
|
||||
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet);
|
||||
eta.setOrbitalSetSize(lcwc.OrbitalSetSize);
|
||||
eta.BasisSetSize = lcwc.BasisSetSize;
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcwc.myBasisSet, lcwc.isOptimizable());
|
||||
eta.setOrbitalSetSize(lcwc.getOrbitalSetSize());
|
||||
eta.BasisSetSize = lcwc.getBasisSetSize();
|
||||
eta.setIdentity(false);
|
||||
|
||||
|
||||
|
|
|
@ -443,15 +443,19 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
|
|||
|
||||
if (myBasisSet == nullptr)
|
||||
PRE.error("Missing basisset.", true);
|
||||
|
||||
if (optimize == "yes")
|
||||
app_log() << " SPOSet " << spo_name << " is optimizable\n";
|
||||
|
||||
LCAOrbitalSet* lcos = nullptr;
|
||||
#if !defined(QMC_COMPLEX)
|
||||
LCAOrbitalSetWithCorrection* lcwc = nullptr;
|
||||
if (doCuspCorrection)
|
||||
lcos = lcwc = new LCAOrbitalSetWithCorrection(sourcePtcl, targetPtcl, myBasisSet);
|
||||
lcos = lcwc = new LCAOrbitalSetWithCorrection(sourcePtcl, targetPtcl, myBasisSet, optimize == "yes");
|
||||
else
|
||||
lcos = new LCAOrbitalSet(myBasisSet);
|
||||
lcos = new LCAOrbitalSet(myBasisSet, optimize == "yes");
|
||||
#else
|
||||
lcos = new LCAOrbitalSet(myBasisSet);
|
||||
lcos = new LCAOrbitalSet(myBasisSet, optimize == "yes");
|
||||
#endif
|
||||
loadMO(*lcos, cur);
|
||||
|
||||
|
@ -464,7 +468,7 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
|
|||
if (id == "")
|
||||
id = spo_name;
|
||||
|
||||
int orbital_set_size = lcos->OrbitalSetSize;
|
||||
int orbital_set_size = lcos->getOrbitalSetSize();
|
||||
Matrix<CuspCorrectionParameters> info(num_centers, orbital_set_size);
|
||||
|
||||
bool valid = false;
|
||||
|
@ -494,12 +498,6 @@ SPOSet* LCAOrbitalBuilder::createSPOSetFromXML(xmlNodePtr cur)
|
|||
}
|
||||
#endif
|
||||
|
||||
if (optimize == "yes")
|
||||
{
|
||||
lcos->Optimizable = true;
|
||||
app_log() << " SPOSet " << spo_name << " is optimizable\n";
|
||||
}
|
||||
|
||||
return lcos;
|
||||
}
|
||||
|
||||
|
|
|
@ -16,11 +16,9 @@
|
|||
|
||||
namespace qmcplusplus
|
||||
{
|
||||
LCAOrbitalSet::LCAOrbitalSet(basis_type* bs)
|
||||
: myBasisSet(nullptr), params_supplied(false), BasisSetSize(0), Identity(true)
|
||||
LCAOrbitalSet::LCAOrbitalSet(basis_type* bs, bool optimize)
|
||||
: 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)
|
||||
setBasisSet(bs);
|
||||
}
|
||||
|
|
|
@ -73,7 +73,7 @@ public:
|
|||
/** constructor
|
||||
* @param bs pointer to the BasisSet
|
||||
*/
|
||||
LCAOrbitalSet(basis_type* bs = nullptr);
|
||||
LCAOrbitalSet(basis_type* bs, bool optimize);
|
||||
|
||||
LCAOrbitalSet(const LCAOrbitalSet& in) = default;
|
||||
|
||||
|
@ -109,16 +109,11 @@ public:
|
|||
const size_t NP2,
|
||||
const std::vector<std::vector<int>>& lookup_tbl);
|
||||
|
||||
|
||||
void checkInVariables(opt_variables_type& active)
|
||||
{
|
||||
if (Optimizable)
|
||||
{
|
||||
if (myVars.size())
|
||||
active.insertFrom(myVars);
|
||||
else
|
||||
Optimizable = false;
|
||||
}
|
||||
}
|
||||
|
||||
void checkOutVariables(const opt_variables_type& active)
|
||||
|
@ -127,7 +122,6 @@ public:
|
|||
myVars.getIndex(active);
|
||||
}
|
||||
|
||||
|
||||
///reset
|
||||
void resetParameters(const opt_variables_type& active)
|
||||
{
|
||||
|
|
|
@ -15,8 +15,8 @@
|
|||
|
||||
namespace qmcplusplus
|
||||
{
|
||||
LCAOrbitalSetWithCorrection::LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs)
|
||||
: LCAOrbitalSet(bs), cusp(ions, els)
|
||||
LCAOrbitalSetWithCorrection::LCAOrbitalSetWithCorrection(ParticleSet& ions, ParticleSet& els, basis_type* bs, bool optimize)
|
||||
: LCAOrbitalSet(bs, optimize), cusp(ions, els)
|
||||
{}
|
||||
|
||||
void LCAOrbitalSetWithCorrection::setOrbitalSetSize(int norbs)
|
||||
|
|
|
@ -34,7 +34,7 @@ struct LCAOrbitalSetWithCorrection : public LCAOrbitalSet
|
|||
* @param bs pointer to the BasisSet
|
||||
* @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;
|
||||
|
||||
|
|
|
@ -108,14 +108,14 @@ TEST_CASE("CuspCorrection He", "[wavefunction]")
|
|||
|
||||
typedef NGOBuilder::CenteredOrbitalType COT;
|
||||
OrbType bs_phi(lcob->myBasisSet);
|
||||
bs_phi.setOrbitalSetSize(lcob->OrbitalSetSize);
|
||||
bs_phi.setOrbitalSetSize(lcob->getOrbitalSetSize());
|
||||
bs_phi.BasisSetSize = lcob->BasisSetSize;
|
||||
bs_phi.setIdentity(false);
|
||||
|
||||
*(bs_phi.C) = *(lcob->C);
|
||||
|
||||
OrbType bs_eta(lcob->myBasisSet);
|
||||
bs_eta.setOrbitalSetSize(lcob->OrbitalSetSize);
|
||||
bs_eta.setOrbitalSetSize(lcob->getOrbitalSetSize());
|
||||
bs_eta.BasisSetSize = lcob->BasisSetSize;
|
||||
bs_eta.setIdentity(false);
|
||||
*(bs_eta.C) = *(lcob->C);
|
||||
|
|
|
@ -129,14 +129,14 @@ TEST_CASE("applyCuspInfo", "[wavefunction]")
|
|||
REQUIRE(lcob != NULL);
|
||||
|
||||
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcob->myBasisSet);
|
||||
phi.setOrbitalSetSize(lcob->OrbitalSetSize);
|
||||
phi.BasisSetSize = lcob->BasisSetSize;
|
||||
LCAOrbitalSet phi = LCAOrbitalSet(lcob->myBasisSet, lcob->isOptimizable());
|
||||
phi.setOrbitalSetSize(lcob->getOrbitalSetSize());
|
||||
phi.BasisSetSize = lcob->getBasisSetSize();
|
||||
phi.setIdentity(false);
|
||||
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcob->myBasisSet);
|
||||
eta.setOrbitalSetSize(lcob->OrbitalSetSize);
|
||||
eta.BasisSetSize = lcob->BasisSetSize;
|
||||
LCAOrbitalSet eta = LCAOrbitalSet(lcob->myBasisSet, lcob->isOptimizable());
|
||||
eta.setOrbitalSetSize(lcob->getOrbitalSetSize());
|
||||
eta.BasisSetSize = lcob->getBasisSetSize();
|
||||
eta.setIdentity(false);
|
||||
|
||||
*(eta.C) = *(lcob->C);
|
||||
|
|
|
@ -1,6 +1,8 @@
|
|||
# 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(
|
||||
deterministic-He_ae-opt
|
||||
"${CMAKE_SOURCE_DIR}/tests/molecules/He_ae"
|
||||
|
@ -19,7 +21,5 @@ IF (NOT MIXED_PRECISION)
|
|||
TRUE
|
||||
2 He_VMC_SCALARS # VMC
|
||||
)
|
||||
ELSE()
|
||||
MESSAGE_VERBOSE("Skipping optimizer deterministic tests in mixed precision (QMC_MIXED_PRECISION=1)")
|
||||
ENDIF()
|
||||
|
||||
|
|
Loading…
Reference in New Issue