Inheritance diagram for OneBodyDensityMatricesInput::OneBodyDensityMatricesInputSection:

Collaboration diagram for OneBodyDensityMatricesInput::OneBodyDensityMatricesInputSection:

Public Member Functions
	OneBodyDensityMatricesInputSection ()
	parse time definition of input parameters More...

	OneBodyDensityMatricesInputSection (const OneBodyDensityMatricesInputSection &)=default

void	checkParticularValidity () override
	do parse time checks of input More...

std::any	assignAnyEnum (const std::string &name) const override
	Derived class overrides this to get proper assignment of scoped enum values. More...

Public Member Functions inherited from InputSection
	InputSection ()=default

	InputSection (const InputSection &other)=default

InputSection &	operator= (const InputSection &other)=default

bool	has (const std::string &name) const

template<typename T >
T	get (const std::string &name) const

template<typename T >
bool	setIfInInput (T &var, const std::string &tag)
	set var if input section has read the tag More...

void	readXML (xmlNodePtr cur)
	Read variable values (initialize) from XML input, call checkValid. More...

void	init (const std::unordered_map< std::string, std::any > &init_values)

Additional Inherited Members
Public Types inherited from InputSection
using	Real = QMCTraits::FullPrecRealType

using	Position = typename QMCTypes< Real, OHMMS_DIM >::PosType

Static Public Member Functions inherited from InputSection
template<typename ENUM_T >
static std::string	reverseLookupInputEnumMap (ENUM_T enum_val, const std::unordered_map< std::string, std::any > &enum_map)
	Get string represtation of enum class type value from enum_val. More...

Protected Types inherited from InputSection
using	DelegateHandler = std::function< std::any(xmlNodePtr cur, std::string &value_name)>
	Function that returns Input class as std::any. More...

Protected Member Functions inherited from InputSection
void	readAttributes (xmlNodePtr cur, const std::string &element_name, const std::vector< std::string > &do_not_consume)
	reads attributes for both the root node and parameter/child nodes that aren't delegated. More...

void	registerDelegate (const std::string &tag, DelegateHandler delegate_handler)
	register factory function for delegate input More...

virtual void	setFromStreamCustom (const std::string &ename, const std::string &name, std::istringstream &svalue)
	Derived class can overrides this to do custom parsing of the element values for Custom elements These can have a name attribute only. More...

void	report () const

void	report (std::ostream &out) const

Static Protected Member Functions inherited from InputSection
static std::any	lookupAnyEnum (const std::string &enum_name, const std::string &enum_value, const std::unordered_map< std::string, std::any > &enum_map)
	Assign any enum helper for InputSection derived class assumes enum lookup table of this form: inline static const std::unordered_map<std::string, std::any> lookup_input_enum_value{{"integrator-uniform_grid", Integrator::UNIFORM_GRID}, {"integrator-uniform", Integrator::UNIFORM}, {"integrator-density", Integrator::DENSITY}, {"evaluator-loop", Evaluator::LOOP}, {"evaluator-matrix", Evaluator::MATRIX}};. More...

Protected Attributes inherited from InputSection
std::string	section_name
	"Name" of the input section, you must define this in the subtype and the ename, name, type, or method must match. More...

std::vector< std::string >	section_name_alternates
	For historical reasons some sections must recognize several different names. Assign them to this variable in your subtype. More...

std::unordered_set< std::string >	attributes

std::unordered_set< std::string >	parameters

std::unordered_set< std::string >	delegates

std::unordered_set< std::string >	required

std::unordered_set< std::string >	multiple

std::unordered_set< std::string >	strings

std::unordered_set< std::string >	multi_strings

std::unordered_set< std::string >	multi_reals

std::unordered_set< std::string >	bools

std::unordered_set< std::string >	integers

std::unordered_set< std::string >	reals

std::unordered_set< std::string >	positions

std::unordered_set< std::string >	custom

std::unordered_set< std::string >	enums
	list of enum inputs which allow a finite set of strings to map to enum values The enum class types and values need only be known to IS subtypes More...

std::unordered_map< std::string, std::any >	default_values

std::unordered_map< std::string, std::function< std::any(xmlNodePtr cur, std::string &value_key)> >	delegate_factories_

std::unordered_map< std::string, std::any >	values_

Detailed Description

Definition at line 66 of file OneBodyDensityMatricesInput.h.

Constructor & Destructor Documentation

◆ OneBodyDensityMatricesInputSection() [1/2]

OneBodyDensityMatricesInputSection ( )

inline

parse time definition of input parameters

Definition at line 70 of file OneBodyDensityMatricesInput.h.

References InputSection::attributes, InputSection::bools, InputSection::enums, InputSection::integers, InputSection::multi_strings, InputSection::parameters, InputSection::positions, InputSection::reals, InputSection::required, InputSection::section_name, and InputSection::strings.

     {
       // clang-format off
       section_name  = "OneBodyDensityMatrices";
       attributes    = {"name", "type"};
       parameters    = {"basis", "energy_matrix", "integrator", "evaluator", "scale",
                        "corner", "center", "points", "samples", "warmup", "timestep",
                        "use_drift", "check_overlap", "check_derivatives", "acceptance_ratio", "rstats",
                        "normalized", "volumed_normed"};
       bools         = {"energy_matrix", "use_drift", "normalized", "volume_normed",
                        "check_overlap", "check_derivatives", "rstats", "acceptance_ratio"};
       enums         = {"integrator", "evaluator"};
       strings       = {"name", "type"};
       multi_strings = {"basis"};
       integers      = {"points", "samples"};
       reals         = {"scale", "timestep"};
       positions     = {"center", "corner"};
       required      = {"name", "basis"};
       // I'd much rather see the default defined in simple native c++ as below
       // clang-format on
     }

◆ OneBodyDensityMatricesInputSection() [2/2]

OneBodyDensityMatricesInputSection ( const OneBodyDensityMatricesInputSection & )

default

Member Function Documentation

◆ assignAnyEnum()

std::any assignAnyEnum ( const std::string & tag ) const

overridevirtual

Derived class overrides this to get proper assignment of scoped enum values.

In most cases all you'll need it to define the map and write: std::any DerivedInputSection::assignAnyEnum(const std::string& name) const { return lookupAnyEnum(name, get<std::string>(name), derived_input_lookup_enum); }

See test_InputSection.cpp and OneBodyDensityMatricesInput You really should do this if your input class has a finite set of string values for an input example: OneBodyDensityMatricesInput

can't be bothered then just define your enum option as a string.

Reimplemented from InputSection.

Definition at line 77 of file OneBodyDensityMatricesInput.cpp.

References OneBodyDensityMatricesInput::lookup_input_enum_value, and InputSection::lookupAnyEnum().

 {
   return lookupAnyEnum(name, get<std::string>(name), lookup_input_enum_value);
 }

◆ checkParticularValidity()

void checkParticularValidity ( )

overridevirtual

do parse time checks of input

Reimplemented from InputSection.

Definition at line 47 of file OneBodyDensityMatricesInput.cpp.

References qmcplusplus::estimatorinput::checkCenterCorner(), qmcplusplus::Units::charge::e, and InputSection::has().

 {
   using namespace estimatorinput;
   const std::string error_tag{"OneBodyDensityMatrices input: "};
   checkCenterCorner(*this, error_tag);
   if (has("scale"))
   {
     Real scale = get<Real>("scale");
     if (scale > 1.0 + 1e-10)
       throw UniformCommunicateError(error_tag + "scale must be less than one");
     else if (scale < 0.0 - 1e-10)
       throw UniformCommunicateError(error_tag + "scale must be greater than zero");
   }
   std::vector<std::string> basis_sets = get<std::vector<std::string>>("basis");
   if (basis_sets.size() == 0 || basis_sets[0].size() == 0)
     throw UniformCommunicateError(error_tag + "basis must have at least one sposet");
   // An example of how to do specific validation of input.
   if (get<std::string>("integrator") != "density")
   {
     if (has("acceptance_ratio") && get<bool>("acceptance_ratio") == true)
       throw UniformCommunicateError(error_tag + "acceptance_ratio can only be true for density integrator");
   }
   if (get<std::string>("integrator") == "uniform_grid")
   {
     if (has("samples"))
       throw UniformCommunicateError(error_tag +
                                     "samples are set from points for uniform_grid integrator and are invalid input");
   }
 }

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Estimators/OneBodyDensityMatricesInput.h
/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Estimators/OneBodyDensityMatricesInput.cpp

Public Member Functions