Inheritance diagram for MagnetizationDensityInput::MagnetizationDensityInputSection:

Collaboration diagram for MagnetizationDensityInput::MagnetizationDensityInputSection:

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

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

void	checkParticularValidity () override
	Do validation for a particular subtype of InputSection Called by check_valid. 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 79 of file MagnetizationDensityInput.h.

Constructor & Destructor Documentation

◆ MagnetizationDensityInputSection()

MagnetizationDensityInputSection ( )

inline

parse time definition of input parameters

Definition at line 83 of file MagnetizationDensityInput.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  = "MagnetizationDensity";
       attributes    = {"name", "type"};
       parameters    = {"integrator", 
                        "corner", "center", "samples", "grid", "dr"
                       };
       bools         = {};
       enums         = {"integrator"};
       strings       = {"name", "type"};
       multi_strings = {};
       integers      = {"samples"};
       reals         = {};
       positions     = {"center", "corner", "grid", "dr"};
       required      = {"name"};
       // I'd much rather see the default defined in simple native c++ as below
       // clang-format on
     }

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 69 of file MagnetizationDensityInput.cpp.

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

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

◆ checkParticularValidity()

void checkParticularValidity ( )

overridevirtual

Do validation for a particular subtype of InputSection Called by check_valid.

Default implementation is noop The InputSection subtype should make all correctness checks reasonable at parse time.

Reimplemented from InputSection.

Definition at line 74 of file MagnetizationDensityInput.cpp.

References qmcplusplus::app_log(), qmcplusplus::estimatorinput::checkCenterCorner(), MagnetizationDensityInput::DIM, and qmcplusplus::has().

 {
   using namespace estimatorinput;
   const std::string error_tag{"MagnetizationDensity input: "};
   checkCenterCorner(*this, error_tag);
 
   if (has("grid") && has("dr"))
     throw UniformCommunicateError(error_tag + " cannot define grid and dr.");
 
   if (has("grid"))
   {
     PosType thisgrid = get<PosType>("grid");
     for (int d = 0; d < DIM; ++d)
     {
       if (thisgrid[d] < 1.0)
         throw UniformCommunicateError(error_tag + " number of grid points must be >=1 in each direction");
     }
   }
   else if (has("dr"))
   {
     //This is the most we can test without knowing the lattice.
     //Correctness determined if dr implies grid with more than 1 point in each direction.
     //Check is performed in calculateDerivedParameters().
     PosType thisdr = get<PosType>("dr");
     for (int d = 0; d < DIM; ++d)
     {
       if (thisdr[d] <= 0.0)
         throw UniformCommunicateError(error_tag + " grid spacing dr must be >= 0 in each direction");
       if (thisdr[d] >= 10.0)
         app_log() << error_tag + " dr larger than 10.0.  Make sure that this grid spacing is intended.\n";
     }
   }
   else
     throw UniformCommunicateError(error_tag + " grid or dr must be specified.");
 
   if (has("samples"))
   {
     int samps = get<int>("samples");
     if (samps < 1)
       throw UniformCommunicateError(error_tag + " number of samples has to be greater than 0");
   }
 }

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

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