MADNESS
0.10.1
|
File holds all helper structures necessary for the CC_Operator and CC2 class. More...
Namespaces | |
archive | |
Namespace for I/O tools. | |
cblas | |
constants | |
Namespace storing mathematical and physical constants. | |
detail | |
guessfactory | |
Hash_private | |
info | |
Runtime details on the configuration and version of MADNESS. | |
is_istreammable_ns | |
is_ostreammable_ns | |
lapacke | |
meta | |
operators | |
profiling | |
tr1 | |
units | |
Classes | |
struct | abs_op |
struct | abs_square_op |
class | AbstractVectorSpace |
A generic vector space which provides common operations needed by linear algebra routines (norm, inner product, etc.) More... | |
class | AC |
struct | accumulate_op |
inserts/accumulates coefficients into impl's tree More... | |
struct | ACParameters |
Contains all the parameters for the asymptotic correction. More... | |
struct | add_future |
maps type T to Future<T> . More... | |
struct | add_future< Future< T > > |
maps Future<T> to Future<T> . More... | |
class | AdhocNuclearCorrelationFactor |
this ncf has no information about itself, only U2 and U1 assigned More... | |
class | AmArg |
World active message that extends an RMI message. More... | |
struct | apply_kernel_helper |
struct | asymptotic_density |
struct | asymptotic_slater |
struct | asymptotic_slater_kernel |
class | Atom |
struct | atom_information |
Needed information about atom to compute asymptotic correction. More... | |
struct | AtomCore |
class | atomic_attraction |
class | AtomicBasis |
Represents multiple shells of contracted gaussians on a single center. More... | |
class | AtomicBasisFunction |
Used to represent one basis function from a shell on a specific center. More... | |
class | AtomicBasisSet |
Contracted Gaussian basis. More... | |
struct | AtomicData |
class | AtomicInt |
An integer with atomic set, get, read+increment, read+decrement, and decrement+test operations. More... | |
class | BandlimitedPropagator |
Class to evaluate the filtered Schrodinger free-particle propagator in real space. More... | |
class | Barrier |
class | BaseTensor |
The base class for tensors defines generic capabilities. More... | |
class | BasisFunctions |
class | Batch |
a batch consists of a 2D-input batch and a 1D-output batch: K-batch <- (I-batch, J-batch) More... | |
class | Batch_1D |
struct | BinaryOpStructure |
computes the corrected exchange correlation potential using the hartree potential More... | |
class | BinSorter |
A parallel bin sort across MPI processes. More... | |
class | BoundaryConditions |
This class is used to specify boundary conditions for all operators. More... | |
class | BSHApply |
apply the BSH operator on a vector of functions with corresponding potentials More... | |
class | BSHFunctionInterface |
a function like f(x) = exp(-mu x)/x More... | |
struct | CalculationParameters |
class | CallbackInterface |
The class used for callbacks (e.g., dependency tracking). More... | |
struct | cartesian_grid |
class | CC2 |
struct | CC_vecfunction |
A helper structure which holds a map of functions. More... | |
class | CCConvolutionOperator |
class | CCFunction |
structure for a CC Function 3D which holds an index and a type More... | |
struct | CCIntermediatePotentials |
little helper structure which manages the stored singles potentials More... | |
struct | CCMessenger |
class | CCPair |
class | CCPairFunction |
a 6D function, either in full or low rank form, possibly including an 2-particle function More... | |
struct | CCParameters |
struct | CCTimer |
Timer Structure. More... | |
struct | charactertable |
struct | CISData |
POD for CIS excitation. More... | |
class | Cloud |
cloud class More... | |
class | CoeffTracker |
a class to track where relevant (parent) coeffs are More... | |
struct | commandlineparser |
very simple command line parser More... | |
class | Complex_CIS_Parameters |
class | ComplexExp |
class | CompositeFactory |
Factory for facile setup of a CompositeFunctorInterface and its FuncImpl. More... | |
class | CompositeFunctorInterface |
CompositeFunctorInterface implements a wrapper of holding several functions and functors. More... | |
class | ConcurrentHashMap |
struct | conditional_conj_struct |
For real types return value, for complex return conjugate. More... | |
struct | conditional_conj_struct< Q, true > |
For real types return value, for complex return conjugate. More... | |
class | ConditionVariable |
Scalable and fair condition variable (spins on local value) More... | |
struct | conj_op |
class | ContractedGaussianShell |
Represents a single shell of contracted, Cartesian, Gaussian primitives. More... | |
class | Convolution1D |
Provides the common functionality/interface of all 1D convolutions. More... | |
struct | ConvolutionData1D |
!!! Note that if Rnormf is zero then ALL of the tensors are empty More... | |
class | ConvolutionND |
Array of 1D convolutions (one / dimension) More... | |
struct | CoreOrbital |
class | CoreOrbitalDerivativeFunctor |
class | CoreOrbitalFunctor |
struct | CorePotential |
Represents a core potential. More... | |
class | CorePotentialManager |
class | Coulomb |
class | CubicInterpolationTable |
An class for 1-D data interpolation based on cubic polynomials. More... | |
struct | default_allocator |
class | DeferredDeleter |
struct | dens_inv |
struct | density_mask_operator |
class | DependencyInterface |
Provides an interface for tracking dependencies. More... | |
class | Derivative |
Implements derivatives operators with variety of boundary conditions on simulation domain. More... | |
class | DerivativeBase |
Tri-diagonal operator traversing tree primarily for derivative operator. More... | |
class | DerivativeOperator |
struct | DFParameters |
class | DFT |
class | DFTCoulombOp |
class | DFTCoulombPeriodicOp |
class | dftgrid |
class | DFTNuclearChargeDensityOp |
class | DFTNuclearPotentialOp |
class | Diamagnetic_potential_factor |
to be put in a separate file More... | |
class | DipoleFunctor |
A MADNESS functor to compute either x, y, or z. More... | |
class | Displacements |
Holds displacements for applying operators to avoid replicating for all operators. More... | |
class | DistributedMatrix |
Manages data associated with a row/column/block distributed array. More... | |
class | DistributedMatrixDistribution |
struct | divide_add_interpolate |
Class to compute terms of the potential. More... | |
class | DNuclear |
derivative of the (regularized) nuclear potential wrt nuclear displacements More... | |
class | DomainMaskInterface |
The interface for masking functions defined by signed distance functions. More... | |
class | DomainMaskSDFFunctor |
Framework for combining a signed distance function (sdf) with a domain mask to produce MADNESS functions. More... | |
struct | DQStats |
class | DQueue |
A thread safe, fast but simple doubled-ended queue. More... | |
class | EigSolver |
class | EigSolverOp |
struct | ElectronCuspyBox_op |
struct | ElectronicStructureParams |
class | ElectronPair |
enhanced POD for the pair functions More... | |
struct | ElectronPairIterator |
class | ElectronRepulsionInterface |
a function like f(x)=1/x More... | |
class | ElementaryInterface |
ElementaryInterface (formerly FunctorInterfaceWrapper) interfaces a c-function. More... | |
struct | error_leaf_op |
class | Exchange |
class | F12Parameters |
class | F12Potentials |
Class that provides all necessary F12 Potentials and Integrals. More... | |
class | Fock |
Computes matrix representation of the Fock operator. More... | |
class | Function |
A multiresolution adaptive numerical function. More... | |
struct | function_real2complex_op |
class | FunctionCommonData |
FunctionCommonData holds all Function data common for given k. More... | |
class | FunctionCommonFunctionality |
collect common functionality does not need to be member function of funcimpl More... | |
class | FunctionDefaults |
FunctionDefaults holds default paramaters as static class members. More... | |
class | FunctionFactory |
FunctionFactory implements the named-parameter idiom for Function. More... | |
class | FunctionFunctorInterface |
Abstract base class interface required for functors used as input to Functions. More... | |
class | FunctionImpl |
FunctionImpl holds all Function state to facilitate shallow copy semantics. More... | |
class | FunctionInterface |
FunctionInterface implements a wrapper around any class with the operator()() More... | |
class | FunctionNode |
FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree. More... | |
class | FunctionSpace |
A vector space using MADNESS Functions. More... | |
class | FunctorInterface |
FunctorInterface interfaces a class or struct with an operator()() More... | |
class | Future |
A future is a possibly yet unevaluated value. More... | |
class | Future< Future< T > > |
A future of a future is forbidden (by deleted constructor). More... | |
class | Future< std::vector< Future< T > > > |
Specialization of Future for a vector of Future s. More... | |
class | Future< void > |
Specialization of Future<void> for internal convenience. This does nothing useful! More... | |
struct | future_to_ref |
struct | future_to_ref< const Future< T > & > |
struct | future_to_ref< Future< T > & > |
struct | future_to_ref< Future< T > * > |
struct | future_to_ref< Future< T > > |
class | FutureImpl |
Implements the functionality of futures. More... | |
class | FutureImpl< void > |
Specialization of FutureImpl<void> for internal convenience. This does nothing useful! More... | |
class | GaussianConvolution1D |
1D convolution with (derivative) Gaussian; coeff and expnt given in simulation coordinates [0,1] More... | |
struct | GaussianConvolution1DCache |
class | GaussianDomainMask |
Use a Gaussian for the surface function and the corresponding erf for the domain mask. More... | |
class | GaussianGenericFunctor |
class | GaussSlater |
A nuclear correlation factor class. More... | |
class | GeneralTwoElectronInterface |
a function like f(x)=1/x More... | |
class | GenericConvolution1D |
Generic 1D convolution using brute force (i.e., slow) adaptive quadrature for rnlp. More... | |
class | GenTensor |
class | GFit |
class | Gnuplot |
class | GradientalGaussSlater |
A nuclear correlation factor class. More... | |
class | gridbase |
class | Group |
A collection of processes. More... | |
class | GTHPseudopotential |
struct | harmonic_potential_boxed |
functor for the diamagnetic term in a box More... | |
struct | hartree_convolute_leaf_op |
struct | hartree_leaf_op |
returns true if the result of a hartree_product is a leaf node (compute norm & error) More... | |
class | HartreeFock |
class | HartreeFockCoulombOp |
class | HartreeFockExchangeOp |
class | HartreeFockNuclearPotentialOp |
struct | Hash |
Hash functor. More... | |
class | HighDimIndexIterator |
class | IEigSolverObserver |
struct | imag_op |
class | IndexIterator |
struct | Info |
POD holding some basic functions and some intermediates for the CC2 calculation. More... | |
struct | InitParameters |
struct | insert_op |
insert/replaces the coefficients into the function More... | |
class | int_factor_functor |
Functor for the correction factor, which is multiplied with the exchange correlation potential. More... | |
struct | is_any_function_pointer |
is true type if T is a pointer to free or member function More... | |
struct | is_any_function_pointer< T, std::enable_if_t< std::is_member_function_pointer< T >::value||is_function_pointer_v< T > > > |
struct | is_archive |
Checks if T is an archive type. More... | |
struct | is_archive< archive::BinaryFstreamInputArchive > |
struct | is_archive< archive::BinaryFstreamOutputArchive > |
struct | is_archive< archive::BufferInputArchive > |
struct | is_archive< archive::BufferOutputArchive > |
struct | is_archive< archive::ContainerRecordInputArchive > |
struct | is_archive< archive::ContainerRecordOutputArchive > |
struct | is_archive< archive::MPIInputArchive > |
struct | is_archive< archive::MPIOutputArchive > |
struct | is_archive< archive::MPIRawInputArchive > |
struct | is_archive< archive::MPIRawOutputArchive > |
struct | is_archive< archive::ParallelInputArchive< localarchiveT > > |
struct | is_archive< archive::ParallelOutputArchive< localarchiveT > > |
struct | is_archive< archive::TextFstreamInputArchive > |
struct | is_archive< archive::TextFstreamOutputArchive > |
struct | is_archive< archive::VectorInputArchive > |
struct | is_archive< archive::VectorOutputArchive > |
struct | is_cereal_archive |
struct | is_default_serializable |
is std::true_type if T can be serialized to Archive without specialized serialize() method More... | |
struct | is_default_serializable_helper |
struct | is_default_serializable_helper< Archive, archive::archive_array< T >, std::enable_if_t< is_default_serializable_helper< Archive, T >::value > > |
struct | is_default_serializable_helper< archive::BinaryFstreamInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::BinaryFstreamOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::BufferInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::BufferOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::ContainerRecordInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::ContainerRecordOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::MPIInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::MPIOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::MPIRawInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::MPIRawOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::ParallelInputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::ParallelOutputArchive< localarchiveT >, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::TextFstreamInputArchive, T, std::enable_if_t< is_iostreammable_v< T >||is_any_function_pointer_v< T > > > |
struct | is_default_serializable_helper< archive::TextFstreamOutputArchive, T, std::enable_if_t< is_iostreammable_v< T >||std::is_function_v< T >||is_any_function_pointer_v< T > > > |
struct | is_default_serializable_helper< archive::VectorInputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_default_serializable_helper< archive::VectorOutputArchive, T, std::enable_if_t< is_trivially_serializable< T >::value > > |
struct | is_function_pointer |
is true type if T is a pointer to a free function More... | |
struct | is_function_pointer< T, std::enable_if_t< std::is_function< typename std::remove_pointer< T >::type >::value > > |
struct | is_future |
test if a type is a future. More... | |
struct | is_future< Future< T > > |
struct | is_input_archive |
Checks if T is an input archive type. More... | |
struct | is_input_archive< archive::BinaryFstreamInputArchive > |
struct | is_input_archive< archive::BufferInputArchive > |
struct | is_input_archive< archive::ContainerRecordInputArchive > |
struct | is_input_archive< archive::MPIInputArchive > |
struct | is_input_archive< archive::MPIRawInputArchive > |
struct | is_input_archive< archive::ParallelInputArchive< localarchiveT > > |
struct | is_input_archive< archive::TextFstreamInputArchive > |
struct | is_input_archive< archive::VectorInputArchive > |
struct | is_istreammable |
struct | is_madness_function |
struct | is_madness_function< madness::Function< T, NDIM > > |
struct | is_madness_function_vector |
struct | is_madness_function_vector< std::vector< typename madness::Function< T, NDIM > > > |
struct | is_ostreammable |
struct | is_output_archive |
Checks if T is an output archive type. More... | |
struct | is_output_archive< archive::BinaryFstreamOutputArchive > |
struct | is_output_archive< archive::BufferOutputArchive > |
struct | is_output_archive< archive::ContainerRecordOutputArchive > |
struct | is_output_archive< archive::MPIOutputArchive > |
struct | is_output_archive< archive::MPIRawOutputArchive > |
struct | is_output_archive< archive::ParallelOutputArchive< localarchiveT > > |
struct | is_output_archive< archive::TextFstreamOutputArchive > |
struct | is_output_archive< archive::VectorOutputArchive > |
struct | is_scalar_result_ptr |
struct | is_scalar_result_ptr< std::shared_ptr< madness::ScalarResult< T > > > |
struct | is_scalar_result_ptr_vector |
struct | is_scalar_result_ptr_vector< std::vector< std::shared_ptr< typename madness::ScalarResult< T > > > > |
struct | is_serializable |
struct | is_text_archive |
This trait types tests if Archive is a text archive. More... | |
struct | is_text_archive< archive::TextFstreamInputArchive > |
struct | is_text_archive< archive::TextFstreamOutputArchive > |
struct | is_trivially_serializable |
struct | is_vector |
struct | is_vector< std::vector< Q > > |
struct | IsSupported |
struct | IsSupported< TypeData, ReturnType, true > |
class | Key |
Key is the index for a node of the 2^NDIM-tree. More... | |
class | KeyChildIterator |
Iterates in lexical order thru all children of a key. More... | |
class | Kinetic |
class | KPoint |
class | Laplacian |
the Laplacian operator: \sum_i \nabla^2_i More... | |
struct | LBCost |
struct | lbcost |
class | LBDeuxPmap |
class | LBNodeDeux |
struct | leaf_op |
class | Leaf_op |
class | Leaf_op_other |
class | LevelPmap |
A pmap that locates children on odd levels with their even level parents. More... | |
class | LinAlgException |
Linear algebra Exception. More... | |
class | LinearSlater |
A nuclear correlation factor class. More... | |
class | LLRVDomainMask |
Provides the Li-Lowengrub-Ratz-Voight (LLRV) domain mask characteristic functions. More... | |
class | LoadBalanceDeux |
class | LoadBalImpl |
class | Localizer |
class | LocalPotentialOperator |
class | LowDimIndexIterator |
class | LowRankFunction |
LowRankFunction represents a hi-dimensional (NDIM) function as a sum of products of low-dimensional (LDIM) functions. More... | |
class | LowRankFunctionFactory |
struct | LowRankFunctionParameters |
class | lr_pot_functor |
Functor for the 1/r potential to induce the correct asymptotic behaviour of the exchange correlation potential. More... | |
struct | LRFunctorBase |
the low-rank functor is what the LowRankFunction will represent More... | |
struct | LRFunctorF12 |
struct | LRFunctorPure |
class | Lz |
the z component of the angular momentum More... | |
class | MacroTask |
class | MacroTaskBase |
base class More... | |
class | MacroTaskConstantPart |
class | MacroTaskIntermediate |
class | MacroTaskIteratePair |
class | MacroTaskMp2ConstantPart |
class | MacroTaskMp2UpdatePair |
class | MacroTaskOperationBase |
class | MacroTaskPartitioner |
partition one (two) vectors into 1D (2D) batches. More... | |
class | MacroTaskQ |
class | MadnessException |
Base class for exceptions thrown in MADNESS. More... | |
struct | MatrixInnerTask |
struct | max_of_x_1_smooth |
struct | merging_operator |
class | molecular_grid |
given a molecule, return a suitable grid More... | |
class | MolecularCorePotentialFunctor |
class | MolecularEnergy |
class | MolecularOptimizationParameters |
struct | MolecularOptimizationTargetInterface |
class | MolecularOptimizer |
Molecular optimizer derived from the QuasiNewton optimizer. More... | |
class | MolecularOrbitals |
class | MolecularPotentialFunctor |
class | Molecule |
class | MomentFunctor |
A MADNESS functor to compute the cartesian moment x^i * y^j * z^k (i, j, k integer and >= 0) More... | |
class | MP2 |
a class for computing the first order wave function and MP2 pair energies More... | |
class | MP3 |
struct | mul_leaf_op |
struct | munging_operator |
class | Mutex |
Mutex using pthread mutex operations. More... | |
class | MutexFair |
A scalable and fair mutex (not recursive) More... | |
class | MutexReaderWriter |
class | MutexWaiter |
class | MyPmap |
Procmap implemented using Tree of TreeCoords. More... | |
struct | MyTimer |
Timer structure. More... | |
class | Nemo |
The Nemo class. More... | |
class | Nemo_complex_Parameters |
class | NemoBase |
class | NonlinearSolverND |
A simple Krylov-subspace nonlinear equation solver. More... | |
class | NonstandardIndexIterator |
struct | noop |
class | Nuclear |
class | NuclearCorrelationFactor |
ABC for the nuclear correlation factors. More... | |
struct | NuclearCuspyBox_op |
class | OEP |
class | OEP_Parameters |
struct | op_leaf_op |
class | Operator |
A generic operator: takes in one T and produces another T . More... | |
struct | OperatorInfo |
struct | OptimizationTargetInterface |
The interface to be provided by functions to be optimized. More... | |
struct | OptimizerInterface |
The interface to be provided by optimizers. More... | |
struct | OrbitalIterator |
iterates the third index for pair coupling More... | |
class | OuterProjector |
an outer product of two projectors More... | |
struct | PairEnergies |
POD structure for energies. More... | |
struct | Pairs |
struct | PairVectorMap |
class | ParametrizedExchange |
struct | particle |
class | PCM |
interface class to the PCMSolver library More... | |
struct | permutation |
permutations in physisists notation: <ij | kl> = (ik | jl), loop over ik<jl More... | |
class | pg_operator |
This class implements the symmetry operations (not the point groups) More... | |
struct | PlotParameters |
class | PNO |
struct | PNOPairs |
POD for PNO code. More... | |
class | PNOParameters |
class | poly4erfc |
class | Polynomial |
A nuclear correlation factor class. More... | |
class | PoolTaskInterface |
Lowest level task interface. More... | |
class | PoolTaskNull |
A no-operation task used for various purposes. More... | |
class | PotentialManager |
struct | printleveler |
class | ProcessKey |
Key object that includes the process information. More... | |
struct | ProfileStat |
Simple container for parallel profile statistic. More... | |
class | Projector |
simple projector class More... | |
class | projector_irrep |
class | ProjectorBase |
class | ProjRLMFunctor |
class | ProjRLMStore |
class | PseudoNuclearCorrelationFactor |
class | PthreadConditionVariable |
Simple wrapper for Pthread condition variable with its own mutex. More... | |
class | QCCalculationParametersBase |
class for holding the parameters for calculation More... | |
struct | QCParameter |
structure holding the value for a given parameter More... | |
class | QCPropertyInterface |
class implementing properties of QC models More... | |
struct | qmsg |
class | QProjector |
orthogonality projector More... | |
class | QuasiNewton |
Optimization via quasi-Newton (BFGS or SR1 update) More... | |
struct | R_times_arg_div_R |
compute the expression (\sum_i R_i)^(-1) \sum_i R_i arg(r,B,v_i) More... | |
class | Random |
A random number generator (portable, vectorized, and thread-safe) More... | |
class | randomgrid |
grid with random points around the origin, with a Gaussian distribution More... | |
class | RandomizedMatrixDecomposition |
struct | RandomState |
class | Range |
Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with chunksize. More... | |
struct | real_op |
struct | Recordlist |
class | RecursiveMutex |
Recursive mutex using pthread mutex operations. More... | |
class | RemoteReference |
Simple structure used to manage references/pointers to remote instances. More... | |
struct | remove_fcvr |
struct | remove_future |
maps Future<T> to T . More... | |
struct | remove_future< const Future< T > & > |
struct | remove_future< const Future< T > > |
struct | remove_future< Future< T > & > |
struct | remove_future< Future< T > && > |
struct | remove_future< Future< T > > |
This metafunction maps Future<T> to T . More... | |
struct | response_function_allocator |
struct | response_matrix_allocator |
struct | response_space |
struct | ResponseParameters |
struct | RMDFactory |
simple factory pattern for the RandomizedMatrixDecomposition More... | |
class | RMI |
This class implements the communications server thread and provides the only send interface. More... | |
struct | RMISendReq |
This for RMI server thread to manage lifetime of WorldAM messages that it is sending. More... | |
struct | RMIStats |
class | ScalarResult |
helper class for returning the result of a task, which is not a madness Function, but a simple scalar More... | |
class | SCF |
class | scf_data |
class | SCFOperatorBase |
class | SCFProtocol |
struct for running a protocol of subsequently tightening precision More... | |
class | ScopedMutex |
Mutex that is applied/released at start/end of a scope. More... | |
class | SDFBox |
A box (3 dimensions) More... | |
class | SDFCircle |
A circle (2 dimensions) More... | |
class | SDFCone |
A cone (3 dimensions) More... | |
class | SDFCube |
A cube (3 dimensions) More... | |
class | SDFCylinder |
A cylinder (3 dimensions) More... | |
class | SDFEllipsoid |
An ellipsoid (3 dimensions) More... | |
class | SDFParaboloid |
A paraboloid (3 dimensions) More... | |
class | SDFPlane |
A plane surface (3 dimensions) More... | |
class | SDFRectangle |
A rectangle (2 dimensions) More... | |
class | SDFSphere |
A spherical surface (3 dimensions) More... | |
class | SeparatedConvolution |
Convolutions in separated form (including Gaussian) More... | |
struct | SeparatedConvolutionData |
SeparatedConvolutionData keeps data for all terms, all dimensions. More... | |
struct | SeparatedConvolutionInternal |
struct | ShallowNode |
shallow-copy, pared-down version of FunctionNode, for special purpose only More... | |
class | SignedDFInterface |
The interface for a signed distance function (sdf). More... | |
class | SimpleCache |
Simplified interface around hash_map to cache stuff for 1D. More... | |
class | SimplePmap |
A simple process map. More... | |
class | Slater |
A nuclear correlation factor class. More... | |
struct | slater_kernel |
struct | slater_kernel_apply |
class | SlaterF12Interface |
a function like f(x) = (1 - exp(-mu x))/(2 gamma) More... | |
class | SlaterFunctionInterface |
a function like f(x)=exp(-mu x) More... | |
class | Slice |
A slice defines a sub-range or patch of a dimension. More... | |
class | SliceGenTensor |
class | SliceLowRankTensor |
implements a temporary(!) slice of a LowRankTensor More... | |
class | SliceTensor |
Indexing a non-constant tensor with slices returns a SliceTensor. More... | |
class | smooth |
class | Solver |
The main class of the periodic DFT solver. More... | |
struct | SolverTargetInterface |
The interface to be provided by targets for non-linear equation solver. More... | |
struct | Specialbox_op |
class | SpectralPropagator |
Spectral propagtor in time. Refer to documentation of file spectralprop.h for math detail. More... | |
class | SpectralPropagatorGaussLobatto |
struct | spherical_box |
an 2-dimensional smooth mask that is 1 inside the radius and 0 outside More... | |
class | Spinlock |
Spinlock using pthread spinlock operations. More... | |
class | SRConf |
class | Stack |
Dynamically sized Stack with small stack size optimization. More... | |
class | SteepestDescent |
Unconstrained minimization via steepest descent. More... | |
class | StrongOrthogonalityProjector |
a SO projector class More... | |
class | Subspace |
The SubspaceK class is a container class holding previous orbitals and residuals. More... | |
class | SubspaceK |
The SubspaceK class is a container class holding previous orbitals and residuals. More... | |
class | SVDTensor |
class | SystolicFixOrbitalOrders |
class | SystolicMatrixAlgorithm |
Base class for parallel algorithms that employ a systolic loop to generate all row pairs in parallel. More... | |
class | SystolicPMOrbitalLocalize |
class | TaggedKey |
Key object that uses a tag to differentiate keys. More... | |
class | TaskAttributes |
Contains attributes of a task. More... | |
struct | TaskFn |
Wrap a callable object and its arguments into a task function. More... | |
struct | TaskFunction |
class | TaskInterface |
All world tasks must be derived from this public interface. More... | |
struct | TaskMemfun |
class | TaskThreadEnv |
Used to pass information about the thread environment to a user's task. More... | |
class | TDHF |
struct | TDHF_allocator |
class | Tensor |
A tensor is a multidimension array. More... | |
struct | TensorArgs |
TensorArgs holds the arguments for creating a LowRankTensor. More... | |
class | TensorException |
Tensor is intended to throw only TensorExceptions. More... | |
class | TensorIterator |
struct | TensorResultType |
TensorResultType<L,R>::type is the type of (L op R) where op is nominally multiplication. More... | |
class | TensorTrain |
class | TensorTypeData |
Traits class to specify support of numeric types. More... | |
class | TensorTypeFromId |
This provides the reverse mapping from integer id to type name. More... | |
struct | test_output |
small class for pretty printing of test output More... | |
class | Thread |
Simplified thread wrapper to hide pthread complexity. More... | |
class | ThreadBase |
Simplified thread wrapper to hide pthread complexity. More... | |
class | ThreadBinder |
class | ThreadPool |
A singleton pool of threads for dynamic execution of tasks. More... | |
class | ThreadPoolThread |
ThreadPool thread object. More... | |
struct | timer |
class | Timer |
struct | trajectory |
struct | true_op |
class | TwoBodyFunctionComponentBase |
class | TwoBodyFunctionPureComponent |
a two-body, explicitly 6-dimensional function More... | |
class | TwoBodyFunctionSeparatedComponent |
class | TwoElectronFactory |
factory for generating TwoElectronInterfaces More... | |
class | TwoElectronInterface |
base class to compute the wavelet coefficients for an isotropic 2e-operator More... | |
class | twoscale_cache_class |
struct | unaryexp |
struct | UnaryOpStructure |
computes the corrected exchange correlation potential using the multipole approximation More... | |
class | uniqueidT |
Class for unique global IDs. More... | |
struct | valarray_allocator |
class | Vector |
A simple, fixed dimension vector. More... | |
struct | vector_function_allocator |
class | VectorOfFunctionsSpace |
A vector space using MADNESS Vectors of MADNESS Functions. More... | |
class | VectorSpace |
A vector space using MADNESS Vectors. More... | |
class | VLocalFunctor |
class | World |
A parallel world class. More... | |
struct | WorldAbsMaxOp |
struct | WorldAbsMinOp |
class | WorldAmInterface |
Implements AM interface. More... | |
struct | WorldBitAndOp |
struct | WorldBitOrOp |
struct | WorldBitXorOp |
class | WorldContainer |
Makes a distributed container with specified attributes. More... | |
class | WorldContainerImpl |
Internal implementation of distributed container to facilitate shallow copy. More... | |
class | WorldContainerIterator |
Iterator for distributed container wraps the local iterator. More... | |
class | WorldDCDefaultPmap |
Default process map is "random" using madness::hash(key) More... | |
class | WorldDCLocalPmap |
Local process map will always return the current process as owner. More... | |
class | WorldDCPmapInterface |
Interface to be provided by any process map. More... | |
class | WorldDCRedistributeInterface |
class | WorldGopInterface |
Provides collectives that interoperate with the AM and task interfaces. More... | |
struct | WorldLogicAndOp |
struct | WorldLogicOrOp |
struct | WorldMaxOp |
class | WorldMemInfo |
Used to output memory statistics and control tracing, etc. More... | |
struct | WorldMinOp |
class | WorldMpiInterface |
This class wraps/extends the MPI interface for World . More... | |
struct | WorldMultOp |
class | WorldObject |
Implements most parts of a globally addressable object (via unique ID). More... | |
struct | WorldObjectBase |
Base class for WorldObject, useful for introspection. More... | |
class | WorldProfile |
Singleton-like class for holding profiling data and functionality. More... | |
struct | WorldProfileEntry |
Used to store profiler info. More... | |
class | WorldProfileObj |
struct | WorldSumOp |
class | WorldTaskQueue |
Multi-threaded queue to manage and run tasks. More... | |
struct | write_test_input |
will write a test input and remove it from disk upon destruction More... | |
class | WSTAtomicBasisFunctor |
struct | X_space |
struct | X_vector |
struct | xc_functional |
Class to compute the energy functional. More... | |
struct | xc_kernel_apply |
Class to compute terms of the kernel. More... | |
struct | xc_lda_potential |
Compute the spin-restricted LDA potential using unaryop (only for the initial guess) More... | |
struct | xc_potential |
Class to compute terms of the potential. More... | |
class | XCfunctional |
Simplified interface to XC functionals. More... | |
class | XCFunctionalLDA |
class | XCOperator |
operator class for the handling of DFT exchange-correlation functionals More... | |
class | XNonlinearSolver |
Generalized version of NonlinearSolver not limited to a single madness function. More... | |
class | Zcis |
class | Znemo |
Typedefs | |
typedef void(* | am_handlerT) (const AmArg &) |
Type of AM handler functions. More... | |
typedef SeparatedConvolution< double_complex, 1 > | complex_convolution_1d |
typedef std::shared_ptr< complex_convolution_1d > | complex_convolution_1d_ptr |
typedef SeparatedConvolution< double_complex, 2 > | complex_convolution_2d |
typedef std::shared_ptr< complex_convolution_2d > | complex_convolution_2d_ptr |
typedef SeparatedConvolution< double_complex, 3 > | complex_convolution_3d |
typedef std::shared_ptr< complex_convolution_3d > | complex_convolution_3d_ptr |
typedef SeparatedConvolution< double_complex, 4 > | complex_convolution_4d |
typedef std::shared_ptr< complex_convolution_4d > | complex_convolution_4d_ptr |
typedef SeparatedConvolution< double_complex, 5 > | complex_convolution_5d |
typedef std::shared_ptr< complex_convolution_5d > | complex_convolution_5d_ptr |
typedef SeparatedConvolution< double_complex, 6 > | complex_convolution_6d |
typedef std::shared_ptr< complex_convolution_6d > | complex_convolution_6d_ptr |
typedef Derivative< double_complex, 1 > | complex_derivative_1d |
typedef Derivative< double_complex, 2 > | complex_derivative_2d |
typedef Derivative< double_complex, 3 > | complex_derivative_3d |
typedef Derivative< double_complex, 4 > | complex_derivative_4d |
typedef Derivative< double_complex, 5 > | complex_derivative_5d |
typedef Derivative< double_complex, 6 > | complex_derivative_6d |
typedef FunctionFactory< double_complex, 1 > | complex_factory_1d |
typedef FunctionFactory< double_complex, 2 > | complex_factory_2d |
typedef FunctionFactory< double_complex, 3 > | complex_factory_3d |
typedef FunctionFactory< double_complex, 4 > | complex_factory_4d |
typedef FunctionFactory< double_complex, 5 > | complex_factory_5d |
typedef FunctionFactory< double_complex, 6 > | complex_factory_6d |
typedef FunctionImpl< double_complex, 1 > | complex_funcimpl_1d |
typedef FunctionImpl< double_complex, 2 > | complex_funcimpl_2d |
typedef FunctionImpl< double_complex, 3 > | complex_funcimpl_3d |
typedef FunctionImpl< double_complex, 4 > | complex_funcimpl_4d |
typedef FunctionImpl< double_complex, 5 > | complex_funcimpl_5d |
typedef FunctionImpl< double_complex, 6 > | complex_funcimpl_6d |
typedef Function< double_complex, 1 > | complex_function_1d |
typedef Function< double_complex, 2 > | complex_function_2d |
typedef Function< double_complex, 3 > | complex_function_3d |
typedef Function< double_complex, 4 > | complex_function_4d |
typedef Function< double_complex, 5 > | complex_function_5d |
typedef Function< double_complex, 6 > | complex_function_6d |
typedef Function< std::complex< double >, 3 > | complex_functionT |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 1 > > | complex_functor_1d |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 2 > > | complex_functor_2d |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 3 > > | complex_functor_3d |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 4 > > | complex_functor_4d |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 5 > > | complex_functor_5d |
typedef std::shared_ptr< FunctionFunctorInterface< double_complex, 6 > > | complex_functor_6d |
typedef Convolution1D< double_complex > | complex_operatorT |
typedef Tensor< double_complex > | complex_tensor |
typedef PthreadConditionVariable | CONDITION_VARIABLE_TYPE |
typedef Vector< double, 1 > | coord_1d |
typedef Vector< double, 2 > | coord_2d |
typedef Vector< double, 3 > | coord_3d |
typedef Vector< double, 4 > | coord_4d |
typedef Vector< double, 5 > | coord_5d |
typedef Vector< double, 6 > | coord_6d |
typedef Vector< double, 3 > | coordT |
typedef std::vector< complex_functionT > | cvecfuncT |
template<typename T > | |
using | decay_tuple = decltype(decay_types(std::declval< T >())) |
typedef DistributedMatrix< double > | distmatT |
typedef std::pair< uniqueidT, std::size_t > | DistributedID |
Distributed ID which is used to identify objects. More... | |
typedef FunctionFactory< double, 3 > | factoryT |
typedef FunctionDefaults< 1 > | function_defaults_1d |
typedef FunctionDefaults< 2 > | function_defaults_2d |
typedef FunctionDefaults< 3 > | function_defaults_3d |
typedef FunctionDefaults< 4 > | function_defaults_4d |
typedef FunctionDefaults< 5 > | function_defaults_5d |
typedef FunctionDefaults< 6 > | function_defaults_6d |
typedef Function< double, 3 > | functionT |
typedef std::shared_ptr< FunctionFunctorInterface< double, 3 > > | functorT |
template<typename T > | |
using | future_to_ref_t = typename future_to_ref< T >::type |
template<typename T , typename Archive > | |
using | has_freestanding_default_serialize_t = decltype(default_serialize(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive , typename = std::enable_if_t<std::is_pointer_v<T>>> | |
using | has_freestanding_default_serialize_with_size_t = decltype(default_serialize(std::declval< Archive & >(), std::declval< const T & >(), 1u)) |
template<typename T , typename Archive > | |
using | has_freestanding_serialize_t = decltype(serialize(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive , typename = std::enable_if_t<std::is_pointer_v<T>>> | |
using | has_freestanding_serialize_with_size_t = decltype(serialize(std::declval< Archive & >(), std::declval< T & >(), 1u)) |
template<typename T , typename Archive , typename = std::enable_if_t<!std::is_pointer_v<T>>> | |
using | has_freestanding_serialize_with_version_t = decltype(serialize(std::declval< Archive & >(), std::declval< T & >(), 0u)) |
template<typename T , typename Archive > | |
using | has_member_serialize_t = decltype(std::declval< T & >().serialize(std::declval< Archive & >())) |
template<typename T , typename Archive > | |
using | has_member_serialize_with_version_t = decltype(std::declval< T & >().serialize(std::declval< Archive & >(), 0u)) |
template<typename T , typename Archive > | |
using | has_nonmember_load_t = decltype(madness::archive::ArchiveLoadImpl< Archive, T >::load(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive > | |
using | has_nonmember_serialize_t = decltype(madness::archive::ArchiveSerializeImpl< Archive, T >::serialize(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive > | |
using | has_nonmember_store_t = decltype(madness::archive::ArchiveStoreImpl< Archive, T >::store(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive > | |
using | has_nonmember_wrap_load_t = decltype(madness::archive::ArchiveImpl< Archive, T >::wrap_load(std::declval< Archive & >(), std::declval< T & >())) |
template<typename T , typename Archive > | |
using | has_nonmember_wrap_store_t = decltype(madness::archive::ArchiveImpl< Archive, T >::wrap_store(std::declval< Archive & >(), std::declval< T & >())) |
typedef std::size_t | hashT |
The hash value type. More... | |
template<typename T , std::size_t NDIM> | |
using | intermediateT = Pairs< Function< T, NDIM > > |
f12 and g12 intermediates of the form <f1|op|f2> (with op=f12 or op=g12) will be saved using the pair structure More... | |
template<typename T > | |
using | is_archive_defined_t = typename is_archive< std::remove_reference_t< std::remove_cv_t< T > >>::type |
template<typename T > | |
using | is_input_archive_defined_t = typename is_input_archive< std::remove_reference_t< std::remove_cv_t< T > >>::type |
template<typename T > | |
using | is_output_archive_defined_t = typename is_output_archive< std::remove_reference_t< std::remove_cv_t< T > >>::type |
using | json = nlohmann::json |
typedef int | Level |
typedef NonlinearSolverND< 3 > | NonlinearSolver |
typedef XNonlinearSolver< std::vector< Function< double, 3 > >, double, vector_function_allocator< double, 3 > > | NonlinearVectorSolver_3d |
typedef XNonlinearSolver< std::vector< Function< double, 6 > >, double, vector_function_allocator< double, 6 > > | NonlinearVectorSolver_6d |
typedef SeparatedConvolution< double, 3 > | operatorT |
typedef std::pair< vecfuncT, vecfuncT > | pairvecfuncT |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 1 > > > | pmap_1d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 2 > > > | pmap_2d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 3 > > > | pmap_3d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 4 > > > | pmap_4d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 5 > > > | pmap_5d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 6 > > > | pmap_6d |
typedef std::shared_ptr< WorldDCPmapInterface< Key< 3 > > > | pmapT |
typedef std::shared_ptr< operatorT> | poperatorT |
typedef SeparatedConvolution< double, 1 > | real_convolution_1d |
typedef std::shared_ptr< real_convolution_1d > | real_convolution_1d_ptr |
typedef SeparatedConvolution< double, 2 > | real_convolution_2d |
typedef std::shared_ptr< real_convolution_2d > | real_convolution_2d_ptr |
typedef SeparatedConvolution< double, 3 > | real_convolution_3d |
typedef std::shared_ptr< real_convolution_3d > | real_convolution_3d_ptr |
typedef SeparatedConvolution< double, 4 > | real_convolution_4d |
typedef std::shared_ptr< real_convolution_4d > | real_convolution_4d_ptr |
typedef SeparatedConvolution< double, 5 > | real_convolution_5d |
typedef std::shared_ptr< real_convolution_5d > | real_convolution_5d_ptr |
typedef SeparatedConvolution< double, 6 > | real_convolution_6d |
typedef std::shared_ptr< real_convolution_6d > | real_convolution_6d_ptr |
typedef Derivative< double, 1 > | real_derivative_1d |
typedef Derivative< double, 2 > | real_derivative_2d |
typedef Derivative< double, 3 > | real_derivative_3d |
typedef Derivative< double, 4 > | real_derivative_4d |
typedef Derivative< double, 5 > | real_derivative_5d |
typedef Derivative< double, 6 > | real_derivative_6d |
typedef FunctionFactory< double, 1 > | real_factory_1d |
typedef FunctionFactory< double, 2 > | real_factory_2d |
typedef FunctionFactory< double, 3 > | real_factory_3d |
typedef FunctionFactory< double, 4 > | real_factory_4d |
typedef FunctionFactory< double, 5 > | real_factory_5d |
typedef FunctionFactory< double, 6 > | real_factory_6d |
typedef FunctionImpl< double, 1 > | real_funcimpl_1d |
typedef FunctionImpl< double, 2 > | real_funcimpl_2d |
typedef FunctionImpl< double, 3 > | real_funcimpl_3d |
typedef FunctionImpl< double, 4 > | real_funcimpl_4d |
typedef FunctionImpl< double, 5 > | real_funcimpl_5d |
typedef FunctionImpl< double, 6 > | real_funcimpl_6d |
typedef Function< double, 1 > | real_function_1d |
typedef Function< double, 2 > | real_function_2d |
typedef Function< double, 3 > | real_function_3d |
typedef Function< double, 4 > | real_function_4d |
typedef Function< double, 5 > | real_function_5d |
typedef Function< double, 6 > | real_function_6d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 1 > > | real_functor_1d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 2 > > | real_functor_2d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 3 > > | real_functor_3d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 4 > > | real_functor_4d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 5 > > | real_functor_5d |
typedef std::shared_ptr< FunctionFunctorInterface< double, 6 > > | real_functor_6d |
typedef Tensor< double > | real_tensor |
typedef std::ptrdiff_t | rel_fn_ptr_t |
template<typename T > | |
using | remove_fcvr_t = typename remove_fcvr< T >::type |
template<typename T > | |
using | remove_future_t = typename remove_future< T >::type |
C++11 version of REMFUTURE. More... | |
typedef std::vector< vector_real_function_3d > | response_matrix |
typedef void(* | rmi_handlerT) (void *buf, size_t nbyte) |
This is the generic low-level interface for a message handler. More... | |
typedef Mutex | SCALABLE_MUTEX_TYPE |
typedef Mutex | SPINLOCK_TYPE |
typedef tbb::split | Split |
Dummy class, a la Intel TBB, used to distinguish splitting constructor. More... | |
typedef std::vector< pairvecfuncT > | subspaceT |
typedef Tensor< double_complex > | tensor_complex |
typedef Tensor< double > | tensor_real |
typedef Tensor< double > | tensorT |
typedef int64_t | Translation |
typedef vector< functionT > | vecfuncT |
typedef std::vector< std::complex< double > > | vector_complex |
typedef std::vector< complex_function_1d > | vector_complex_function_1d |
typedef std::vector< complex_function_2d > | vector_complex_function_2d |
typedef std::vector< complex_function_3d > | vector_complex_function_3d |
typedef std::vector< complex_function_4d > | vector_complex_function_4d |
typedef std::vector< complex_function_5d > | vector_complex_function_5d |
typedef std::vector< complex_function_6d > | vector_complex_function_6d |
typedef std::vector< Vector< double, 1 > > | vector_coord_1d |
typedef std::vector< Vector< double, 2 > > | vector_coord_2d |
typedef std::vector< Vector< double, 3 > > | vector_coord_3d |
typedef std::vector< Vector< double, 4 > > | vector_coord_4d |
typedef std::vector< Vector< double, 5 > > | vector_coord_5d |
typedef std::vector< Vector< double, 6 > > | vector_coord_6d |
typedef std::vector< double > | vector_real |
typedef std::vector< real_function_1d > | vector_real_function_1d |
typedef std::vector< real_function_2d > | vector_real_function_2d |
typedef std::vector< real_function_3d > | vector_real_function_3d |
typedef std::vector< real_function_4d > | vector_real_function_4d |
typedef std::vector< real_function_5d > | vector_real_function_5d |
typedef std::vector< real_function_6d > | vector_real_function_6d |
Functions | |
static const Slice | _ (0,-1, 1) |
static const Slice | _reverse (-1, 0,-1) |
Entire tensor. More... | |
template<std::size_t NDIM> | |
Function< double, NDIM > | abs (const Function< double_complex, NDIM > &z, bool fence=true) |
Returns a new function that is the absolute value of the input. More... | |
template<typename Q , int NDIM> | |
Function< typename TensorTypeData< Q >::scalar_type, NDIM > | abs (const Function< Q, NDIM > &func) |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | abs (const Function< T, NDIM > &f, bool fence=true) |
Create a new function that is the abs of f - global comm only if not reconstructed. More... | |
template<class T > | |
Tensor< typename Tensor< T >::scalar_type > | abs (const Tensor< T > &t) |
Return a new tensor holding the absolute value of each element of t. More... | |
double | abs (double x) |
template<typename Q , int NDIM> | |
Function< typename TensorTypeData< Q >::scalar_type, NDIM > | abs_square (const Function< Q, NDIM > &func) |
template<typename T , std::size_t NDIM> | |
std::enable_if<!TensorTypeData< T >::iscomplex, Function< T, NDIM > >::type | abs_square (const Function< T, NDIM > &f, bool fence=true) |
Create a new function that is the abs_square of f - global comm only if not reconstructed. More... | |
template<typename T , std::size_t NDIM> | |
std::enable_if< TensorTypeData< T >::iscomplex, Function< typename Tensor< T >::scalar_type, NDIM > >::type | abs_square (const Function< T, NDIM > &f, bool fence=true) |
Create a new function that is the abs_square of f - global comm only if not reconstructed. More... | |
template<std::size_t NDIM> | |
Function< double, NDIM > | abssq (const Function< double_complex, NDIM > &z, bool fence=true) |
Returns a new function that is the square of the absolute value of the input. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > > | abssq (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Computes the square of a vector of functions — q[i] = abs(v[i])**2. More... | |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | add (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
Same as operator+ but with optional fence and no automatic compression. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Returns new vector of functions — q[i] = a + b[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true, unsigned int blk=1) |
Returns new vector of functions — q[i] = a + b[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const std::vector< Function< R, NDIM > > &b, const Function< T, NDIM > &a, bool fence=true) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const std::vector< Function< R, NDIM > > &b, const Function< T, NDIM > &a, bool fence=true, unsigned int blk=1) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Returns new vector of functions — q[i] = a[i] + b[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | add (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true, unsigned int blk=1) |
Returns new vector of functions — q[i] = a[i] + b[i]. More... | |
template<typename funcT > | |
funcT::returnT | adq (double lo, double hi, const funcT &func, double thresh) |
template<typename funcT > | |
funcT::returnT | adq1 (double lo, double hi, const funcT &func, double thresh, int n, const double *x, const double *w, int level) |
void | aligned_add (long n, double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b) |
void | aligned_add (long n, double_complex *MADNESS_RESTRICT a, const double_complex *MADNESS_RESTRICT b) |
template<typename T , typename Q > | |
static void | aligned_add (long n, T *MADNESS_RESTRICT a, const Q *MADNESS_RESTRICT b) |
template<> | |
void | aligned_axpy (long n, double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b, double s) |
template<> | |
void | aligned_axpy (long n, double_complex *MADNESS_RESTRICT a, const double_complex *MADNESS_RESTRICT b, double s) |
template<> | |
void | aligned_axpy (long n, double_complex *MADNESS_RESTRICT a, const double_complex *MADNESS_RESTRICT b, double_complex s) |
template<typename T , typename Q > | |
static void | aligned_axpy (long n, T *MADNESS_RESTRICT a, const T *MADNESS_RESTRICT b, Q s) |
void | aligned_sub (long n, double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b) |
void | aligned_sub (long n, double_complex *MADNESS_RESTRICT a, const double_complex *MADNESS_RESTRICT b) |
template<typename T , typename Q > | |
static void | aligned_sub (long n, T *MADNESS_RESTRICT a, const Q *MADNESS_RESTRICT b) |
template<typename T > | |
static void | aligned_zero (long n, T *a) |
AmArg * | alloc_am_arg (std::size_t nbyte) |
Allocates a new AmArg with nbytes of user data ... delete with free_am_arg. More... | |
static double | analytical_slater_functor (double rho) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | append (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
combine two vectors More... | |
complex_functionT | APPLY (const complex_operatorT *q1d, const complex_functionT &psi) |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | apply (const Derivative< T, NDIM > &D, const Function< T, NDIM > &f, bool fence=true) |
Applies derivative operator to function (for syntactic equivalence to integral operator apply) More... | |
template<typename opT , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | apply (const opT &op, const Function< R, NDIM > &f, bool fence=true) |
Apply operator in non-standard form. More... | |
template<typename opT , typename T , std::size_t LDIM> | |
Function< TENSOR_RESULT_TYPE(typename opT::opT, T), LDIM+LDIM > | apply (const opT &op, const std::vector< Function< T, LDIM >> &f1, const std::vector< Function< T, LDIM >> &f2, bool fence=true) |
Apply operator on a hartree product of two low-dimensional functions. More... | |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | apply (const ProjectorBase &projector, const CCPairFunction< T, NDIM > &argument) |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | apply (const ProjectorBase &projector, const std::vector< CCPairFunction< T, NDIM >> &argument) |
apply the projector on the argument function, potentially yielding a vector of CCPairfunctions as result More... | |
template<typename T , typename R , std::size_t NDIM, std::size_t KDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | apply (const SeparatedConvolution< T, KDIM > &op, const std::vector< Function< R, NDIM > > f) |
Applies an operator to a vector of functions — q[i] = apply(op,f[i]) More... | |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | apply (const SeparatedConvolution< T, NDIM > &G, const CCPairFunction< T, NDIM > &argument) |
apply the operator on a CCPairfunction, both with the same dimension More... | |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | apply (const SeparatedConvolution< T, NDIM > &G, const std::vector< CCPairFunction< T, NDIM >> &argument) |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | apply (const SeparatedConvolution< T, NDIM > &op, const std::vector< CCPairFunction< T, NDIM >> &argument) |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | apply (const SeparatedConvolution< T, NDIM/2 > &op, const CCPairFunction< T, NDIM > &arg) |
apply the operator to the argument More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | apply (const SeparatedConvolution< T, NDIM/2 > &op, const std::vector< CCPairFunction< T, NDIM >> &argument) |
apply the operator to the argument More... | |
template<class T , class Q > | |
TensorTrain< TENSOR_RESULT_TYPE(T, Q)> | apply (const TensorTrain< T > &op, const TensorTrain< Q > &t, const double thresh) |
apply an operator in TT format on a tensor in TT format More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | apply (World &world, const Derivative< T, NDIM > &D, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Applies a derivative operator to a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | apply (World &world, const Derivative< T, NDIM > &D, const std::vector< Function< T, NDIM > > &v, const unsigned int blk=1, const bool fence=true) |
Applies a derivative operator to a vector of functions. More... | |
template<typename T , typename R , std::size_t NDIM, std::size_t KDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | apply (World &world, const SeparatedConvolution< T, KDIM > &op, const std::vector< Function< R, NDIM > > f) |
Applies an operator to a vector of functions — q[i] = apply(op,f[i]) More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | apply (World &world, const SeparatedConvolution< T, NDIM > &op, const std::vector< Function< R, NDIM > > f, const unsigned int blk=1) |
Applies an operator to a vector of functions — q[i] = apply(op,f[i]) More... | |
template<typename opT , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > > | apply (World &world, const std::vector< std::shared_ptr< opT > > &op, const std::vector< Function< R, NDIM > > f) |
Applies a vector of operators to a vector of functions — q[i] = apply(op[i],f[i]) More... | |
template<typename opT , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > > | apply (World &world, const std::vector< std::shared_ptr< opT > > &op, const std::vector< Function< R, NDIM > > f, const unsigned int blk=1) |
Applies a vector of operators to a vector of functions — q[i] = apply(op[i],f[i]) More... | |
response_space | apply (World &world, real_derivative_3d &op, response_space &f) |
response_space | apply (World &world, std::vector< std::shared_ptr< real_convolution_3d >> &op, response_space &f) |
response_space | apply (World &world, std::vector< std::vector< std::shared_ptr< real_convolution_3d >>> &op, response_space &f) |
template<typename opT , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | apply_1d_realspace_push (const opT &op, const Function< R, NDIM > &f, int axis, bool fence=true) |
template<typename opT , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(typename opT::opT, R), NDIM > | apply_only (const opT &op, const Function< R, NDIM > &f, bool fence=true) |
Apply operator ONLY in non-standard form - required other steps missing !! More... | |
template<class T > | |
Tensor< typename Tensor< T >::scalar_type > | arg (const Tensor< T > &t) |
Return a new tensor holding the argument of each element of t (complex types only) More... | |
CalcType | assign_calctype (const std::string name) |
Assigns enum to string. More... | |
std::string | assign_name (const CalcType &inp) |
Assigns strings to enums for formated output. More... | |
std::string | assign_name (const CCState &input) |
Assigns strings to enums for formated output. More... | |
std::string | assign_name (const FuncType &inp) |
Assigns strings to enums for formated output. More... | |
std::string | assign_name (const PotentialType &inp) |
Assigns strings to enums for formated output. More... | |
std::string | atomic_number_to_symbol (const unsigned int atomic_number) |
return the lower-case element symbol corresponding to the atomic number More... | |
bool | autoc (int k, Tensor< double > *c) |
Return the autocorrelation coefficients for scaling functions of given order. More... | |
void | bandlimited_propagator_plot () |
void | begin_papi_measurement () |
void | bgq_mtxmq_padded (long dimi, long dimj, long dimk, long extb, __complex__ double *c_x, const __complex__ double *a_x, const __complex__ double *b_x) |
void | bgq_mtxmq_padded (long dimi, long dimj, long dimk, long extb, __complex__ double *c_x, const __complex__ double *a_x, const double *b_x) |
void | bgq_mtxmq_padded (long dimi, long dimj, long dimk, long extb, __complex__ double *c_x, const double *a_x, const __complex__ double *b_x) |
void | bgq_mtxmq_padded (long dimi, long dimj, long dimk, long extb, double *c_x, const double *a_x, const double *b_x) |
template<typename L , typename R , typename opT , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | binary_op (const Function< L, NDIM > &left, const Function< R, NDIM > &right, const opT &op, bool fence=true) |
Generate new function = op(left,right) where op acts on the function values. More... | |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > | BSHOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Factory function generating separated kernel for convolution with BSH kernel in general NDIM. More... | |
static SeparatedConvolution< double, 3 > | BSHOperator3D (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D. More... | |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > * | BSHOperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Factory function generating separated kernel for convolution with BSH kernel in general NDIM. More... | |
static SeparatedConvolution< double, 3 > * | BSHOperatorPtr3D (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D. More... | |
int | c_rks_vwn5__ (const double *r__, double *f, double *dfdra) |
int | c_uks_vwn5__ (double *ra, double *rb, double *f, double *dfdra, double *dfdrb) |
template<typename T , std::size_t NDIM> | |
std::shared_ptr< CCConvolutionOperator< T, NDIM > > | CCConvolutionOperatorPtr (World &world, const OpType type, typename CCConvolutionOperator< T, NDIM >::Parameters param) |
template<typename T > | |
void | change_tensor_type (GenTensor< T > &t, const TensorArgs &targs) |
change representation to targ.tt More... | |
template<typename T , std::size_t NDIM> | |
const std::vector< Function< T, NDIM > > & | change_tree_state (const std::vector< Function< T, NDIM >> &v, const TreeState finalstate, const bool fence=true) |
change tree state of the functions More... | |
template<typename T > | |
static std::enable_if< std::is_floating_point< T >::value, void >::type | check_for_inf (const std::string &str, T &arg) |
template<typename T > | |
static std::enable_if<!std::is_floating_point< T >::value, void >::type | check_for_inf (const std::string &str, T &arg) |
bool | check_if_pseudo_atom (const std::string &symbol) |
template<typename C > | |
void | check_linear_dependence (const Tensor< C > &Q, Tensor< C > &c, const double rcondtol, const double cabsmax, bool do_print=true) |
check for subspace linear dependency More... | |
unsigned long | checksum_file (const char *filename) |
Simple checksum for ASCII characters in file. More... | |
template<> | |
void | cholesky (char uplo, integer n, complex_real4 *A, integer lda) |
template<> | |
void | cholesky (char uplo, integer n, complex_real8 *A, integer lda) |
template<> | |
void | cholesky (char uplo, integer n, real4 *A, integer lda) |
template<> | |
void | cholesky (char uplo, integer n, real8 *A, integer lda) |
template<typename T > | |
void | cholesky (char uplo, integer n, T *A, integer lda) |
Compute the Cholesky Factorization via LAPACK. More... | |
template void | cholesky (Tensor< double > &A) |
template void | cholesky (Tensor< double_complex > &A) |
template<typename T > | |
void | cholesky (Tensor< T > &A) |
Compute the Cholesky factorization. More... | |
template<typename T > | |
DistributedMatrix< T > | column_distributed_matrix (World &world, int64_t n, int64_t m, int64_t coltile=0) |
Generates an (n,m) matrix distributed by columns (row dimension is not distributed) More... | |
static DistributedMatrixDistribution | column_distributed_matrix_distribution (World &world, int64_t n, int64_t m, int64_t coltile) |
Generates distribution for an (n,m) matrix distributed by columns (row dimension is not distributed) More... | |
template<typename T , std::size_t NDIM> | |
const std::vector< Function< T, NDIM > > & | compress (const std::vector< Function< T, NDIM > > &v) |
compress a vector of functions More... | |
template<typename T , std::size_t NDIM> | |
void | compress (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Compress a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
void | compress (World &world, const std::vector< Function< T, NDIM > > &v, unsigned int blk=1, bool fence=true) |
Compress a vector of functions. More... | |
template<typename T > | |
DistributedMatrix< T > | concatenate_columns (const DistributedMatrix< T > &a, const DistributedMatrix< T > &b) |
Generates a row-distributed matrix with rows of a and b contatenated. More... | |
template<typename T > | |
DistributedMatrix< T > | concatenate_rows (const DistributedMatrix< T > &a, const DistributedMatrix< T > &b) |
Generates a column-distributed matrix with rows of a and b contatenated. More... | |
template<typename T > | |
DistributedMatrix< T > | concatenate_rows (const DistributedMatrix< T > &a, const DistributedMatrix< T > &b, const DistributedMatrix< T > &c, const DistributedMatrix< T > &d) |
Generates a column-distributed matrix with rows of a , b , c , and d contatenated in order. More... | |
template<typename Q > | |
Q | conditional_conj (const Q &coeff) |
For real types return value, for complex return conjugate. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | conj (const Function< T, NDIM > &f, bool fence=true) |
Return the complex conjugate of the input function with the same distribution and optional fence. More... | |
template<class T > | |
Tensor< T > | conj (const Tensor< T > &t) |
Returns a new deep copy of the complex conjugate of the input tensor (complex types only) More... | |
double | conj (double x) |
double | conj (float x) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | conj (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Returns the complex conjugate of the vector of functions. More... | |
template<class T > | |
Tensor< T > | conj_transpose (const Tensor< T > &t) |
Returns a new deep copy of the complex conjugate transpose of the input tensor. More... | |
template<typename T , typename Q , std::size_t NDIM> | |
Function< Q, NDIM > | convert (const Function< T, NDIM > &f, bool fence=true) |
Type conversion implies a deep copy. No communication except for optional fence. More... | |
template<class Q , class T > | |
GenTensor< Q > | convert (const GenTensor< T > &other) |
type conversion implies a deep copy More... | |
template<class Q , class T > | |
Tensor< Q > | convert (const Tensor< T > &t) |
Returns a new contiguous tensor of type Q that is a deep copy of the input. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< R, NDIM > > | convert (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Returns a deep copy of a vector of functions. More... | |
template<typename T > | |
DistributedMatrix< T > | copy (const DistributedMatrix< T > &A) |
Deep copy of content. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | copy (const Function< T, NDIM > &f, bool fence=true) |
Create a new copy of the function with the same distribution and optional fence. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | copy (const Function< T, NDIM > &f, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true) |
Create a new copy of the function with different distribution and optional fence. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | copy (const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Returns a deep copy of a vector of functions. More... | |
template<class T > | |
Tensor< T > | copy (const Tensor< T > &t) |
Returns a new contiguous tensor that is a deep copy of the input. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | copy (World &world, const Function< T, NDIM > &v, const unsigned int n, bool fence=true) |
Returns a vector of n deep copies of a function. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | copy (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Returns a deep copy of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | copy (World &world, const std::vector< Function< T, NDIM >> &v, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM >>> &pmap, bool fence=true) |
Returns a deep copy of a vector of functions. More... | |
template<typename T > | |
static void | copy_2d_patch (T *MADNESS_RESTRICT out, long ldout, const T *MADNESS_RESTRICT in, long ldin, long n, long m) |
AmArg * | copy_am_arg (const AmArg &arg) |
static SeparatedConvolution< double, 3 > | CoulombOperator (World &world, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with 1/r in 3D. More... | |
static SeparatedConvolution< double, 3 > * | CoulombOperatorPtr (World &world, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with 1/r in 3D. More... | |
double | cpu_frequency () |
Estimate the processor frequency, in Hz. More... | |
void | cpu_relax () |
Do nothing and especially do not touch memory. More... | |
static double | cpu_time () |
Returns the cpu time in seconds relative to an arbitrary origin. More... | |
std::shared_ptr< NuclearCorrelationFactor > | create_nuclear_correlation_factor (World &world, const Molecule &molecule, const std::shared_ptr< PotentialManager > pm, const std::pair< std::string, double > &ncf) |
std::shared_ptr< NuclearCorrelationFactor > | create_nuclear_correlation_factor (World &world, const Molecule &molecule, const std::shared_ptr< PotentialManager > potentialmanager, const std::string inputline) |
create and return a new nuclear correlation factor More... | |
auto | create_response_matrix (const size_t &num_states, const size_t &num_orbitals) -> response_matrix |
Create a response matrix object. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | cross (const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool do_refine=false, bool fence=true) |
shorthand cross operator More... | |
template<typename T , std::size_t N> | |
std::enable_if< N==3, Vector< T, N > >::type | cross (const Vector< T, N > &l, const Vector< T, N > &r) |
compute the cross product two Vector s of dimension 3 More... | |
std::uint64_t | cstr_to_memory_size (const char *str) |
Unit-aware conversion of a C string to a size_t. More... | |
std::vector< std::string > | cubefile_header (std::string filename="input", const bool &no_orient=false) |
static uint64_t | cycle_count () |
On some machines we have access to a cycle count. More... | |
double | d2smoothed_potential (double r) |
second radial derivative of the regularized 1/r potential More... | |
template<typename ... Ts> | |
constexpr auto | decay_types (std::tuple< Ts... > const &) -> std::tuple< std::remove_cv_t< std::remove_reference_t< Ts >>... > |
template<size_t NDIM> | |
Key< NDIM > | displacement (const Key< NDIM > &source, const Key< NDIM > &target) |
given a source and a target, return the displacement in translation More... | |
double | distance (const Fred &a, const Fred &b) |
double | distance (double a, double b) |
Default function for computing the distance between two doubles. More... | |
static double | distance (double x1, double y1, double z1, double x2, double y2, double z2) |
double | distance (madness::Function< std::complex< double >, 1ul > &a, madness::Function< std::complex< double >, 1ul > &b) |
template<typename T > | |
double | distance (std::complex< T > &a, std::complex< T > &b) |
Default function for computing the distance between two complex numbers. More... | |
static double | distance_sq (double x1, double y1, double z1, double x2, double y2, double z2) |
DistributedMatrix< double > | distributed_localize_PM (World &world, const std::vector< Function< double, 3 >> &mo, const std::vector< Function< double, 3 >> &ao, const std::vector< int > &set, const std::vector< int > &at_to_bf, const std::vector< int > &at_nbf, const double thresh=1e-9, const double thetamax=0.5, const bool randomize=true, const bool doprint=false) |
DistributedMatrix< double > | distributed_localize_PM (World &world, const vecfuncT &mo, const vecfuncT &ao, const std::vector< int > &set, const std::vector< int > &at_to_bf, const std::vector< int > &at_nbf, const double thresh, const double thetamax, const bool randomize, const bool doprint) |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | div (const std::vector< Function< T, NDIM > > &v, bool do_refine=false, bool fence=true) |
shorthand div operator More... | |
template<typename funcT > | |
funcT::returnT | do_adq (double lo, double hi, const funcT &func, int n, const double *x, const double *w) |
void | do_response_density_vtk_plots (World &world, int npt_plot, double L, const Molecule &molecule, const real_function_3d &ground_density, const vector_real_function_3d &response_density) |
void | do_response_orbital_vtk_plots (World &world, int npt_plot, double L, const Molecule &molecule, const vector_real_function_3d &ground_orbs, const response_matrix &responseMatrix) |
void | do_vtk_plots (World &world, int npt_plot, double L, int lowest_orbital, int highest_orbital, const Molecule &molecule, std::vector< real_function_3d > densities, const std::string &name) |
void | do_vtk_plots (World &world, int npt_plot, double L, Molecule molecule, real_function_3d &rho_0, std::vector< real_function_3d > &rho_omega, std::vector< real_function_3d > &ground_orbitals, X_space &Chi) |
template<typename T , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(T, R), NDIM > | dot (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Multiplies and sums two vectors of functions r = \sum_i a[i] * b[i]. More... | |
DPEC (double, double, double) | |
DPEC (double_complex, double_complex, double_complex) | |
DPEC (float, float, float) | |
DPEC (float_complex, float_complex, float_complex) | |
DPEC (int, int, int) | |
DPEC (long, long, long) | |
void | drot (long n, double *MADNESS_RESTRICT a, double *MADNESS_RESTRICT b, double s, double c, long inc) |
Simple (?) version of BLAS-1 DROT(N, DX, INCX, DY, INCY, DC, DS) More... | |
double | dsmoothed_potential (double r) |
Derivative of the regularized 1/r potential. More... | |
static void | dxprintvalue (FILE *f, const double t) |
static void | dxprintvalue (FILE *f, const double_complex &t) |
void | end_papi_measurement () |
static void | END_TIMER (World &world, const char *msg) |
static bool | enforce_bc (bool is_periodic, Level n, Translation &l) |
void | error (const char *msg) |
template<typename T > | |
static void | error (const char *msg, const T &data) |
Prints an error message, along with some data, and aborts the program. More... | |
double | estimate_area (double x) |
void | exception_break (bool message) |
This function is executed just before a MadnessException is thrown. More... | |
template<typename T > | |
int | exchange_anchor_test (World &world, Exchange< T, 3 > &K, const double thresh) |
anchor test for the exchange operator – partially hardwired More... | |
static SeparatedConvolution< double, 3 > | F2GOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with (1/(2 mu)*(1 - exp(-mu*r)))^2/r in 3D. More... | |
static SeparatedConvolution< double, 3 > * | F2GOperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with (1/(2 mu)*(1 - exp(-mu*r)))^2/r in 3D. More... | |
template<class T , class Q > | |
Tensor< TENSOR_RESULT_TYPE(T, Q) > & | fast_transform (const Tensor< T > &t, const Tensor< Q > &c, Tensor< TENSOR_RESULT_TYPE(T, Q) > &result, Tensor< TENSOR_RESULT_TYPE(T, Q) > &workspace) |
Restricted but heavily optimized form of transform() More... | |
template<typename T > | |
void | fast_transpose (long n, long m, const T *a, T *MADNESS_RESTRICT b) |
a(n,m) --> b(m,n) ... optimized for smallish matrices More... | |
template<typename T , std::size_t NDIM> | |
Tensor< T > | fcube (const Key< NDIM > &, T(*f)(const Vector< double, NDIM > &), const Tensor< double > &) |
template<typename T , std::size_t NDIM> | |
Tensor< T > | fcube (const Key< NDIM > &key, const FunctionFunctorInterface< T, NDIM > &f, const Tensor< double > &qx) |
template<typename T , std::size_t NDIM> | |
void | fcube (const Key< NDIM > &key, const FunctionFunctorInterface< T, NDIM > &f, const Tensor< double > &qx, Tensor< T > &fval) |
forward declaration More... | |
static SeparatedConvolution< double, 3 > | FGOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with 1/(2 mu)*(1 - exp(-mu*r))/r in 3D. More... | |
static SeparatedConvolution< double, 3 > * | FGOperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with 1/(2 mu)*(1 - exp(-mu*r))/r in 3D. More... | |
void | finalize () |
Call this once at the very end of your main program instead of MPI_Finalize(). More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | flatten (const std::vector< std::vector< Function< T, NDIM > > > &vv) |
template<std::size_t NDIM, typename objT > | |
void | foreach_child (const Key< NDIM > &parent, objT *obj, void(objT::*memfun)(const Key< NDIM > &)) |
Applies member function of obj to each child key of parent. More... | |
template<std::size_t NDIM, typename opT > | |
void | foreach_child (const Key< NDIM > &parent, opT &op) |
Applies op(key) to each child key of parent. More... | |
void | free_am_arg (AmArg *arg) |
Frees an AmArg allocated with alloc_am_arg. More... | |
template<typename T , std::size_t NDIM> | |
Derivative< T, NDIM > | free_space_derivative (World &world, int axis, int k=FunctionDefaults< NDIM >::get_k()) |
Convenience function returning derivative operator with free-space boundary conditions. More... | |
void | from_json (const nlohmann::json &, ResponseParameters &p) |
std::shared_ptr< FunctionFunctorInterface< double, 3 > > | func (new opT(g)) |
template<typename Q , int NDIM> | |
Function< std::complex< Q >, NDIM > | function_real2complex (const Function< Q, NDIM > &r) |
static double | functor_r2 (const coord_3d &r) |
static double | functor_x (const coord_3d &r) |
static double | functor_y (const coord_3d &r) |
template<typename T > | |
std::vector< Future< T > > | future_vector_factory (std::size_t n) |
Factory for a vectors of futures. More... | |
bool | gauss_legendre (int n, double xlo, double xhi, double *x, double *w) |
bool | gauss_legendre_numeric (int n, double xlo, double xhi, double *x, double *w) |
Compute the Gauss-Legendre quadrature points and weights. More... | |
bool | gauss_legendre_test (bool print) |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > | GaussOperator (World &world, double mu, double lo=0.0, double eps=0.0, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r*r) More... | |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > * | GaussOperatorPtr (World &world, double mu, double lo=0.0, double eps=0.0, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r*r) in 3D. More... | |
template<typename T > | |
void | gaxpy (const double a, ScalarResult< T > &left, const double b, const T &right, const bool fence=true) |
the result type of a macrotask must implement gaxpy More... | |
template<typename T , typename Q , typename R , std::size_t NDIM> | |
void | gaxpy (Q alpha, std::vector< Function< T, NDIM >> &a, Q beta, const std::vector< Function< R, NDIM >> &b, const bool fence) |
Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i]. More... | |
template<typename L , typename R , std::size_t NDIM> | |
void | gaxpy (TENSOR_RESULT_TYPE(L, R) alpha, Function< L, NDIM > &left, TENSOR_RESULT_TYPE(L, R) beta, const Function< R, NDIM > &right, bool fence=true) |
adds beta*right only left: alpha*left + beta*right optional fence and no automatic compression More... | |
template<typename T , typename Q , typename R , std::size_t NDIM> | |
void | gaxpy (World &world, Q alpha, std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i]. More... | |
template<typename T , typename Q , typename R , std::size_t NDIM> | |
void | gaxpy (World &world, Q alpha, std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, unsigned int blk=1, bool fence=true) |
Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i]. More... | |
template<typename T , typename Q , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(Q, TENSOR_RESULT_TYPE(T, R)), NDIM > > | gaxpy_oop (Q alpha, const std::vector< Function< T, NDIM > > &a, Q beta, const Function< R, NDIM > &b, bool fence=true) |
out-of-place gaxpy for a vectors and a function: result[i] = alpha * a[i] + beta * b More... | |
template<typename T , typename Q , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(Q, TENSOR_RESULT_TYPE(T, R)), NDIM > > | gaxpy_oop (Q alpha, const std::vector< Function< T, NDIM > > &a, Q beta, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
out-of-place gaxpy for two vectors: result[i] = alpha * a[i] + beta * b[i] More... | |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | gaxpy_oop (TENSOR_RESULT_TYPE(L, R) alpha, const Function< L, NDIM > &left, TENSOR_RESULT_TYPE(L, R) beta, const Function< R, NDIM > &right, bool fence=true) |
Returns new function alpha*left + beta*right optional fence and no automatic compression. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | gaxpy_oop_reconstructed (const double alpha, const Function< T, NDIM > &left, const double beta, const Function< T, NDIM > &right, const bool fence=true) |
Returns new function alpha*left + beta*right optional fence, having both addends reconstructed. More... | |
template void | geev (const Tensor< double > &A, Tensor< double > &V, Tensor< double_complex > &e) |
template<typename T > | |
void | geev (const Tensor< T > &A, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
Real non-symmetric or complex non-Hermitian eigenproblem. More... | |
template<typename T > | |
void | geevp (World &world, const Tensor< T > &A, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
template void | gelss (const Tensor< double > &a, const Tensor< double > &b, double rcond, Tensor< double > &x, Tensor< Tensor< double >::scalar_type > &s, long &rank, Tensor< Tensor< double >::scalar_type > &sumsq) |
template void | gelss (const Tensor< double_complex > &a, const Tensor< double_complex > &b, double rcond, Tensor< double_complex > &x, Tensor< Tensor< double_complex >::scalar_type > &s, long &rank, Tensor< Tensor< double_complex >::scalar_type > &sumsq) |
template<typename T > | |
void | gelss (const Tensor< T > &a, const Tensor< T > &b, double rcond, Tensor< T > &x, Tensor< typename Tensor< T >::scalar_type > &s, long &rank, Tensor< typename Tensor< T >::scalar_type > &sumsq) |
Solve Ax = b for general A using the LAPACK *gelss routines. More... | |
template<typename R , typename Q > | |
GenTensor< TENSOR_RESULT_TYPE(R, Q)> | general_transform (const GenTensor< R > &t, const Tensor< Q > c[]) |
template<typename R , typename Q > | |
SVDTensor< TENSOR_RESULT_TYPE(R, Q)> | general_transform (const SVDTensor< R > &t, const Tensor< Q > c[]) |
template<class T , class Q > | |
Tensor< TENSOR_RESULT_TYPE(T, Q)> | general_transform (const Tensor< T > &t, const Tensor< Q > c[]) |
Transform all dimensions of the tensor t by distinct matrices c. More... | |
template<class T , class Q > | |
TensorTrain< TENSOR_RESULT_TYPE(T, Q)> | general_transform (const TensorTrain< T > &t, const Tensor< Q > c[]) |
Transform all dimensions of the tensor t by distinct matrices c. More... | |
template void | geqp3 (Tensor< double > &A, Tensor< double > &tau, Tensor< integer > &jpvt) |
template void | geqp3 (Tensor< double_complex > &A, Tensor< double_complex > &tau, Tensor< integer > &jpvt) |
template<typename T > | |
void | geqp3 (Tensor< T > &A, Tensor< T > &tau, Tensor< integer > &jpvt) |
Compute the QR factorization. More... | |
template<typename T > | |
void | geqp3_result (Tensor< T > &A, Tensor< T > &tau, Tensor< integer > &jpvt, Tensor< T > &work) |
template void | gesv (const Tensor< double > &a, const Tensor< double > &b, Tensor< double > &x) |
template void | gesv (const Tensor< double_complex > &a, const Tensor< double_complex > &b, Tensor< double_complex > &x) |
template<typename T > | |
void | gesv (const Tensor< T > &a, const Tensor< T > &b, Tensor< T > &x) |
Solve Ax = b for general A using the LAPACK *gesv routines. More... | |
template<typename T > | |
void | gesvp (World &world, const Tensor< T > &a, const Tensor< T > &b, Tensor< T > &x) |
const AtomicData & | get_atomic_data (unsigned int atomic_number) |
double | get_charge_from_file (const std::string filename, unsigned int atype) |
template<typename T , std::size_t NDIM> | |
std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > | get_impl (const std::vector< Function< T, NDIM >> &v) |
template<typename tupleT , std::size_t I> | |
constexpr std::size_t | get_index_of_first_vector_argument () |
given a tuple return the index of the first argument that is a vector of Function<T,NDIM> More... | |
template<typename tupleT , std::size_t I> | |
constexpr std::size_t | get_index_of_second_vector_argument () |
given a tuple return the index of the second argument that is a vector of Function<T,NDIM> More... | |
std::string | get_mra_data_dir () |
const long long * | get_papi_measurement () |
template<typename T , std::size_t NDIM> | |
double | get_size (const Function< T, NDIM > &f) |
template<typename T , std::size_t NDIM> | |
double | get_size (World &world, const std::vector< Function< T, NDIM > > &v) |
template void | ggev (const Tensor< double > &A, Tensor< double > &B, Tensor< double > &V, Tensor< double_complex > &e) |
template<typename T > | |
void | ggev (const Tensor< T > &A, Tensor< T > &B, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
Generalized real-non-symmetric or complex-non-Hermitian eigenproblem. More... | |
template<typename T > | |
void | ggevp (World &world, const Tensor< T > &A, Tensor< T > &B, Tensor< T > &VR, Tensor< std::complex< T >> &e) |
template<typename T , typename real_type , typename scalar_type > | |
void | GMRES (const AbstractVectorSpace< T, real_type, scalar_type > &space, const Operator< T > &op, const T &b, T &x, int &maxiters, real_type &resid_thresh, real_type &update_thresh, const bool outp=false) |
A GMRES solver routine for linear systems, . More... | |
void | gprofexit (int id, int nproc) |
Rename gmon.out for each process by ordering process termination. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
shorthand gradient operator More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad_ble_one (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad_ble_two (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad_bpsline_two (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad_bspline_one (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | grad_bspline_three (const Function< T, NDIM > &f, bool refine=false, bool fence=true) |
static std::vector< std::shared_ptr< SeparatedConvolution< double, 3 > > > | GradBSHOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating operator for convolution with grad(bsh) in 3D. More... | |
static std::vector< std::shared_ptr< SeparatedConvolution< double, 3 > > > | GradCoulombOperator (World &world, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating operator for convolution with grad(1/r) in 3D. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< std::shared_ptr< Derivative< T, NDIM > > > | gradient_operator (World &world, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Convenience function returning vector of derivative operators implementing grad ( ) More... | |
static std::vector< std::shared_ptr< SeparatedConvolution< double, 3 > > > | GradSlaterOperator (World &world, double gamma, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating operator for convolution with grad(e^{-\gamma*r}) in 3D. More... | |
template<typename T , std::size_t KDIM, std::size_t LDIM> | |
Function< T, KDIM+LDIM > | hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2) |
Performs a Hartree product on the two given low-dimensional functions. More... | |
template<typename T , std::size_t KDIM, std::size_t LDIM, typename opT > | |
Function< T, KDIM+LDIM > | hartree_product (const Function< T, KDIM > &left2, const Function< T, LDIM > &right2, const opT &op) |
Performs a Hartree product on the two given low-dimensional functions. More... | |
template<typename T , std::size_t KDIM, std::size_t LDIM> | |
Function< T, KDIM+LDIM > | hartree_product (const std::vector< Function< T, KDIM >> &left, const std::vector< Function< T, LDIM >> &right) |
Performs a Hartree/outer product on the two given low-dimensional function vectors. More... | |
template<class T > | |
void | hash_combine (hashT &seed, const T &v) |
Combine hash values. More... | |
template<class T > | |
hashT | hash_range (const T *t, std::size_t n) |
Combine the hash values of a pointer range. More... | |
template<class T , std::size_t n> | |
hashT | hash_range (const T(&t)[n]) |
Combine the hash values of a C-style array. More... | |
template<class T > | |
std::enable_if< std::is_fundamental< T >::value >::type | hash_range (hashT &seed, const T *t, std::size_t n) |
Combine the hash values of a pointer range. More... | |
template<class T > | |
std::enable_if<!std::is_fundamental< T >::value >::type | hash_range (hashT &seed, const T *t, std::size_t n) |
Combine the hash values of a pointer range. More... | |
template<class T , std::size_t n> | |
void | hash_range (hashT &seed, const T(&t)[n]) |
Combine the hash values of a C-style array. More... | |
template<class It > | |
void | hash_range (hashT &seed, It first, It last) |
template<class It > | |
hashT | hash_range (It first, It last) |
Combine the hash values of an iterator range. More... | |
template<typename T , std::size_t N> | |
madness::hashT | hash_value (const std::array< T, N > &a) |
Hash std::array with madness hash. More... | |
template<typename T > | |
hashT | hash_value (const std::basic_string< T > &t) |
Hash a std::basic_string. More... | |
template<typename T , typename R > | |
hashT | hash_value (const std::pair< T, R > &t) |
Hash a std::pair. More... | |
template<typename T > | |
auto | hash_value (const T &t) |
Hash a class object. More... | |
template<typename T > | |
hashT | hash_value (const T *t) |
Hash a pointer address. More... | |
template<class T > | |
std::enable_if< std::is_fundamental< T >::value &&((sizeof(T)%sizeof(uint32_t))==0), hashT >::type | hash_value (const T t) |
Hash a single fundamental object. More... | |
template<class T > | |
std::enable_if< std::is_fundamental< T >::value &&((sizeof(T)%sizeof(uint32_t)) !=0), hashT >::type | hash_value (const T t) |
Hash a single fundamental object. More... | |
hashT | hash_value (const uniqueidT &id) |
Hash a uniqueidT . More... | |
template<> | |
void | hereig (char jobz, char uplo, integer n, complex_real4 *A, integer lda, real4 *W) |
template<> | |
void | hereig (char jobz, char uplo, integer n, complex_real8 *A, integer lda, real8 *W) |
template<> | |
void | hereig (char jobz, char uplo, integer n, real4 *A, integer lda, real4 *W) |
template<> | |
void | hereig (char jobz, char uplo, integer n, real8 *A, integer lda, real8 *W) |
template<typename T > | |
void | hereig (char jobz, char uplo, integer n, T *A, integer lda, typename detail::real_type< T >::type *W) |
Solve the EVP via LAPACK. More... | |
template<> | |
void | hereig_gen (integer itype, char jobz, char uplo, integer n, complex_real4 *A, integer lda, complex_real4 *B, integer ldb, real4 *W) |
template<> | |
void | hereig_gen (integer itype, char jobz, char uplo, integer n, complex_real8 *A, integer lda, complex_real8 *B, integer ldb, real8 *W) |
template<> | |
void | hereig_gen (integer itype, char jobz, char uplo, integer n, real4 *A, integer lda, real4 *B, integer ldb, real4 *W) |
template<> | |
void | hereig_gen (integer itype, char jobz, char uplo, integer n, real8 *A, integer lda, real8 *B, integer ldb, real8 *W) |
template<typename T > | |
void | hereig_gen (integer itype, char jobz, char uplo, integer n, T *A, integer lda, T *B, integer ldb, typename detail::real_type< T >::type *W) |
Solve the Generalized EVP via LAPACK. More... | |
template<std::size_t NDIM> | |
Function< double, NDIM > | imag (const Function< double_complex, NDIM > &z, bool fence=true) |
Returns a new function that is the imaginary part of the input. More... | |
template<typename Q , int NDIM> | |
Function< typename TensorTypeData< Q >::scalar_type, NDIM > | imag (const Function< Q, NDIM > &func) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > > | imag (const std::vector< Function< T, NDIM > > &v, bool fence=true) |
return the imaginary parts of the vector's function (if complex) More... | |
template<class T > | |
Tensor< typename Tensor< T >::scalar_type > | imag (const Tensor< T > &t) |
Return a new tensor holding the imaginary part of each element of t (complex types only) More... | |
double | imag (double x) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | impl2function (const std::vector< std::shared_ptr< FunctionImpl< T, NDIM >>> vimpl) |
void | init_tensor_lapack () |
World/MRA initialization calls this before going multithreaded due to static data in dlamch . More... | |
World & | initialize (int &argc, char **&argv, bool quiet) |
World & | initialize (int &argc, char **&argv, const MPI_Comm &comm, int nthread, bool quiet) |
World & | initialize (int &argc, char **&argv, const SafeMPI::Intracomm &comm, bool quiet) |
World & | initialize (int &argc, char **&argv, const SafeMPI::Intracomm &comm, int nthread, bool quiet) |
World & | initialize (int &argc, char **&argv, int nthread, bool quiet) |
void | initialize_legendre_stuff () |
Call this single threaded to initialize static data (used read only by multiple threads) More... | |
void | initialize_papi () |
bool | initialized () |
Check if the MADNESS runtime has been initialized (and not subsequently finalized). More... | |
template<typename T , std::size_t NDIM> | |
Function< T, CCPairFunction< T, NDIM >::LDIM > | inner (const CCPairFunction< T, NDIM > &c, const Function< T, CCPairFunction< T, NDIM >::LDIM > &f, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v1, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v2) |
template<typename T , std::size_t NDIM> | |
Function< T, CCPairFunction< T, NDIM >::LDIM > | inner (const CCPairFunction< T, NDIM > &c, const Function< T, CCPairFunction< T, NDIM >::LDIM > &f, const std::tuple< int, int, int > v1, const std::tuple< int, int, int > v2) |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | inner (const CCPairFunction< T, NDIM > &c1, const CCPairFunction< T, NDIM > &c2, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v1, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v2) |
template<typename T , std::size_t NDIM> | |
CCPairFunction< T, NDIM > | inner (const CCPairFunction< T, NDIM > &c1, const CCPairFunction< T, NDIM > &c2, const std::tuple< int, int, int > v1, const std::tuple< int, int, int > v2) |
template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> | |
Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-2 > | inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int > v1, const std::tuple< int > v2) |
Computes the partial scalar/inner product between two functions, returns a low-dim function. More... | |
template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> | |
Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-4 > | inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int, int > v1, const std::tuple< int, int > v2) |
Computes the partial scalar/inner product between two functions, returns a low-dim function. More... | |
template<typename T , std::size_t LDIM, typename R , std::size_t KDIM> | |
Function< TENSOR_RESULT_TYPE(T, R), KDIM+LDIM-6 > | inner (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::tuple< int, int, int > v1, const std::tuple< int, int, int > v2) |
Computes the partial scalar/inner product between two functions, returns a low-dim function. More... | |
template<typename T , std::size_t NDIM, std::size_t PDIM> | |
LowRankFunction< T, NDIM > | inner (const Function< T, NDIM > &f1, const LowRankFunction< T, NDIM > &f2, const particle< PDIM > p1, const particle< PDIM > p2) |
lrf(1,3) = inner(full(1,2), lrf(2,3)) More... | |
template<typename T , std::size_t NDIM> | |
double | inner (const LowRankFunction< T, NDIM > &a, const LowRankFunction< T, NDIM > &b) |
template<typename T , std::size_t NDIM, std::size_t PDIM> | |
LowRankFunction< T, NDIM > | inner (const LowRankFunction< T, NDIM > &f1, const Function< T, NDIM > &f2, const particle< PDIM > p1, const particle< PDIM > p2) |
lrf(1,3) = inner(lrf(1,2), full(2,3)) More... | |
template<typename T , std::size_t NDIM, std::size_t PDIM> | |
Function< T, NDIM > | inner (const LowRankFunction< T, NDIM > &f1, const Function< T, PDIM > &f2, const particle< PDIM > p1, const particle< PDIM > p2=particle< PDIM >::particle1()) |
f(1) = inner(lrf(1,2), f(2)) More... | |
template<typename T , std::size_t NDIM, std::size_t PDIM> | |
LowRankFunction< T, NDIM > | inner (const LowRankFunction< T, NDIM > &f1, const LowRankFunction< T, NDIM > &f2, const particle< PDIM > p1, const particle< PDIM > p2) |
lrf(1,3) = inner(lrf(1,2), lrf(2,3)) More... | |
template<typename T , std::size_t NDIM, std::size_t PDIM> | |
std::vector< Function< T, NDIM-PDIM > > | inner (const LowRankFunction< T, NDIM > &f1, const std::vector< Function< T, PDIM >> &vf, const particle< PDIM > p1, const particle< PDIM > p2=particle< PDIM >::particle1()) |
f(1) = inner(lrf(1,2), f(2)) More... | |
double | inner (const std::valarray< double > &bra, const std::valarray< double > &ket) |
inner product for std::valarray More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | inner (const std::vector< CCPairFunction< T, NDIM >> &c1, const std::vector< CCPairFunction< T, NDIM >> &c2, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v1, const std::array< int, CCPairFunction< T, NDIM >::LDIM > &v2) |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | inner (const std::vector< CCPairFunction< T, NDIM >> &c1, const std::vector< CCPairFunction< T, NDIM >> &c2, const std::tuple< int, int, int > v1, const std::tuple< int, int, int > v2) |
template<class T , class Q > | |
Tensor< TENSOR_RESULT_TYPE(T, Q)> | inner (const Tensor< T > &left, const Tensor< Q > &right, long k0=-1, long k1=0) |
Inner product ... result(i,j,...,p,q,...) = sum(z) left(i,j,...,z)*right(z,p,q,...) More... | |
template<typename T , std::size_t N> | |
T | inner (const Vector< T, N > &l, const Vector< T, N > &r) |
compute the inner product two Vector s. More... | |
auto | inner (const X_space &A, const X_space &B) -> Tensor< double > |
Computes the matrix elements between two response spaces. More... | |
return f | inner (g) |
double | inner (response_space &a, response_space &b) |
template<typename T , typename R , std::size_t NDIM> | |
Tensor< TENSOR_RESULT_TYPE(T, R) > | inner (World &world, const Function< T, NDIM > &f, const std::vector< Function< R, NDIM > > &g) |
Computes the inner product of a function with a function vector - q(i) = inner(f,g[i]) More... | |
template<typename T , typename R , std::size_t NDIM> | |
Tensor< TENSOR_RESULT_TYPE(T, R) > | inner (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g) |
Computes the element-wise inner product of two function vectors - q(i) = inner(f[i],g[i]) More... | |
return f | inner_adaptive (func) |
template<class T , class Q > | |
void | inner_result (const Tensor< T > &left, const Tensor< Q > &right, long k0, long k1, Tensor< TENSOR_RESULT_TYPE(T, Q) > &result) |
Accumulate inner product into user provided, contiguous, correctly sized result tensor. More... | |
template<std::size_t NDIM, typename T , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2> | |
Function< TENSOR_RESULT_TYPE(T, R), NDIM > | innerXX (const Function< T, LDIM > &f, const Function< R, KDIM > &g, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2, int task=0) |
Computes the partial scalar/inner product between two functions, returns a low-dim function. More... | |
template<std::size_t NDIM, typename T , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | innerXX (const Function< T, LDIM > &f, const std::vector< Function< R, KDIM >> &vg, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2, int task=0) |
Computes the partial scalar/inner product between two functions, returns a low-dim function. More... | |
template<typename T > | |
DistributedMatrix< T > | interleave_rows (const DistributedMatrix< T > &a, const DistributedMatrix< T > &b) |
Generates a distributed matrix with rows of a and b interleaved. More... | |
template Tensor< double > | inverse (const Tensor< double > &A) |
template Tensor< double_complex > | inverse (const Tensor< double_complex > &A) |
template<typename T > | |
Tensor< T > | inverse (const Tensor< T > &a_in) |
invert general square matrix A More... | |
template<typename T , std::size_t NDIM> | |
bool | is_collected (const std::vector< CCPairFunction< T, NDIM >> &other) |
bool | is_madness_thread () |
template<typename Q , typename R > | |
bool | is_same_tensor_type (const GenTensor< R > &rhs, const GenTensor< Q > &lhs) |
void | jacobi (Tensor< double > &A, Tensor< double > &V, const std::vector< int > &set) |
Exchange< double, 3 >::ExchangeImpl | junkjunkjunk (World &world, const SCF *calc, const int ispin) |
template<typename T > | |
Tensor< T > | KAIN (const Tensor< T > &Q, double rcond=1e-12) |
Solves non-linear equation using KAIN (returns coefficients to compute next vector) More... | |
void | legendre_polynomials (double x, long order, double *p) |
Evaluate the Legendre polynomials up to the given order at x in [-1,1]. More... | |
void | legendre_scaling_functions (double x, long k, double *p) |
Evaluate the first k Legendre scaling functions. More... | |
template<class T , std::size_t NDIM> | |
void | load (Function< T, NDIM > &f, const std::string name) |
void | load_balance (const real_function_6d &f, const bool leaf) |
do some load-balancing More... | |
void | load_coeffs (World &world, const char *dir) |
Collective routine to load and cache twoscale & autorrelation coefficients. More... | |
template<typename T , size_t NDIM> | |
void | load_function (World &world, std::vector< Function< T, NDIM > > &f, const std::string name) |
load a vector of functions More... | |
void | load_quadrature (World &world, const char *dir) |
Collective routine to pre-load and cache the quadrature points and weights. More... | |
static xc_func_type * | lookup_func (const std::string &name, bool polarized) |
static std::string | lookup_id (const int id) |
static int | lookup_name (const std::string &name) |
std::string | lowercase (const std::string &s) |
template void | lq (Tensor< double > &A, Tensor< double > &L) |
template void | lq (Tensor< double_complex > &A, Tensor< double_complex > &L) |
template<typename T > | |
void | lq (Tensor< T > &A, Tensor< T > &R) |
compute the LQ decomposition of the matrix A = L Q More... | |
template void | lq_result (Tensor< double > &A, Tensor< double > &R, Tensor< double > &tau, Tensor< double > &work, bool do_qr) |
template void | lq_result (Tensor< double_complex > &A, Tensor< double_complex > &R, Tensor< double_complex > &tau, Tensor< double_complex > &work, bool do_qr) |
template<typename T > | |
void | lq_result (Tensor< T > &A, Tensor< T > &R, Tensor< T > &tau, Tensor< T > &work, bool do_qr) |
compute the LQ decomposition of the matrix A = L Q More... | |
int | main (int argc, char **argv) |
std::vector< atom_information< 3 > > | make_atom_vec (const Molecule &molecule, double R1_, double R2_) |
double | make_exp (double x) |
static xc_func_type * | make_func (int id, bool polarized) |
double | make_log (double x) |
template<typename T , std::size_t NDIM> | |
void | make_nonstandard (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true) |
Generates non-standard form of a vector of functions. More... | |
template<std::size_t NDIM> | |
static double | make_radius (const Vector< double, NDIM > &x) |
template<typename T , std::size_t NDIM> | |
void | make_redundant (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
change tree_state of a vector of functions to redundant More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | map_and_mirror (const Function< T, NDIM > &f, const std::vector< long > &map, const std::vector< long > &mirror, bool fence=true) |
This is replaced with mirror(map(f)), optional fence. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | mapdim (const Function< T, NDIM > &f, const std::vector< long > &map, bool fence=true) |
Generate a new function by reordering dimensions ... optional fence. More... | |
double | mask1 (double x) |
static double | mask3 (const coordT &ruser) |
static double | mask_functor_box (const coord_3d &x) |
static void | mask_info (integer &info) |
template<std::size_t NDIM> | |
static double | mask_munging (const double x) |
template<typename T , std::size_t NDIM> | |
DistributedMatrix< T > | matrix_inner (const DistributedMatrixDistribution &d, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< T, NDIM > > &g, bool sym=false) |
template<typename T , std::size_t NDIM> | |
void | matrix_inner (DistributedMatrix< T > &A, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< T, NDIM > > &g, bool sym=false) |
template<typename T , typename R , std::size_t NDIM> | |
Tensor< TENSOR_RESULT_TYPE(T, R) > | matrix_inner (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false) |
Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j]) More... | |
template<typename T , typename R , std::size_t NDIM> | |
Tensor< TENSOR_RESULT_TYPE(T, R) > | matrix_inner_old (World &world, const std::vector< Function< T, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, bool sym=false) |
Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j]) More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > > | matrix_mul_sparse (World &world, const std::vector< Function< R, NDIM > > &f, const std::vector< Function< R, NDIM > > &g, double tol, bool fence=true, bool symm=false) |
Outer product of a vector of functions with a vector of functions using sparsity. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | mirror (const Function< T, NDIM > &f, const std::vector< long > &mirrormap, bool fence=true) |
Generate a new function by mirroring within the dimensions .. optional fence. More... | |
template<> | |
void | mTxm (long dimi, long dimj, long dimk, double *MADNESS_RESTRICT c, const double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b) |
Matrix transpose * matrix (hand unrolled version) More... | |
template<typename T , typename Q , typename S > | |
static void | mTxm (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
template<typename T > | |
void | mTxm (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b) |
Matrix += Matrix transpose * matrix ... MKL interface version. More... | |
template<typename T , typename Q , typename S > | |
static void | mTxm_reference (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
Matrix += Matrix transpose * matrix ... reference implementation (slow but correct) More... | |
template<typename aT , typename bT , typename cT > | |
void | mTxmq (long dimi, long dimj, long dimk, cT *MADNESS_RESTRICT c, const aT *a, const bT *b, long ldb=-1) |
template<typename T > | |
void | mTxmq (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b, long ldb=-1) |
Matrix = Matrix transpose * matrix ... MKL interface version. More... | |
template<typename aT , typename bT , typename cT > | |
void | mTxmq_padding (long dimi, long dimj, long dimk, long ext_b, cT *c, const aT *a, const bT *b) |
template<typename aT , typename bT , typename cT > | |
void | mTxmq_reference (long dimi, long dimj, long dimk, cT *MADNESS_RESTRICT c, const aT *a, const bT *b, long ldb=-1) |
Matrix = Matrix transpose * matrix ... slow reference implementation. More... | |
template<> | |
void | mTxmT (long dimi, long dimj, long dimk, double *MADNESS_RESTRICT csave, const double *MADNESS_RESTRICT asave, const double *MADNESS_RESTRICT b) |
Matrix transpose * matrix transpose (hand tiled and unrolled) More... | |
template<typename T , typename Q , typename S > | |
static void | mTxmT (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
template<typename T > | |
void | mTxmT (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b) |
Matrix += Matrix transpose * matrix transpose ... MKL interface version. More... | |
template<typename T , typename Q , typename S > | |
static void | mTxmT_reference (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
Matrix += Matrix transpose * matrix transpose reference implementation (slow but correct) More... | |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | mul (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
Same as operator* but with optional fence and no automatic reconstruction. More... | |
template<typename Q , typename T , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | mul (const Function< T, NDIM > &f, const Q alpha, bool fence=true) |
Returns new function equal to f(x)*alpha with optional fence. More... | |
template<typename Q , typename T , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | mul (const Q alpha, const Function< T, NDIM > &f, bool fence=true) |
Returns new function equal to alpha*f(x) with optional fence. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, bool fence=true) |
Multiplies a function against a vector of functions — q[i] = a * v[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, const unsigned int blk=1, const bool fence=true) |
Multiplies a function against a vector of functions — q[i] = a * v[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Multiplies two vectors of functions q[i] = a[i] * b[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true, unsigned int blk=1) |
Multiplies two vectors of functions q[i] = a[i] * b[i]. More... | |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | mul_sparse (const Function< L, NDIM > &left, const Function< R, NDIM > &right, double tol, bool fence=true) |
Sparse multiplication — left and right must be reconstructed and if tol!=0 have tree of norms already created. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul_sparse (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, const double tol, const bool fence=true, const unsigned int blk=1) |
Multiplies a function against a vector of functions using sparsity of a and v[i] — q[i] = a * v[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | mul_sparse (World &world, const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v, double tol, bool fence=true) |
Multiplies a function against a vector of functions using sparsity of a and v[i] — q[i] = a * v[i]. More... | |
template<typename T , typename opT , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | multi_to_multi_op_values (const opT &op, const std::vector< Function< T, NDIM > > &vin, const bool fence=true) |
apply op on the input vector yielding an output vector of functions More... | |
template<typename T , typename opT , std::size_t NDIM> | |
Function< T, NDIM > | multiop_values (const opT &op, const std::vector< Function< T, NDIM > > &vf) |
template<typename T , std::size_t NDIM, std::size_t LDIM> | |
Function< T, NDIM > | multiply (const Function< T, NDIM > f, const Function< T, LDIM > g, const int particle, const bool fence=true) |
multiply a high-dimensional function with a low-dimensional function More... | |
template<typename T , std::size_t NDIM, std::size_t LDIM> | |
std::vector< Function< T, NDIM > > | multiply (const Function< T, NDIM > f, const std::vector< Function< T, LDIM > > g, const std::tuple< int, int, int > v) |
template<std::size_t NDIM> | |
static double | munge (const double x) |
template<> | |
void | mxm (long dimi, long dimj, long dimk, double *MADNESS_RESTRICT c, const double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b) |
Matrix * matrix (hand unrolled version) More... | |
template<typename T , typename Q , typename S > | |
static void | mxm (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
template<typename T > | |
void | mxm (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b) |
Matrix += Matrix * matrix ... BLAS/MKL interface version. More... | |
template<typename T , typename Q , typename S > | |
static void | mxm_reference (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
Matrix += Matrix * matrix reference implementation (slow but correct) More... | |
template<> | |
void | mxmT (long dimi, long dimj, long dimk, double *MADNESS_RESTRICT c, const double *MADNESS_RESTRICT a, const double *MADNESS_RESTRICT b) |
Matrix * matrix transpose (hand unrolled version) More... | |
template<typename T , typename Q , typename S > | |
static void | mxmT (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
template<typename T > | |
void | mxmT (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b) |
Matrix += Matrix * matrix transpose ... MKL interface version. More... | |
template<typename T , typename Q , typename S > | |
static void | mxmT_reference (long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const Q *MADNESS_RESTRICT a, const S *MADNESS_RESTRICT b) |
Matrix += Matrix * matrix transpose ... reference implementation (slow but correct) More... | |
STATIC Tensor< double > | my_conj_transpose (Tensor< double > a) |
STATIC Tensor< double_complex > | my_conj_transpose (Tensor< double_complex > a) |
STATIC Tensor< float > | my_conj_transpose (Tensor< float > a) |
STATIC Tensor< float_complex > | my_conj_transpose (Tensor< float_complex > a) |
static void | myusleep (unsigned int us) |
Sleep or spin for specified number of microseconds. More... | |
std::string | name (const FuncType &type, const int ex=-1) |
template<typename... argT> | |
AmArg * | new_am_arg (const argT &... args) |
Convenience template for serializing arguments into a new AmArg. More... | |
template<typename T , std::size_t NDIM> | |
static XNonlinearSolver< std::vector< Function< T, NDIM > >, T, vector_function_allocator< T, NDIM > > | nonlinear_vector_solver (World &world, const long nvec) |
template<typename T , std::size_t NDIM> | |
void | nonstandard (World &world, std::vector< Function< T, NDIM > > &v, unsigned int blk=1, bool fence=true) |
Generates non-standard form of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
double | norm2 (World &world, const std::vector< Function< T, NDIM > > &v) |
Computes the 2-norm of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< double > | norm2s (World &world, const std::vector< Function< T, NDIM > > &v) |
Computes the 2-norms of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< double > | norm2s (World &world, const std::vector< Function< T, NDIM > > &v, const unsigned int blk=1, const bool fence=true) |
Computes the 2-norms of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
Tensor< double > | norm2s_T (World &world, const std::vector< Function< T, NDIM >> &v) |
Computes the 2-norms of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
void | norm_tree (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Makes the norm tree for all functions in a vector. More... | |
template<typename T , std::size_t NDIM> | |
void | norm_tree (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true, unsigned int blk=1) |
Makes the norm tree for all functions in a vector. More... | |
template<typename T , std::size_t NDIM> | |
void | normalize (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true) |
Normalizes a vector of functions — v[i] = v[i].scale(1.0/v[i].norm2()) More... | |
bool | operator!= (const DistributedID &left, const DistributedID &right) |
Distributed ID inequality comparison operator. More... | |
bool | operator!= (const QCCalculationParametersBase &p1, const QCCalculationParametersBase &p2) |
bool | operator!= (const ResponseParameters &p1, const ResponseParameters &p2) |
bool | operator!= (const uniqueidT &a, const uniqueidT &b) |
Inequality comparison operator. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | operator* (const double fac, const std::vector< CCPairFunction< T, NDIM > > &arg) |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | operator* (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
Multiplies two functions with the new result being of type TensorResultType<L,R> More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | operator* (const Function< T, NDIM > &a, const std::vector< Function< R, NDIM > > &v) |
multiply a vector of functions with a function: r[i] = v[i] * a More... | |
template<typename Q , typename T , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | operator* (const Function< T, NDIM > &f, const Q alpha) |
Returns new function equal to f(x)*alpha. More... | |
template<typename T , typename Q > | |
IsSupported< TensorTypeData< Q >, GenTensor< T > >::type | operator* (const Q &x, const GenTensor< T > &t) |
The class defines tensor op scalar ... here define scalar op tensor. More... | |
template<typename T , typename Q > | |
IsSupported< TensorTypeData< Q >, Tensor< T > >::type | operator* (const Q &x, const Tensor< T > &t) |
The class defines tensor op scalar ... here define scalar op tensor. More... | |
template<typename Q , typename T , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(Q, T), NDIM > | operator* (const Q alpha, const Function< T, NDIM > &f) |
Returns new function equal to alpha*f(x) More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | operator* (const R fac, const std::vector< Function< T, NDIM > > &rhs) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator* (const std::vector< Function< T, NDIM > > &rhs, const R fac) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | operator* (const std::vector< Function< T, NDIM > > &v, const Function< R, NDIM > &a) |
multiply a vector of functions with a function: r[i] = a * v[i] More... | |
template<typename T , typename U , std::size_t N> | |
Vector< T, N > | operator* (T l, Vector< U, N > r) |
Scale a Vector . More... | |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator* (Vector< T, N > l, const Vector< U, N > &r) |
Multiply (element-wise) two Vector s. More... | |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator* (Vector< T, N > l, U r) |
Scale a Vector . More... | |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | operator+ (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
Adds two functions with the new result being of type TensorResultType<L,R> More... | |
template<typename T , typename R , std::size_t NDIM> | |
IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | operator+ (const Function< T, NDIM > &f, R r) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator+ (const Function< T, NDIM > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
result[i] = a + b[i] More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | operator+ (const std::vector< CCPairFunction< T, NDIM >> c1, const std::vector< CCPairFunction< T, NDIM > > &c2) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator+ (const std::vector< Function< T, NDIM > > &lhs, const Function< T, NDIM > &rhs) |
result[i] = a[i] + b More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator+ (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM >> &rhs) |
result[i] = a[i] + b[i] More... | |
template<typename T , typename Q > | |
IsSupported< TensorTypeData< Q >, Tensor< T > >::type | operator+ (Q x, const Tensor< T > &t) |
The class defines tensor op scalar ... here define scalar op tensor. More... | |
template<typename T , typename R , std::size_t NDIM> | |
IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | operator+ (R r, const Function< T, NDIM > &f) |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator+ (Vector< T, N > l, const Vector< U, N > &r) |
Add (element-wise) two Vector s. More... | |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator+ (Vector< T, N > l, U r) |
Add a scalar to a Vector . More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > & | operator+= (std::vector< CCPairFunction< T, NDIM > > &lhs, const CCPairFunction< T, NDIM > &rhs) |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > & | operator+= (std::vector< CCPairFunction< T, NDIM > > &rhs, const std::vector< CCPairFunction< T, NDIM > > &lhs) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator+= (std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | operator- (const Function< L, NDIM > &left, const Function< R, NDIM > &right) |
Subtracts two functions with the new result being of type TensorResultType<L,R> More... | |
template<typename T , typename R , std::size_t NDIM> | |
IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | operator- (const Function< T, NDIM > &f, R r) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator- (const Function< T, NDIM > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
result[i] = a - b[i] More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > | operator- (const std::vector< CCPairFunction< T, NDIM >> c1, const std::vector< CCPairFunction< T, NDIM > > &c2) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator- (const std::vector< Function< T, NDIM > > &lhs, const Function< T, NDIM > &rhs) |
result[i] = a[i] - b More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator- (const std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
result[i] = a[i] - b[i] More... | |
template<typename T , typename Q > | |
IsSupported< TensorTypeData< Q >, Tensor< T > >::type | operator- (Q x, const Tensor< T > &t) |
The class defines tensor op scalar ... here define scalar op tensor. More... | |
template<typename T , typename R , std::size_t NDIM> | |
IsSupported< TensorTypeData< R >, Function< TENSOR_RESULT_TYPE(T, R), NDIM > >::type | operator- (R r, const Function< T, NDIM > &f) |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator- (Vector< T, N > l, const Vector< U, N > &r) |
Subtract (element-wise) two Vector s. More... | |
template<typename T , std::size_t N, typename U > | |
Vector< T, N > | operator- (Vector< T, N > l, U r) |
Subtract a scalar from a Vector . More... | |
template<typename T , std::size_t NDIM> | |
std::vector< CCPairFunction< T, NDIM > > & | operator-= (std::vector< CCPairFunction< T, NDIM > > &rhs, const std::vector< CCPairFunction< T, NDIM > > &lhs) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | operator-= (std::vector< Function< T, NDIM > > &lhs, const std::vector< Function< T, NDIM > > &rhs) |
bool | operator< (const uniqueidT &a, const uniqueidT &b) |
Ordering operator. More... | |
std::ostream & | operator<< (std::ostream &os, const DistributedID &did) |
Overload redirect to std::ostream to be discoverable via ADL. More... | |
std::ostream & | operator<< (std::ostream &os, const EnergyType &en) |
std::ostream & | operator<< (std::ostream &os, const GuessType &en) |
template<std::size_t N = 1> | |
std::ostream & | operator<< (std::ostream &os, const OpType type) |
operator type to string More... | |
std::ostream & | operator<< (std::ostream &os, const PairType &en) |
template<std::size_t PDIM> | |
std::ostream & | operator<< (std::ostream &os, const particle< PDIM > &p) |
std::ostream & | operator<< (std::ostream &os, const permutation &p) |
template<typename Key , typename Tag > | |
std::ostream & | operator<< (std::ostream &os, const ProcessKey< Key, Tag > &key) |
Overload redirect to std::ostream to be discoverable via ADL. More... | |
template<typename Key , typename Tag > | |
std::ostream & | operator<< (std::ostream &os, const TaggedKey< Key, Tag > &key) |
Overload redirect to std::ostream to be discoverable via ADL. More... | |
template<std::size_t NDIM = 1> | |
std::ostream & | operator<< (std::ostream &os, const TreeState treestate) |
template<typename T > | |
std::ostream & | operator<< (std::ostream &out, const Future< T > &f) |
Human readable printing of a Future to a stream. More... | |
template<> | |
std::ostream & | operator<< (std::ostream &out, const Future< void > &f) |
Stream output operator for a void future. More... | |
std::ostream & | operator<< (std::ostream &out, const MadnessException &e) |
Enables easy printing of a MadnessException . More... | |
std::ostream & | operator<< (std::ostream &s, const Atom &atom) |
std::ostream & | operator<< (std::ostream &s, const AtomicBasis &c) |
std::ostream & | operator<< (std::ostream &s, const AtomicBasisFunction &a) |
template<std::size_t NDIM> | |
static std::ostream & | operator<< (std::ostream &s, const BoundaryConditions< NDIM > &bc) |
template<typename T , std::size_t NDIM> | |
std::ostream & | operator<< (std::ostream &s, const CoeffTracker< T, NDIM > &ct) |
std::ostream & | operator<< (std::ostream &s, const ContractedGaussianShell &c) |
template<typename T , std::size_t NDIM> | |
std::ostream & | operator<< (std::ostream &s, const FunctionNode< T, NDIM > &node) |
template<std::size_t NDIM> | |
std::ostream & | operator<< (std::ostream &s, const Key< NDIM > &key) |
template<typename T > | |
static std::ostream & | operator<< (std::ostream &s, const SRConf< T > &sr) |
template<class T > | |
std::ostream & | operator<< (std::ostream &s, const Tensor< T > &t) |
Print (for human consumption) a tensor to the stream. More... | |
static std::ostream & | operator<< (std::ostream &s, const TensorType &tt) |
std::ostream & | operator<< (std::ostream &stream, const Slice &s) |
bool | operator== (const DistributedID &left, const DistributedID &right) |
Distributed ID equality comparison operator. More... | |
bool | operator== (const ResponseParameters &p1, const ResponseParameters &p2) |
bool | operator== (const uniqueidT &a, const uniqueidT &b) |
Equality comparison operator. More... | |
std::istream & | operator>> (std::istream &is, EnergyType &en) |
std::istream & | operator>> (std::istream &is, GuessType &en) |
std::istream & | operator>> (std::istream &is, PairType &en) |
template<typename Q , typename T > | |
std::istream & | operator>> (std::istream &is, std::pair< T, Q > &p) |
template<typename T , typename A = std::allocator<T>> | |
std::istream & | operator>> (std::istream &is, std::vector< T, A > &v) |
template void | orgqr (Tensor< complex_real4 > &A, const Tensor< complex_real4 > &tau) |
template void | orgqr (Tensor< double > &A, const Tensor< double > &tau) |
template void | orgqr (Tensor< double_complex > &A, const Tensor< double_complex > &tau) |
template void | orgqr (Tensor< float > &A, const Tensor< float > &tau) |
template<typename T > | |
void | orgqr (Tensor< T > &A, const Tensor< T > &tau) |
reconstruct the orthogonal matrix Q (e.g. from QR factorization) More... | |
template<typename T > | |
void | ortho3 (Tensor< T > &x, Tensor< T > &y, Tensor< typename Tensor< T >::scalar_type > &weights, const double &thresh) |
sophisticated version of ortho2 More... | |
template<typename T > | |
void | ortho5 (Tensor< T > &x1, Tensor< T > &y1, Tensor< typename Tensor< T >::scalar_type > &w1, const Tensor< T > &x2, const Tensor< T > &y2, const Tensor< typename Tensor< T >::scalar_type > &w2, const double &thresh) |
specialized version of ortho3 More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize (const std::vector< Function< T, NDIM > > &vf_in) |
orthonormalize the vectors More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_canonical (const std::vector< Function< T, NDIM > > &v, const double lindep) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_canonical (const std::vector< Function< T, NDIM > > &v, const Tensor< T > &ovlp, double lindep) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_cd (const std::vector< Function< T, NDIM > > &v) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_cd (const std::vector< Function< T, NDIM > > &v, Tensor< T > &ovlp) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, const double tol) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, Tensor< T > &ovlp, const double tol, Tensor< integer > &piv, int &rank) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_rrcd (const std::vector< Function< T, NDIM > > &v, Tensor< T > ovlp, const double tol) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_symmetric (const std::vector< Function< T, NDIM > > &v) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | orthonormalize_symmetric (const std::vector< Function< T, NDIM > > &v, const Tensor< T > &ovlp) |
symmetric orthonormalization (see e.g. Szabo/Ostlund) More... | |
template<class T > | |
GenTensor< T > | outer (const GenTensor< T > &left, const GenTensor< T > &right, const TensorArgs final_tensor_args) |
Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
template<class T , class Q > | |
GenTensor< TENSOR_RESULT_TYPE(T, Q)> | outer (const GenTensor< T > &t1, const GenTensor< Q > &t2, const TensorArgs final_tensor_args=TensorArgs(-1.0, TT_2D)) |
outer product of two Tensors, yielding a low rank tensor More... | |
template<typename projT , typename projQ > | |
std::enable_if< std::is_base_of< ProjectorBase, projT >::value, OuterProjector< projT, projQ > >::type | outer (const projT &p0, const projQ &p1) |
template<class T > | |
Tensor< T > | outer (const Tensor< T > &left, const Tensor< T > &right) |
Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
template<class T > | |
GenTensor< T > | outer (const Tensor< T > &left, const Tensor< T > &right, const TensorArgs final_tensor_args) |
Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
template<class T , class Q > | |
GenTensor< TENSOR_RESULT_TYPE(T, Q)> | outer (const Tensor< T > &lhs2, const Tensor< Q > &rhs2, const TensorArgs final_tensor_args) |
outer product of two Tensors, yielding a low rank tensor More... | |
template<class T , class Q > | |
TensorTrain< TENSOR_RESULT_TYPE(T, Q)> | outer (const TensorTrain< T > &t1, const TensorTrain< Q > &t2) |
computes the outer product of two tensors More... | |
template<class T > | |
void | outer_result (const Tensor< T > &left, const Tensor< T > &right, Tensor< T > &result) |
Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...) More... | |
static int | parity (int i) |
Return +1 if i is even, -1 if i is odd ... perverse no if-test form. More... | |
template<typename T , std::size_t NDIM, std::size_t LDIM> | |
std::vector< Function< T, NDIM > > | partial_mul (const Function< T, NDIM > f, const std::vector< Function< T, LDIM > > g, const int particle) |
multiply a high-dimensional function with a low-dimensional function More... | |
template<typename T , std::size_t NDIM> | |
Derivative< T, NDIM > | periodic_derivative (World &world, int axis, int k=FunctionDefaults< NDIM >::get_k()) |
Conveinence function returning derivative operator with periodic boundary conditions. More... | |
template<typename Q , int NDIM> | |
SeparatedConvolution< Q, NDIM > | PeriodicBSHOp (World &world, double mu, long k, double lo, double eps, Tensor< double > L) |
static SeparatedConvolution< double_complex, 3 > | PeriodicBSHOperator3D (World &world, Vector< double, 3 > args, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D. More... | |
static SeparatedConvolution< double_complex, 3 > * | PeriodicBSHOperatorPtr3D (World &world, Vector< double, 3 > args, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D. More... | |
template<typename Q , int NDIM> | |
SeparatedConvolution< Q, NDIM > * | PeriodicBSHOpPtr (World &world, double mu, long k, double lo, double eps, Tensor< double > L) |
template<typename Q , int NDIM> | |
SeparatedConvolution< Q, NDIM > | PeriodicCoulombOp (World &world, long k, double lo, double eps, Tensor< double > L) |
template<typename Q , int NDIM> | |
SeparatedConvolution< Q, NDIM > * | PeriodicCoulombOpPtr (World &world, long k, double lo, double eps, Tensor< double > L) |
static SeparatedConvolution< double_complex, 3 > | PeriodicHFExchangeOperator (World &world, Vector< double, 3 > args, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with 1/r in 3D. More... | |
static pg_operator | pg_c2 () |
static pg_operator | pg_c2x () |
static pg_operator | pg_c2y () |
static pg_operator | pg_c2z () |
static pg_operator | pg_c4 () |
static pg_operator | pg_c4x () |
static pg_operator | pg_c4y () |
static pg_operator | pg_c4z () |
static pg_operator | pg_identity () |
static pg_operator | pg_inversion () |
static pg_operator | pg_sigma_x () |
static pg_operator | pg_sigma_xy () |
static pg_operator | pg_sigma_xz () |
static pg_operator | pg_sigma_y () |
static pg_operator | pg_sigma_yz () |
static double | phase (long i) |
template<size_t NDIM> | |
void | plot (const std::vector< Function< double, NDIM > > &vf, const std::string &name, const std::vector< std::string > &header) |
convenience to get plot_plane and plot_cubefile More... | |
template<size_t NDIM> | |
void | plot_along (World &world, trajectory< NDIM > traj, const Function< double, NDIM > &function, std::string filename) |
template<size_t NDIM> | |
void | plot_along (World &world, trajectory< NDIM > traj, double(*ff)(const Vector< double, NDIM > &), std::string filename) |
template<size_t NDIM> | |
std::enable_if< NDIM==3, void >::type | plot_cubefile (World &world, const Function< double, NDIM > &f, std::string filename, std::vector< std::string > molecular_info=std::vector< std::string >(), int npoints=100, double zoom=1.0) |
template<typename T , std::size_t NDIM> | |
void | plot_line (const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const Function< T, NDIM > &f) |
Generates ASCII file tabulating f(r) at npoints along line r=lo,...,hi. More... | |
template<typename T , typename U , std::size_t NDIM> | |
void | plot_line (const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const Function< T, NDIM > &f, const Function< U, NDIM > &g) |
Generates ASCII file tabulating f(r) and g(r) at npoints along line r=lo,...,hi. More... | |
template<typename T , typename U , typename V , std::size_t NDIM> | |
void | plot_line (const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const Function< T, NDIM > &f, const Function< U, NDIM > &g, const Function< V, NDIM > &a) |
Generates ASCII file tabulating f(r), g(r), and a(r) at npoints along line r=lo,...,hi. More... | |
template<typename T , typename U , typename V , typename W , std::size_t NDIM> | |
void | plot_line (const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const Function< T, NDIM > &f, const Function< U, NDIM > &g, const Function< V, NDIM > &a, const Function< W, NDIM > &b) |
Generates ASCII file tabulating f(r), g(r), a(r), b(r) at npoints along line r=lo,...,hi. More... | |
template<typename T , std::size_t NDIM> | |
void | plot_line (const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const std::vector< Function< T, NDIM >> &vf) |
The ordinate is distance from lo. More... | |
template<typename opT , std::size_t NDIM> | |
void | plot_line (World &world, const char *filename, int npt, const Vector< double, NDIM > &lo, const Vector< double, NDIM > &hi, const opT &op) |
Generates ASCII file tabulating f(r) at npoints along line r=lo,...,hi. More... | |
static void | plot_line_print_value (FILE *f, double v) |
static void | plot_line_print_value (FILE *f, double_complex v) |
template<size_t NDIM> | |
void | plot_plane (World &world, const Function< double, NDIM > &function, const std::string name) |
template<size_t NDIM> | |
void | plot_plane (World &world, const Function< double, NDIM > &function1, const Function< double, NDIM > &function2, const Function< double, NDIM > &function3, const std::string name) |
template<size_t NDIM> | |
void | plot_plane (World &world, const Function< double, NDIM > &function1, const Function< double, NDIM > &function2, const std::string name) |
template<size_t NDIM, typename opT > | |
void | plot_plane (World &world, const opT &op, const std::string name, const PlotParameters param) |
template<size_t NDIM> | |
void | plot_plane (World &world, const std::vector< Function< double, NDIM > > &vfunction, const std::string name, const PlotParameters param) |
plot a 2-d slice of a given function and the according MRA structure More... | |
template<size_t NDIM> | |
void | plot_plane (World &world, const std::vector< Function< double, NDIM > > &vfunction, const std::string name, const std::string inputfile="input") |
template<typename T , std::size_t NDIM> | |
void | plotdx (const Function< T, NDIM > &f, const char *filename, const Tensor< double > &cell=FunctionDefaults< NDIM >::get_cell(), const std::vector< long > &npt=std::vector< long >(NDIM, 201L), bool binary=true) |
Writes an OpenDX format file with a cube/slice of points on a uniform grid. More... | |
template<typename T > | |
static void | plotpovray (const Function< T, 3 > &function, const char *filename, const Tensor< double > &cell=FunctionDefaults< 3 >::get_cell(), const std::vector< long > &npt=std::vector< long >(3, 201L)) |
Writes a Povray DF3 format file with a cube of points on a uniform grid. More... | |
template<std::size_t NDIM> | |
void | plotvtk_begin (World &world, const char *filename, const Vector< double, NDIM > &plotlo, const Vector< double, NDIM > &plothi, const Vector< long, NDIM > &npt, bool binary=false) |
template<typename T , std::size_t NDIM> | |
void | plotvtk_data (const Function< std::complex< T >, NDIM > &function, const char *fieldname, World &world, const char *filename, const Vector< double, NDIM > &plotlo, const Vector< double, NDIM > &plothi, const Vector< long, NDIM > &npt, bool binary=false, bool plot_refine=false) |
VTK data writer for complex-valued madness::functions. More... | |
template<typename T , std::size_t NDIM> | |
void | plotvtk_data (const Function< T, NDIM > &function, const char *fieldname, World &world, const char *filename, const Vector< double, NDIM > &plotlo, const Vector< double, NDIM > &plothi, const Vector< long, NDIM > &npt, bool binary=false, bool plot_refine=false) |
VTK data writer for real-valued (not complex) madness::functions. More... | |
template<typename T , std::size_t NDIM> | |
void | plotvtk_data (const T &function, const char *fieldname, World &world, const char *filename, const Vector< double, NDIM > &plotlo, const Vector< double, NDIM > &plothi, const Vector< long, NDIM > &npt, bool binary=false) |
template<std::size_t NDIM> | |
void | plotvtk_end (World &world, const char *filename, bool binary=false) |
static double | PM_q (const tensorT &S, const double *MADNESS_RESTRICT Ci, const double *MADNESS_RESTRICT Cj, int lo, int nbf) |
static double | pop (std::vector< double > &v) |
std::istream & | position_stream (std::istream &f, const std::string &tag, bool rewind=true) |
std::istream & | position_stream_to_word (std::istream &f, const std::string &tag, const char comment, bool rewind, bool silent) |
position the input stream to tag, which must be a word (not part of a word) More... | |
template<int D> | |
int | power (int base=2) |
template<int N, class T > | |
T | power (T const x) |
template<> | |
int | power< 0 > (int base) |
template<> | |
int | power< 1 > (int base) |
template<> | |
int | power< 10 > (int base) |
template<> | |
int | power< 12 > (int base) |
template<> | |
int | power< 2 > (int base) |
template<> | |
int | power< 3 > (int base) |
template<> | |
int | power< 4 > (int base) |
template<> | |
int | power< 5 > (int base) |
template<> | |
int | power< 6 > (int base) |
template<> | |
int | power< 7 > (int base) |
template<> | |
int | power< 8 > (int base) |
template<> | |
int | power< 9 > (int base) |
template<typename T , typename... Ts> | |
void | print (const T &t, const Ts &... ts) |
Print items to std::cout (items separated by spaces) and terminate with a new line. More... | |
void | print_centered (const char *s, int column=40, bool underline=true) |
Print a string centered at the given column with optional underlining. More... | |
template<typename T , typename... Ts> | |
void | print_error (const T &t, const Ts &... ts) |
Print items to std::cerr (items separated by spaces) and terminate with a new line. More... | |
void | print_header1 (const std::string &s) |
big section heading More... | |
void | print_header2 (const std::string &s) |
medium section heading More... | |
void | print_header3 (const std::string &s) |
small section heading More... | |
std::ostream & | print_helper (std::ostream &out) |
Helper function for print . Base case. More... | |
template<typename T , typename... Ts> | |
std::ostream & | print_helper (std::ostream &out, const T &t, const Ts &... ts) |
Helper function for print . Prints the first item (t ) and recursively passes on the other items. More... | |
void | print_justified (const char *s, int column=0, bool underline=true) |
Print a string justified on the left to start at the given column with optional underlining. More... | |
void | print_meminfo_disable () |
disables print_meminfo() profiling (i.e. calling it is a no-op) More... | |
void | print_meminfo_enable () |
bool | print_meminfo_enabled () |
bool | print_meminfo_keep_ostream_open () |
void | print_meminfo_keep_ostream_open (bool keep_open) |
std::basic_ofstream< wchar_t > & | print_meminfo_ostream (int rank, const std::string filename_prefix) |
template<typename A > | |
void | print_seq (World &world, const A &a) |
Sequentially ordered printing of (serializable) data from every process. More... | |
template<typename A , typename B > | |
void | print_seq (World &world, const A &a, const B &b) |
Sequentially ordered printing of (serializable) data from every process. More... | |
template<typename A , typename B , typename C > | |
void | print_seq (World &world, const A &a, const B &b, const C &c) |
Sequentially ordered printing of (serializable) data from every process. More... | |
template<typename A , typename B , typename C , typename D > | |
void | print_seq (World &world, const A &a, const B &b, const C &c, const D &d) |
Sequentially ordered printing of (serializable) data from every process. More... | |
template<typename T , std::size_t NDIM> | |
void | print_size (World &world, const std::vector< Function< T, NDIM > > &v, const std::string &msg="vectorfunction") |
void | print_stats (World &world) |
Print miscellaneous stats on a World. More... | |
template<size_t NDIM> | |
std::enable_if< NDIM==3, void >::type | print_tree_jsonfile (World &world, const Function< double, NDIM > &f, std::string filename) |
void | printf_msg_energy_time (const std::string msg, const double energy, const double time) |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | project (const Function< T, NDIM > &other, int k=FunctionDefaults< NDIM >::get_k(), double thresh=FunctionDefaults< NDIM >::get_thresh(), bool fence=true) |
tensorT | Q2 (const tensorT &s) |
Given overlap matrix, return rotation with 2nd order error to orthonormalize the vectors. More... | |
tensorT | Q3 (const tensorT &s) |
Given overlap matrix, return rotation with 3rd order error to orthonormalize the vectors. More... | |
Convolution1D< double_complex > * | qm_1d_free_particle_propagator (int k, double bandlimit, double timestep, double width) |
template<std::size_t NDIM> | |
SeparatedConvolution< double_complex, NDIM > | qm_free_particle_propagator (World &world, int k, double bandlimit, double timestep) |
template<std::size_t NDIM> | |
SeparatedConvolution< double_complex, NDIM > * | qm_free_particle_propagatorPtr (World &world, int k, double bandlimit, double timestep) |
template void | qr (Tensor< double > &A, Tensor< double > &R) |
template void | qr (Tensor< double_complex > &A, Tensor< double_complex > &R) |
template void | qr (Tensor< float > &A, Tensor< float > &R) |
template void | qr (Tensor< float_complex > &A, Tensor< float_complex > &R) |
template<typename T > | |
void | qr (Tensor< T > &A, Tensor< T > &R) |
compute the QR decomposition of the matrix A More... | |
bool | quiet () |
Check if the MADNESS runtime was initialized for quiet operation. More... | |
static double | r2 (const coord_3d &x) |
template<class T > | |
T | RandomValue () |
Random value that wraps the default Fibonacci generator. More... | |
template<> | |
double | RandomValue< double > () |
Random double. More... | |
template<> | |
double_complex | RandomValue< double_complex > () |
Random double_complex. More... | |
template<> | |
float | RandomValue< float > () |
Random float. More... | |
template<> | |
float_complex | RandomValue< float_complex > () |
Random float_complex. More... | |
template<> | |
int | RandomValue< int > () |
Random int. More... | |
template<> | |
long | RandomValue< long > () |
Random long. More... | |
template<class T > | |
void | RandomVector (int n, T *t) |
template<> | |
void | RandomVector< double > (int n, double *t) |
template<> | |
void | RandomVector< double_complex > (int n, double_complex *t) |
template<> | |
void | RandomVector< float > (int n, float *t) |
template<> | |
void | RandomVector< float_complex > (int n, float_complex *t) |
template<typename T > | |
long | rank_revealing_decompose (Tensor< T > &A, Tensor< T > &U, const double thresh, Tensor< typename Tensor< T >::scalar_type > &s, Tensor< T > &scr) |
static AtomCore | read_atom (TiXmlElement *e, unsigned int atn, double eprec) |
static bool | read_data () |
read_data loads the precomputed Gauss-Legendre data More... | |
static bool | read_data (int k) |
static bool | read_orbital (TiXmlElement *e, AtomCore &ac) |
static bool | read_potential (TiXmlElement *elem, AtomCore &ac, double eprec) |
static bool | read_twoscale (int kmax) |
static Tensor< double > | readmat (int k, FILE *file) |
template<std::size_t NDIM> | |
Function< double, NDIM > | real (const Function< double, NDIM > &z, bool fence=true) |
Returns a new function that is the real part of the input. More... | |
template<std::size_t NDIM> | |
Function< double, NDIM > | real (const Function< double_complex, NDIM > &z, bool fence=true) |
Returns a new function that is the real part of the input. More... | |
template<typename Q , int NDIM> | |
Function< typename TensorTypeData< Q >::scalar_type, NDIM > | real (const Function< Q, NDIM > &func) |
template<typename T , std::size_t NDIM> | |
std::vector< Function< typename Tensor< T >::scalar_type, NDIM > > | real (const std::vector< Function< T, NDIM > > &v, bool fence=true) |
return the real parts of the vector's function (if complex) More... | |
template<class T > | |
Tensor< typename Tensor< T >::scalar_type > | real (const Tensor< T > &t) |
Return a new tensor holding the real part of each element of t (complex types only) More... | |
double | real (double x) |
template<typename T , std::size_t NDIM> | |
const std::vector< Function< T, NDIM > > & | reconstruct (const std::vector< Function< T, NDIM > > &v) |
reconstruct a vector of functions More... | |
template<typename T , std::size_t NDIM> | |
void | reconstruct (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Reconstruct a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
void | reconstruct (World &world, const std::vector< Function< T, NDIM > > &v, unsigned int blk=1, bool fence=true) |
Reconstruct a vector of functions. More... | |
void | redirectio (const World &world, bool split=false) |
redirects standard output and error to rank-specific files More... | |
template<class T > | |
GenTensor< T > | reduce (std::list< GenTensor< T > > &addends, double eps, bool are_optimal=false) |
add all the GenTensors of a given list More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | reduce_rank (std::vector< Function< T, NDIM > > v, double thresh=0.0, bool fence=true) |
reduces the tensor rank of the coefficient tensor (if applicable) More... | |
template<typename T , std::size_t NDIM> | |
void | refine (World &world, const std::vector< Function< T, NDIM > > &vf, bool fence=true) |
refine the functions according to the autorefine criteria More... | |
template<typename T , std::size_t NDIM> | |
void | refine_to_common_level (World &world, std::vector< Function< T, NDIM > > &vf, bool fence=true) |
refine all functions to a common (finest) level More... | |
void | reset_papi_measurement () |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | rot (const std::vector< Function< T, NDIM > > &v, bool do_refine=false, bool fence=true) |
shorthand rot operator More... | |
template<typename T > | |
DistributedMatrix< T > | row_distributed_matrix (World &world, int64_t n, int64_t m, int64_t rowtile=0) |
Generates an (n,m) matrix distributed by rows (column dimension is not distributed) More... | |
static DistributedMatrixDistribution | row_distributed_matrix_distribution (World &world, int64_t n, int64_t m, int64_t rowtile) |
Generates an (n,m) matrix distribution distributed by rows (column dimension is not distributed) More... | |
template void | rr_cholesky (Tensor< double > &A, typename Tensor< double >::scalar_type tol, Tensor< integer > &piv, int &rank) |
template void | rr_cholesky (Tensor< double_complex > &A, typename Tensor< double_complex >::scalar_type tol, Tensor< integer > &piv, int &rank) |
template<typename T > | |
void | rr_cholesky (Tensor< T > &A, typename Tensor< T >::scalar_type tol, Tensor< integer > &piv, int &rank) |
Compute the rank-revealing Cholesky factorization. More... | |
static double | rsquared (const coordT &r) |
template<class T , std::size_t NDIM> | |
void | save (const Function< T, NDIM > &f, const std::string name) |
template<typename T , size_t NDIM> | |
void | save_function (const std::vector< Function< T, NDIM > > &f, const std::string name) |
save a vector of functions More... | |
template<typename T > | |
std::vector< std::shared_ptr< ScalarResult< T > > > | scalar_result_shared_ptr_vector (World &world, std::size_t n) |
helper function to create a vector of ScalarResult, circumventing problems with the constructors More... | |
response_space | scale (response_space a, double b) |
template<typename T , typename Q , std::size_t NDIM> | |
void | scale (World &world, std::vector< Function< T, NDIM > > &v, const Q factor, bool fence=true) |
Scales inplace a vector of functions by the same. More... | |
template<typename T , typename Q , std::size_t NDIM> | |
void | scale (World &world, std::vector< Function< T, NDIM > > &v, const Q factor, const unsigned int blk=1, const bool fence=true) |
Scales inplace a vector of functions by the same. More... | |
template<typename T , typename Q , std::size_t NDIM> | |
void | scale (World &world, std::vector< Function< T, NDIM > > &v, const std::vector< Q > &factors, bool fence=true) |
Scales inplace a vector of functions by distinct values. More... | |
template<typename T , typename Q , std::size_t NDIM> | |
void | scale (World &world, std::vector< Function< T, NDIM > > &v, const std::vector< Q > &factors, const unsigned int blk=1, const bool fence=true) |
Scales inplace a vector of functions by distinct values. More... | |
response_space | scale_2d (World &world, const response_space &a, const Tensor< double > &b) |
template<typename Archive > | |
void | serialize_am_args (Archive &&) |
Terminate argument serialization. More... | |
template<typename Archive , typename T , typename... argT> | |
void | serialize_am_args (Archive &&archive, T &&t, argT &&... args) |
Argument serialization. More... | |
template<typename T , std::size_t NDIM> | |
void | set_impl (std::vector< Function< T, NDIM >> &v, const std::vector< std::shared_ptr< FunctionImpl< T, NDIM >>> vimpl) |
void | set_thread_tag (int tag) |
void | set_thread_tag (ThreadTag tag) |
template<typename T , std::size_t NDIM> | |
void | set_thresh (World &world, std::vector< Function< T, NDIM > > &v, double thresh, bool fence=true) |
Sets the threshold in a vector of functions. More... | |
template<std::size_t NDIM> | |
static void | sim_to_user (const Vector< double, NDIM > &xsim, Vector< double, NDIM > &xuser) |
Convert simulation coords ([0,1]^ndim) to user coords (FunctionDefaults<NDIM>::get_cell()) More... | |
template<typename T , std::size_t NDIM> | |
static Key< NDIM > | simpt2key (const Vector< T, NDIM > &pt, Level n) |
template<typename T , std::size_t NDIM> | |
double | size_of (const intermediateT< T, NDIM > &im) |
Returns the size of an intermediate. More... | |
static double | slater_functor (const coord_3d &x) |
double | slater_radius (int atomic_number) |
static SeparatedConvolution< double, 3 > | SlaterF12Operator (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
static SeparatedConvolution< double, 3 > * | SlaterF12OperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
Factory function generating separated kernel for convolution with (1 - exp(-mu*r))/(2 mu) in 3D. More... | |
static SeparatedConvolution< double, 3 > | SlaterF12sqOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
static SeparatedConvolution< double, 3 > * | SlaterF12sqOperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
template<std::size_t NDIM = 3> | |
static SeparatedConvolution< double, NDIM > | SlaterOperator (World &world, double mu, double lo, double eps, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
Factory function generating separated kernel for convolution with exp(-mu*r) in 3D. More... | |
static SeparatedConvolution< double, 3 > * | SlaterOperatorPtr (World &world, double mu, double lo, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > * | SlaterOperatorPtr_ND (World &world, double mu, double lo, double eps, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
double | smoothed_density (double r) |
Charge density corresponding to smoothed 1/r potential. More... | |
double | smoothed_potential (double r) |
Smoothed 1/r potential. More... | |
double | smoothing_parameter (double Z, double eprec) |
Returns radius for smoothing nuclear potential with energy precision eprec. More... | |
template<std::size_t NDIM> | |
static SeparatedConvolution< double, NDIM > | SmoothingOperator (World &world, double eps, const BoundaryConditions< NDIM > &bc=FunctionDefaults< NDIM >::get_bc(), int k=FunctionDefaults< NDIM >::get_k()) |
static SeparatedConvolution< double, 3 > | SmoothingOperator3D (World &world, double eps, const BoundaryConditions< 3 > &bc=FunctionDefaults< 3 >::get_bc(), int k=FunctionDefaults< 3 >::get_k()) |
SPEC (double, double_complex, double_complex) | |
SPEC (double, float_complex, float_complex) | |
SPEC (float, double, double) | |
SPEC (float, double_complex, double_complex) | |
SPEC (float, float_complex, float_complex) | |
SPEC (float_complex, double_complex, double_complex) | |
SPEC (int, double, double) | |
SPEC (int, double_complex, double_complex) | |
SPEC (int, float, float) | |
SPEC (int, float_complex, float_complex) | |
SPEC (int, long, long) | |
SPEC (long, double, double) | |
SPEC (long, double_complex, double_complex) | |
SPEC (long, float, float) | |
SPEC (long, float_complex, float_complex) | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | square (const Function< T, NDIM > &f, bool fence=true) |
Create a new function that is the square of f - global comm only if not reconstructed. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | square (World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true) |
Computes the square of a vector of functions — q[i] = v[i]**2. More... | |
template<typename T , std::size_t NDIM> | |
void | standard (World &world, std::vector< Function< T, NDIM > > &v, bool fence=true) |
Generates standard form of a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
void | standard (World &world, std::vector< Function< T, NDIM > > &v, unsigned int blk=1, bool fence=true) |
Generates standard form of a vector of functions. More... | |
static void | START_TIMER (World &world) |
void | startup (World &world, int argc, char **argv, bool doprint=false, bool make_stdcout_nice_to_reals=true) |
template<typename T > | |
T | stheta_fd (const T &x) |
template<typename T > | |
static std::string | stringify (T arg) |
template<typename L , typename R , std::size_t NDIM> | |
Function< TENSOR_RESULT_TYPE(L, R), NDIM > | sub (const Function< L, NDIM > &left, const Function< R, NDIM > &right, bool fence=true) |
Same as operator- but with optional fence and no automatic compression. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | sub (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true) |
Returns new vector of functions — q[i] = a[i] - b[i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | sub (World &world, const std::vector< Function< T, NDIM > > &a, const std::vector< Function< R, NDIM > > &b, bool fence=true, unsigned int blk=1) |
Returns new vector of functions — q[i] = a[i] - b[i]. More... | |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | sum (World &world, const std::vector< Function< T, NDIM > > &f, bool fence=true) |
Returns new function — q = sum_i f[i]. More... | |
template<> | |
void | svd (char jobu, char jobvt, integer m, integer n, complex_real4 *A, integer lda, real4 *S, complex_real4 *U, integer ldu, complex_real4 *VT, integer ldvt) |
template<> | |
void | svd (char jobu, char jobvt, integer m, integer n, complex_real8 *A, integer lda, real8 *S, complex_real8 *U, integer ldu, complex_real8 *VT, integer ldvt) |
template<> | |
void | svd (char jobu, char jobvt, integer m, integer n, real4 *A, integer lda, real4 *S, real4 *U, integer ldu, real4 *VT, integer ldvt) |
template<> | |
void | svd (char jobu, char jobvt, integer m, integer n, real8 *A, integer lda, real8 *S, real8 *U, integer ldu, real8 *VT, integer ldvt) |
template<typename T > | |
void | svd (char jobu, char jobvt, integer m, integer n, T *A, integer lda, typename detail::real_type< T >::type *S, T *U, integer ldu, T *VT, integer ldvt) |
Compute the SVD via LAPACK. More... | |
template void | svd (const Tensor< double > &a, Tensor< double > &U, Tensor< Tensor< double >::scalar_type > &s, Tensor< double > &VT) |
template void | svd (const Tensor< double_complex > &a, Tensor< double_complex > &U, Tensor< Tensor< double_complex >::scalar_type > &s, Tensor< double_complex > &VT) |
template void | svd (const Tensor< float > &a, Tensor< float > &U, Tensor< Tensor< float >::scalar_type > &s, Tensor< float > &VT) |
template void | svd (const Tensor< float_complex > &a, Tensor< float_complex > &U, Tensor< Tensor< float_complex >::scalar_type > &s, Tensor< float_complex > &VT) |
template<typename T > | |
std::tuple< Tensor< T >, Tensor< typename Tensor< T >::scalar_type >, Tensor< T > > | svd (const Tensor< T > &A) |
SVD - MATLAB syntax. More... | |
template<typename T > | |
void | svd (const Tensor< T > &a, Tensor< T > &U, Tensor< typename Tensor< T >::scalar_type > &s, Tensor< T > &VT) |
Compute the singluar value decomposition of an n-by-m matrix using *gesvd. More... | |
template void | svd_result (Tensor< double > &a, Tensor< double > &U, Tensor< Tensor< double >::scalar_type > &s, Tensor< double > &VT, Tensor< double > &work) |
template void | svd_result (Tensor< double_complex > &a, Tensor< double_complex > &U, Tensor< Tensor< double_complex >::scalar_type > &s, Tensor< double_complex > &VT, Tensor< double_complex > &work) |
template void | svd_result (Tensor< float > &a, Tensor< float > &U, Tensor< Tensor< float >::scalar_type > &s, Tensor< float > &VT, Tensor< float > &work) |
template void | svd_result (Tensor< float_complex > &a, Tensor< float_complex > &U, Tensor< Tensor< float_complex >::scalar_type > &s, Tensor< float_complex > &VT, Tensor< float_complex > &work) |
template<typename T > | |
void | svd_result (Tensor< T > &a, Tensor< T > &U, Tensor< typename Tensor< T >::scalar_type > &s, Tensor< T > &VT, Tensor< T > &work) |
same as svd, but it optimizes away the tensor construction: a = U * diag(s) * VT More... | |
template<typename T , typename U > | |
void | swap (RemoteReference< T > &l, RemoteReference< U > &r) |
Swap the two remote references. More... | |
template<typename T , std::size_t N> | |
void | swap (Vector< T, N > &l, Vector< T, N > &r) |
Swap the contents of two Vector s. More... | |
template<typename keyT , typename valueT , typename hashfunT > | |
void | swap (WorldContainer< keyT, valueT, hashfunT > &dc0, WorldContainer< keyT, valueT, hashfunT > &dc1) |
Swaps the content of two WorldContainer objects. It should be called on all nodes. More... | |
template<typename T , std::size_t NDIM> | |
std::enable_if_t< NDIM%2==0, Function< T, NDIM > > | swap_particles (const Function< T, NDIM > &f) |
swap particles 1 and 2 More... | |
template void | syev (const Tensor< double > &A, Tensor< double > &V, Tensor< Tensor< double >::scalar_type > &e) |
template void | syev (const Tensor< double_complex > &A, Tensor< double_complex > &V, Tensor< Tensor< double_complex >::scalar_type > &e) |
template<typename T > | |
std::tuple< Tensor< typename Tensor< T >::scalar_type >, Tensor< T > > | syev (const Tensor< T > &A) |
Solves symmetric or Hermitian eigenvalue problem - MATLAB syntax. More... | |
template<typename T > | |
void | syev (const Tensor< T > &A, Tensor< T > &V, Tensor< typename Tensor< T >::scalar_type > &e) |
Real-symmetric or complex-Hermitian eigenproblem. More... | |
template void | sygv (const Tensor< double > &A, const Tensor< double > &B, int itype, Tensor< double > &V, Tensor< Tensor< double >::scalar_type > &e) |
template void | sygv (const Tensor< double_complex > &A, const Tensor< double_complex > &B, int itype, Tensor< double_complex > &V, Tensor< Tensor< double_complex >::scalar_type > &e) |
template<typename T > | |
void | sygv (const Tensor< T > &A, const Tensor< T > &B, int itype, Tensor< T > &V, Tensor< typename Tensor< T >::scalar_type > &e) |
Generalized real-symmetric or complex-Hermitian eigenproblem. More... | |
template<typename T > | |
void | sygvp (World &world, const Tensor< T > &a, const Tensor< T > &B, int itype, Tensor< T > &V, Tensor< typename Tensor< T >::scalar_type > &e) |
unsigned int | symbol_to_atomic_number (const std::string &symbol) |
template<typename T , std::size_t NDIM> | |
Function< T, NDIM > | symmetrize (const Function< T, NDIM > &f, const std::string symmetry, bool fence=true) |
symmetrize a function More... | |
template<typename Q > | |
Tensor< Q > | tensor_abs (const Tensor< std::complex< Q > > &c) |
template<typename Q > | |
Tensor< std::complex< Q > > | tensor_real2complex (const Tensor< Q > &r) |
template<typename T , typename R , std::size_t NDIM> | |
TENSOR_RESULT_TYPE (T, R) inner(const Function< T | |
Computes the scalar/inner product between two functions. More... | |
template<typename T , typename opT , std::size_t NDIM> | |
TENSOR_RESULT_TYPE (T, typename opT::value_type) inner(const Function< T | |
Computes the scalar/inner product between an MRA function and an external functor. More... | |
template<typename T , typename opT , std::size_t NDIM> | |
TENSOR_RESULT_TYPE (T, typename opT::value_type) inner(const opT &g | |
Computes the scalar/inner product between an MRA function and an external functor. More... | |
template<typename Q > | |
Tensor< Q > | tensor_ximag (const Tensor< std::complex< Q > > &c) |
template<typename Q > | |
Tensor< Q > | tensor_xreal (const Tensor< std::complex< Q > > &c) |
static double | test_1d_functor (const coord_1d &x) |
bool | test_autoc () |
template<typename T > | |
double | test_cholesky (int n) |
template<typename T > | |
int | test_exchange (World &world) |
template<typename T > | |
double | test_gelss (int n, int nrhs) |
template<typename T > | |
double | test_gesv (int n, int nrhs) |
template<typename T > | |
double | test_inverse (int n) |
Example and test code for interface to LAPACK SVD interfae. More... | |
template<typename T > | |
double | test_qr () |
bool | test_rnlp () |
template<typename T > | |
double | test_rr_cholesky (int n) |
template<typename T > | |
double | test_svd (int n, int m) |
Example and test code for interface to LAPACK SVD interfae. More... | |
template<typename T > | |
double | test_syev (int n) |
template<typename T > | |
double | test_sygv (int n) |
bool | test_tensor_lapack () |
Test the Tensor-LAPACK interface ... currently always returns true! More... | |
bool | test_two_scale_coefficients () |
static double | testf (int n, double x) |
void | threadpool_wait_policy (WaitPolicy policy, int sleep_duration_in_microseconds=0) |
static void | time_transform (World &world, int &mflopslo, int &mflopshi) |
auto | to_conjugate_response_matrix (const X_space &x) -> response_matrix |
auto | to_conjugate_X_space (const response_matrix &x) -> X_space |
response_matrix [x,y] -> Xspace X.x=y X.y=conjugate(x) More... | |
auto | to_flattened_vector (const X_space &x) -> vector_real_function_3d |
Flattens all response functions into a single vector of functions. More... | |
void | to_json (nlohmann::json &j) |
auto | to_response_matrix (const X_space &x) -> response_matrix |
auto | to_response_vector (const vector_real_function_3d &vec) -> vector_real_function_3d |
auto | to_X_space (const response_matrix &x) -> X_space |
template<typename R , typename Q > | |
GenTensor< TENSOR_RESULT_TYPE(R, Q)> | transform (const GenTensor< R > &t, const Tensor< Q > &c) |
template<typename R , typename Q > | |
SVDTensor< TENSOR_RESULT_TYPE(R, Q)> | transform (const SVDTensor< R > &t, const Tensor< Q > &c) |
template<class T , class Q > | |
Tensor< TENSOR_RESULT_TYPE(T, Q)> | transform (const Tensor< T > &t, const Tensor< Q > &c) |
Transform all dimensions of the tensor t by the matrix c. More... | |
template<class T , class Q > | |
TensorTrain< TENSOR_RESULT_TYPE(T, Q)> | transform (const TensorTrain< T > &t, const Tensor< Q > &c) |
transform each dimension with the same operator matrix More... | |
template<typename L , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(L, R), NDIM > > | transform (World &world, const std::vector< Function< L, NDIM > > &v, const Tensor< R > &c, const double tol, const unsigned int blki=1, const bool fence) |
template<typename L , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(L, R), NDIM > > | transform (World &world, const std::vector< Function< L, NDIM > > &v, const Tensor< R > &c, double tol, bool fence) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | transform (World &world, const std::vector< Function< T, NDIM > > &v, const DistributedMatrix< R > &c, bool fence=true) |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | transform (World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i]. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | transform (World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, unsigned int blki=1, unsigned int blkj=1, const bool fence=true) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i]. More... | |
template<typename R , typename Q > | |
GenTensor< TENSOR_RESULT_TYPE(R, Q)> | transform_dir (const GenTensor< R > &t, const Tensor< Q > &c, const int axis) |
template<typename R , typename Q > | |
SVDTensor< TENSOR_RESULT_TYPE(R, Q)> | transform_dir (const SVDTensor< R > &t, const Tensor< Q > &c, const int axis) |
template<class T , class Q > | |
Tensor< TENSOR_RESULT_TYPE(T, Q)> | transform_dir (const Tensor< T > &t, const Tensor< Q > &c, int axis) |
Transforms one dimension of the tensor t by the matrix c, returns new contiguous tensor. More... | |
template<class T , class Q > | |
TensorTrain< TENSOR_RESULT_TYPE(T, Q)> | transform_dir (const TensorTrain< T > &t, const Tensor< Q > &c, const int axis) |
Transforms one dimension of the tensor t by the matrix c, returns new contiguous tensor. More... | |
template<typename T , typename R , std::size_t NDIM> | |
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > | transform_reconstructed (World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i]. More... | |
template<class T > | |
Tensor< T > | transpose (const Tensor< T > &t) |
Returns a new deep copy of the transpose of the input tensor. More... | |
response_space | transpose (response_space &f) |
auto | transposeResponseMatrix (const response_matrix &x) -> response_matrix |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | truncate (std::vector< Function< T, NDIM > > v, double tol=0.0, bool fence=true) |
Truncates a vector of functions. More... | |
void | truncate (World &world, response_space &v, double tol, bool fence) |
template<typename T , std::size_t NDIM> | |
void | truncate (World &world, std::vector< Function< T, NDIM > > &v, double tol=0.0, bool fence=true) |
Truncates a vector of functions. More... | |
template<typename T , std::size_t NDIM> | |
void | truncate (World &world, std::vector< Function< T, NDIM > > &v, double tol=0.0, unsigned int blk=1, bool fence=true) |
Truncates a vector of functions. More... | |
bool | try_two_locks (const Mutex &m1, const Mutex &m2) |
Attempt to acquire two locks without blocking holding either one. More... | |
template<typename T > | |
TensorTrain< T > | tt_identity (const long ndim, const long k) |
compute the n-D identity operator with k elements per dimension More... | |
bool | two_scale_coefficients (int k, Tensor< double > *h0, Tensor< double > *h1, Tensor< double > *g0, Tensor< double > *g1) |
Return the two scale coefficients in the Legendre basis. More... | |
bool | two_scale_hg (int k, Tensor< double > *hg) |
std::string | type (const EnergyType &n) |
std::string | type (const GuessType &n) |
std::string | type (const PairType &n) |
TYPEINFO (0, int, false, true, int, double) | |
TYPEINFO (1, long, false, true, long, double) | |
TYPEINFO (2, float, false, true, float, float) | |
TYPEINFO (3, double, false, true, double, double) | |
TYPEINFO (4, float_complex, true, true, float, float) | |
TYPEINFO (5, double_complex, true, true, double, double) | |
template<typename Q , typename opT , std::size_t NDIM> | |
Function< typename opT::resultT, NDIM > | unary_op (const Function< Q, NDIM > &func, const opT &op, bool fence=true) |
Out of place application of unary operation to function values with optional fence. More... | |
template<typename Q , typename opT , std::size_t NDIM> | |
Function< typename opT::resultT, NDIM > | unary_op_coeffs (const Function< Q, NDIM > &func, const opT &op, bool fence=true) |
Out of place application of unary operation to scaling function coefficients with optional fence. More... | |
std::string | unique_fileid () |
creates a unique filename, using PBS ID if available More... | |
template<std::size_t NDIM> | |
static double | unitfunctor (const Vector< double, NDIM > &x) |
template<typename T , std::size_t N> | |
Vector< T, N > | unitvec (const Vector< T, N > &r, const double eps=1.e-6) |
Construct a unit-Vector that has the same direction as r . More... | |
template<std::size_t NDIM> | |
static void | user_to_sim (const Vector< double, NDIM > &xuser, Vector< double, NDIM > &xsim) |
Convert user coords (cell[][]) to simulation coords ([0,1]^ndim) More... | |
template<typename T , typename... Ts> | |
Vector< T, sizeof...(Ts)+1 > | vec (T t, Ts... ts) |
Factory function for creating a madness::Vector . More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2, const T &v3) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T > | |
std::vector< T > | vector_factory (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7) |
Returns a std::vector<T> initialized from the arguments. More... | |
template<typename T , std::size_t NDIM> | |
static void | verify_tree (World &world, const std::vector< Function< T, NDIM > > &v) |
template<typename L , typename R , std::size_t D> | |
std::vector< Function< TENSOR_RESULT_TYPE(L, R), D > > | vmulXX (const Function< L, D > &left, const std::vector< Function< R, D > > &vright, double tol, bool fence=true) |
Use the vmra/mul(...) interface instead. More... | |
double | wall_time () |
Returns the wall time in seconds relative to an arbitrary origin. More... | |
WorldMemInfo * | world_mem_info () |
Returns pointer to internal structure. More... | |
void | write_molecules_to_file (const Molecule &molecule, const std::string &geo_file) |
int | x_rks_s__ (const double *r__, double *f, double *dfdra) |
int | x_uks_s__ (double *ra, double *rb, double *f, double *dfdra, double *dfdrb) |
static double | xf (const coord_3d &x) |
void | xterm_debug (const char *path, const char *display) |
void | xterm_debug_breakpoint () |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | zero_functions (World &world, int n) |
Generates a vector of zero functions. More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | zero_functions (World &world, int n, bool fence=true) |
Generates a vector of zero functions (reconstructed) More... | |
template<typename T , std::size_t NDIM> | |
std::vector< Function< T, NDIM > > | zero_functions_compressed (World &world, int n, bool fence=true) |
Generates a vector of zero functions (compressed) More... | |
print_meminfo | |
These functions are useful to instrument aggregate (not fine-grained, like WorldMemInfo) memory profiling.
| |
template<typename String > | |
void | print_meminfo (int rank, const String &tag, const std::string filename_prefix=std::string("MEMORY"), bool verbose=false) |
print aggregate memory stats to file filename_prefix .<rank> , tagged with tag More... | |
Variables | |
static const std::vector< Slice > | ___ = vector_factory(_,_,_,_,_,_) |
Entire dimension. More... | |
static Tensor< double > | _c |
static Tensor< double > | _cread |
const double | acut1e_6 = 0.25 |
static const AtomicData | atomic_data [NUMBER_OF_ATOMS_IN_TABLE] |
static const char * | autocorr_filename = "autocorr" |
ThreadBinder | binder |
const double | c_b14 = 1.333333333333333333333333333333 |
const double | c_b2 = 0.333333333333333333333333333333333 |
const double | c_b7 = 0.333333333333333333333333333333 |
static class madness::twoscale_cache_class | cache [kmax+1] |
static double | cutoff_radius = 5.0 |
static bool | data_is_read = false |
static const long | default_jdim = 5551212 |
Random | default_random_generator |
The default random number stream. More... | |
static const string | dir = "coredata/" |
static const Tag | DYNAMIC_TAG_BASE = 1024 |
NDIM & | f |
static const char * | filename = "gaussleg" |
NDIM const Function< R, NDIM > & | g |
template<typename T , typename Archive > | |
constexpr bool | has_freestanding_default_serialize_v = madness::meta::is_detected_v<madness::has_freestanding_default_serialize_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_freestanding_default_serialize_with_size_v = madness::meta::is_detected_v<madness::has_freestanding_default_serialize_with_size_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_freestanding_serialize_v = madness::meta::is_detected_v<madness::has_freestanding_serialize_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_freestanding_serialize_with_size_v = madness::meta::is_detected_v<madness::has_freestanding_serialize_with_size_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_freestanding_serialize_with_version_v = madness::meta::is_detected_v<madness::has_freestanding_serialize_with_version_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_member_serialize_v = madness::meta::is_detected_v<madness::has_member_serialize_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_member_serialize_with_version_v = madness::meta::is_detected_v<madness::has_member_serialize_with_version_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_load_and_store_v = has_nonmember_load_v<T, Archive> && has_nonmember_store_v<T, Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_load_v = madness::meta::is_detected_v<madness::has_nonmember_load_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_serialize_v = madness::meta::is_detected_v<madness::has_nonmember_serialize_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_store_v = madness::meta::is_detected_v<madness::has_nonmember_store_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_wrap_load_and_store_v = has_nonmember_wrap_load_v<T, Archive> && has_nonmember_wrap_store_v<T, Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_wrap_load_v = madness::meta::is_detected_v<madness::has_nonmember_wrap_load_t,T,Archive> |
template<typename T , typename Archive > | |
constexpr bool | has_nonmember_wrap_store_v = madness::meta::is_detected_v<madness::has_nonmember_wrap_store_t,T,Archive> |
template<typename T > | |
constexpr bool | is_always_serializable |
template<typename T > | |
constexpr bool | is_any_function_pointer_v = is_any_function_pointer<T>::value |
template<typename T > | |
constexpr bool | is_archive_v = meta::is_detected_v<is_archive_defined_t,T> |
template<typename Archive , typename T > | |
constexpr bool | is_default_serializable_v = is_default_serializable<Archive, T>::value |
template<typename Archive , typename T > | |
constexpr bool | is_default_serializable_v< Archive, const T > = is_default_serializable_v<Archive, T> |
template<typename T > | |
constexpr bool | is_function_pointer_v = is_function_pointer<T>::value |
template<typename T > | |
constexpr bool | is_input_archive_v = meta::is_detected_v<is_input_archive_defined_t, T> |
template<typename T > | |
constexpr bool | is_iostreammable_v = is_istreammable_v<T> && is_ostreammable_v<T> |
providing automatic support for serializing to/from std streams requires bidirectional streammability More... | |
template<typename T > | |
constexpr bool | is_istreammable_v = is_istreammable<T>::value |
Shortcut for is_istreammable<T>::value . More... | |
template<typename T > | |
constexpr bool | is_ostreammable_v = is_ostreammable<T>::value |
Shortcut for is_ostreammable<T>::value . More... | |
template<typename T > | |
constexpr bool | is_output_archive_v = meta::is_detected_v<is_output_archive_defined_t, T> |
template<typename Archive , typename T > | |
constexpr bool | is_serializable_v |
template<typename Archive , typename T > | |
constexpr bool | is_serializable_v< Archive, const T > = is_serializable_v<Archive, T> |
template<typename Archive > | |
constexpr const bool | is_text_archive_v = is_text_archive<Archive>::value |
is_text_archive_v is a shorthand for is_text_archive<A>::value More... | |
template<typename T > | |
constexpr bool | is_trivially_serializable_v = is_trivially_serializable<T>::value |
template<typename Archive , typename T > | |
constexpr bool | is_user_serializable_v |
template<typename Archive , typename T > | |
constexpr bool | is_user_serializable_v< Archive, const T > = is_user_serializable_v<Archive, T> |
static int | kcur = -1 |
static const int | kmax = 60 |
static const int | kmax_autoc = 30 |
static int | kread = -1 |
static bool | loaded = 0 |
static double | mask_factor = 5.0 |
static const int | max_npt = 64 |
static const int | MAXK = 30 |
The maximum wavelet order presently supported. More... | |
static const int | MAXLEVEL = 8*sizeof(Translation)-2 |
The maximum depth of refinement possible. More... | |
static double | nn1 [100] |
static const unsigned int | NUMBER_OF_ATOMS_IN_TABLE = 110 |
const int | NUMEVENTS = 0 |
static double | phi_norms [100] |
static Tensor< double > | points [max_npt+1] |
static bool | print_timings = false |
static std::string | reduction_alg ="divide_conquer" |
static std::atomic< bool > | rmi_task_is_running = false |
static std::vector< double > | sss |
const char * | tensor_type_names [] |
static AtomicInt | threadcounter |
static std::vector< double > | ttt |
static const char * | twoscale_filename = "coeffs" |
static Tensor< double > | weights [max_npt+1] |
File holds all helper structures necessary for the CC_Operator and CC2 class.
Namespace for all elements and tools of MADNESS.
this block needs to be known before nonlinsol.h is included (happens when nemo is included) better move this to nonlinsol.h
We provide an abstract base class FunctionFunctorInterface, of which we derive (as of now) the following classes:
Each of these Interfaces can be used in a FunctionFactory to set up a Function
If you can recall the Intel hypercubes, their comm lib used GOP as the abbreviation.
typedef void(* madness::am_handlerT) (const AmArg &) |
Type of AM handler functions.
typedef std::shared_ptr<complex_convolution_1d> madness::complex_convolution_1d_ptr |
typedef std::shared_ptr<complex_convolution_2d> madness::complex_convolution_2d_ptr |
typedef std::shared_ptr<complex_convolution_3d> madness::complex_convolution_3d_ptr |
typedef std::shared_ptr<complex_convolution_4d> madness::complex_convolution_4d_ptr |
typedef std::shared_ptr<complex_convolution_5d> madness::complex_convolution_5d_ptr |
typedef std::shared_ptr<complex_convolution_6d> madness::complex_convolution_6d_ptr |
typedef Function<double_complex,1> madness::complex_function_1d |
typedef Function<double_complex,2> madness::complex_function_2d |
typedef Function<double_complex,3> madness::complex_function_3d |
typedef Function<double_complex,4> madness::complex_function_4d |
typedef Function<double_complex,5> madness::complex_function_5d |
typedef Function<double_complex,6> madness::complex_function_6d |
typedef Function<std::complex<double>, 3> madness::complex_functionT |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,1> > madness::complex_functor_1d |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,2> > madness::complex_functor_2d |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,3> > madness::complex_functor_3d |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,4> > madness::complex_functor_4d |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,5> > madness::complex_functor_5d |
typedef std::shared_ptr< FunctionFunctorInterface<double_complex,6> > madness::complex_functor_6d |
typedef Tensor<double_complex> madness::complex_tensor |
typedef Vector<double,1> madness::coord_1d |
typedef Vector<double,2> madness::coord_2d |
typedef Vector< double, 3 > madness::coord_3d |
typedef Vector<double,4> madness::coord_4d |
typedef Vector<double,5> madness::coord_5d |
typedef Vector< double, 6 > madness::coord_6d |
typedef Vector< double, 3 > madness::coordT |
typedef std::vector<complex_functionT> madness::cvecfuncT |
using madness::decay_tuple = typedef decltype(decay_types(std::declval<T>())) |
typedef DistributedMatrix<double> madness::distmatT |
typedef std::pair<uniqueidT, std::size_t> madness::DistributedID |
Distributed ID which is used to identify objects.
typedef FunctionFactory< double, 3 > madness::factoryT |
typedef FunctionDefaults<1> madness::function_defaults_1d |
typedef FunctionDefaults<2> madness::function_defaults_2d |
typedef FunctionDefaults<3> madness::function_defaults_3d |
typedef FunctionDefaults<4> madness::function_defaults_4d |
typedef FunctionDefaults<5> madness::function_defaults_5d |
typedef FunctionDefaults<6> madness::function_defaults_6d |
typedef Function< double, 3 > madness::functionT |
typedef std::shared_ptr< FunctionFunctorInterface< double, 3 > > madness::functorT |
using madness::future_to_ref_t = typedef typename future_to_ref< T >::type |
using madness::has_freestanding_default_serialize_t = typedef decltype(default_serialize(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports freestanding default_serialize
function
using madness::has_freestanding_default_serialize_with_size_t = typedef decltype(default_serialize(std::declval<Archive&>(), std::declval<const T&>(), 1u)) |
helps to detect that T=U*
supports freestanding default_serialize
function
using madness::has_freestanding_serialize_t = typedef decltype(serialize(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports freestanding serialize
function
using madness::has_freestanding_serialize_with_size_t = typedef decltype(serialize(std::declval<Archive&>(), std::declval<T&>(), 1u)) |
helps to detect that T=U*
supports freestanding serialize
function
using madness::has_freestanding_serialize_with_version_t = typedef decltype(serialize(std::declval<Archive&>(), std::declval<T&>(), 0u)) |
helps to detect that T
supports freestanding serialize
function that accepts version
using madness::has_member_serialize_t = typedef decltype(std::declval<T&>().serialize(std::declval<Archive&>())) |
helps to detect that T
has a member serialization method that accepts single argument of type Archive
using madness::has_member_serialize_with_version_t = typedef decltype(std::declval<T&>().serialize(std::declval<Archive&>(),0u)) |
helps to detect that T
has a member serialization method that accepts one argument of type Archive
and an unsigned version
using madness::has_nonmember_load_t = typedef decltype(madness::archive::ArchiveLoadImpl<Archive, T>::load(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports nonintrusive asymmetric serialization via load
using madness::has_nonmember_serialize_t = typedef decltype(madness::archive::ArchiveSerializeImpl<Archive, T>::serialize(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports nonintrusive symmetric serialization
using madness::has_nonmember_store_t = typedef decltype(madness::archive::ArchiveStoreImpl<Archive, T>::store(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports nonintrusive asymmetric serialization via store
using madness::has_nonmember_wrap_load_t = typedef decltype(madness::archive::ArchiveImpl<Archive, T>::wrap_load(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports nonintrusive asymmetric serialization via wrap_load
using madness::has_nonmember_wrap_store_t = typedef decltype(madness::archive::ArchiveImpl<Archive, T>::wrap_store(std::declval<Archive&>(), std::declval<T&>())) |
helps to detect that T
supports nonintrusive asymmetric serialization via wrap_store
typedef std::size_t madness::hashT |
The hash value type.
using madness::intermediateT = typedef Pairs<Function<T,NDIM> > |
f12 and g12 intermediates of the form <f1|op|f2> (with op=f12 or op=g12) will be saved using the pair structure
using madness::is_archive_defined_t = typedef typename is_archive<std::remove_reference_t<std::remove_cv_t<T> >>::type |
using madness::is_input_archive_defined_t = typedef typename is_input_archive<std::remove_reference_t<std::remove_cv_t<T> >>::type |
using madness::is_output_archive_defined_t = typedef typename is_output_archive<std::remove_reference_t<std::remove_cv_t<T> >>::type |
using madness::json = typedef nlohmann::json |
typedef int madness::Level |
typedef NonlinearSolverND<3> madness::NonlinearSolver |
typedef XNonlinearSolver<std::vector<Function<double,3> >,double,vector_function_allocator<double,3> > madness::NonlinearVectorSolver_3d |
typedef XNonlinearSolver<std::vector<Function<double,6> >,double,vector_function_allocator<double,6> > madness::NonlinearVectorSolver_6d |
typedef SeparatedConvolution<double, 3> madness::operatorT |
typedef std::pair<vecfuncT, vecfuncT> madness::pairvecfuncT |
typedef std::shared_ptr< WorldDCPmapInterface< Key<1> > > madness::pmap_1d |
typedef std::shared_ptr< WorldDCPmapInterface< Key<2> > > madness::pmap_2d |
typedef std::shared_ptr< WorldDCPmapInterface< Key<3> > > madness::pmap_3d |
typedef std::shared_ptr< WorldDCPmapInterface< Key<4> > > madness::pmap_4d |
typedef std::shared_ptr< WorldDCPmapInterface< Key<5> > > madness::pmap_5d |
typedef std::shared_ptr< WorldDCPmapInterface< Key<6> > > madness::pmap_6d |
typedef std::shared_ptr<WorldDCPmapInterface<Key<3> > > madness::pmapT |
typedef std::shared_ptr<operatorT> madness::poperatorT |
typedef SeparatedConvolution<double,1> madness::real_convolution_1d |
typedef std::shared_ptr<real_convolution_1d> madness::real_convolution_1d_ptr |
typedef SeparatedConvolution<double,2> madness::real_convolution_2d |
typedef std::shared_ptr<real_convolution_2d> madness::real_convolution_2d_ptr |
typedef SeparatedConvolution<double,3> madness::real_convolution_3d |
typedef std::shared_ptr<real_convolution_3d> madness::real_convolution_3d_ptr |
typedef SeparatedConvolution<double,4> madness::real_convolution_4d |
typedef std::shared_ptr<real_convolution_4d> madness::real_convolution_4d_ptr |
typedef SeparatedConvolution<double,5> madness::real_convolution_5d |
typedef std::shared_ptr<real_convolution_5d> madness::real_convolution_5d_ptr |
typedef SeparatedConvolution<double,6> madness::real_convolution_6d |
typedef std::shared_ptr<real_convolution_6d> madness::real_convolution_6d_ptr |
typedef Derivative<double,1> madness::real_derivative_1d |
typedef Derivative<double,2> madness::real_derivative_2d |
typedef Derivative<double,3> madness::real_derivative_3d |
typedef Derivative<double,4> madness::real_derivative_4d |
typedef Derivative<double,5> madness::real_derivative_5d |
typedef Derivative<double,6> madness::real_derivative_6d |
typedef FunctionFactory<double,1> madness::real_factory_1d |
typedef FunctionFactory<double,2> madness::real_factory_2d |
typedef FunctionFactory<double,3> madness::real_factory_3d |
typedef FunctionFactory<double,4> madness::real_factory_4d |
typedef FunctionFactory<double,5> madness::real_factory_5d |
typedef FunctionFactory<double,6> madness::real_factory_6d |
typedef FunctionImpl<double,1> madness::real_funcimpl_1d |
typedef FunctionImpl<double,2> madness::real_funcimpl_2d |
typedef FunctionImpl<double,3> madness::real_funcimpl_3d |
typedef FunctionImpl<double,4> madness::real_funcimpl_4d |
typedef FunctionImpl<double,5> madness::real_funcimpl_5d |
typedef FunctionImpl<double,6> madness::real_funcimpl_6d |
typedef Function<double,1> madness::real_function_1d |
typedef Function<double,2> madness::real_function_2d |
typedef Function<double,3> madness::real_function_3d |
typedef Function<double,4> madness::real_function_4d |
typedef Function<double,5> madness::real_function_5d |
typedef Function<double,6> madness::real_function_6d |
typedef std::shared_ptr< FunctionFunctorInterface<double,1> > madness::real_functor_1d |
typedef std::shared_ptr< FunctionFunctorInterface<double,2> > madness::real_functor_2d |
typedef std::shared_ptr< FunctionFunctorInterface<double,3> > madness::real_functor_3d |
typedef std::shared_ptr< FunctionFunctorInterface<double,4> > madness::real_functor_4d |
typedef std::shared_ptr< FunctionFunctorInterface<double,5> > madness::real_functor_5d |
typedef std::shared_ptr< FunctionFunctorInterface<double,6> > madness::real_functor_6d |
typedef Tensor<double> madness::real_tensor |
typedef std::ptrdiff_t madness::rel_fn_ptr_t |
using madness::remove_fcvr_t = typedef typename remove_fcvr<T>::type |
using madness::remove_future_t = typedef typename remove_future< T >::type |
C++11 version of REMFUTURE.
typedef std::vector< vector_real_function_3d > madness::response_matrix |
typedef void(* madness::rmi_handlerT) (void *buf, size_t nbyte) |
This is the generic low-level interface for a message handler.
typedef Mutex madness::SCALABLE_MUTEX_TYPE |
typedef Mutex madness::SPINLOCK_TYPE |
typedef std::vector<pairvecfuncT> madness::subspaceT |
typedef Tensor<double_complex> madness::tensor_complex |
typedef Tensor<double> madness::tensor_real |
typedef Tensor< double > madness::tensorT |
typedef int64_t madness::Translation |
typedef std::vector< real_function_3d > madness::vecfuncT |
typedef std::vector< std::complex<double> > madness::vector_complex |
typedef std::vector<complex_function_1d> madness::vector_complex_function_1d |
typedef std::vector<complex_function_2d> madness::vector_complex_function_2d |
typedef std::vector<complex_function_3d> madness::vector_complex_function_3d |
typedef std::vector<complex_function_4d> madness::vector_complex_function_4d |
typedef std::vector<complex_function_5d> madness::vector_complex_function_5d |
typedef std::vector<complex_function_6d> madness::vector_complex_function_6d |
typedef std::vector< Vector<double,1> > madness::vector_coord_1d |
typedef std::vector< Vector<double,2> > madness::vector_coord_2d |
typedef std::vector< Vector<double,3> > madness::vector_coord_3d |
typedef std::vector< Vector<double,4> > madness::vector_coord_4d |
typedef std::vector< Vector<double,5> > madness::vector_coord_5d |
typedef std::vector< Vector<double,6> > madness::vector_coord_6d |
typedef std::vector<double> madness::vector_real |
typedef std::vector<real_function_1d> madness::vector_real_function_1d |
typedef std::vector<real_function_2d> madness::vector_real_function_2d |
typedef std::vector<real_function_3d> madness::vector_real_function_3d |
typedef std::vector<real_function_4d> madness::vector_real_function_4d |
typedef std::vector<real_function_5d> madness::vector_real_function_5d |
typedef std::vector<real_function_6d> madness::vector_real_function_6d |
enum madness::BCType |
enum madness::CalcType |
Calculation Types used by CC2.
Enumerator | |
---|---|
CT_UNDEFINED | |
CT_MP2 | |
CT_MP3 | |
CT_CC2 | |
CT_LRCCS | |
CT_LRCC2 | |
CT_CISPD | |
CT_ADC2 | |
CT_TDHF | |
CT_TEST |
enum madness::CCState |
Type of Pairs used by CC_Pair2 class.
Enumerator | |
---|---|
CCSTATE_UNDEFINED | |
GROUND_STATE | |
EXCITED_STATE |
enum madness::EnergyType |
enum madness::FuncType |
enum madness::GuessType |
enum madness::OpType |
enum madness::PairType |
CC2 Singles Potentials.
Enumerator | |
---|---|
POT_UNDEFINED | |
POT_F3D_ | |
POT_s3a_ | |
POT_s3b_ | |
POT_s3c_ | |
POT_s5a_ | |
POT_s5b_ | |
POT_s5c_ | |
POT_s2b_ | |
POT_s2c_ | |
POT_s4a_ | |
POT_s4b_ | |
POT_s4c_ | |
POT_s6_ | |
POT_ccs_ | |
POT_cis_ | |
POT_singles_ |
enum madness::TensorType |
enum madness::ThreadTag |
enum madness::TreeState |
|
strong |
|
static |
Referenced by madness::FunctionCommonData< T, NDIM >::_init_twoscale(), madness::SCF::analyze_vectors(), madness::SeparatedConvolution< Q, NDIM >::apply2_lowdim(), madness::projector_irrep::apply_symmetry_operators(), madness::Znemo::canonicalize(), madness::MolecularOrbitals< T, NDIM >::compute_center(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::compute_offdiagonal_batch_in_symmetric_matrix(), madness::SVDTensor< T >::compute_svd(), madness::SVDTensor< T >::concatenate(), concatenate_columns(), concatenate_rows(), madness::TensorTrain< T >::decompose(), diag_and_transform(), DF::diagonalize(), madness::FunctionImpl< T, NDIM >::dirac_convolution_op(), madness::RandomizedMatrixDecomposition< T >::do_compute_range(), madness::FunctionImpl< T, NDIM >::do_inner_localX(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::MacroTaskPartitionerExchange::do_partitioning(), madness::Coulomb< T, NDIM >::MacroTaskCoulomb::MacroTaskPartitionerCoulomb::do_partitioning(), madness::FunctionImpl< T, NDIM >::do_project_out(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), MiniDFT::doit(), doit(), doplot(), doplotptk(), madness::SRConf< T >::emul(), madness::TensorTrain< T >::emul(), madness::GFit< T, NDIM >::f12_fit(), madness::GFit< T, NDIM >::f12sq_fit(), fixphases(), madness::TensorTrain< T >::gaxpy(), madness::SRConf< T >::get_configs(), madness::Znemo::hcore_guess(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), madness::TDHF::make_cis_matrix(), madness::TwoElectronInterface< T, NDIM >::make_coeff(), madness::FunctionDefaults< NDIM >::make_default_cell(), madness::FunctionDefaults< NDIM >::make_default_cell_width(), madness::Zcis::make_guess(), madness::TDHF::make_guess_from_initial_diagonalization(), madness::Nemo::make_incomplete_hessian_response_part(), madness::SRConf< T >::make_slices(), madness::RandomizedMatrixDecomposition< T >::make_SVD_decaying_matrix(), madness::SeparatedConvolution< Q, NDIM >::make_tt_representation(), madness::SRConf< T >::make_vector_with_weights(), madness::SRConf< T >::normalize(), madness::FunctionImpl< T, NDIM >::NS_fcube_for_mul(), madness::FunctionImpl< T, NDIM >::NScoeffs2values(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_mirror::operator()(), madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()(), BoysLocalization::operator()(), madness::GenTensor< T >::operator+(), madness::SliceLowRankTensor< T >::operator+=(), madness::GenTensor< T >::operator+=(), madness::SliceLowRankTensor< T >::operator-=(), madness::GenTensor< T >::operator-=(), orth(), ortho3(), ortho5(), orthonormalize_canonical(), madness::PNO::pno_compress(), madness::FunctionImpl< T, NDIM >::print_plane_local(), projector_external_dof(), madness::MolecularOptimizer::projector_external_dof(), rank_revealing_decompose(), madness::FunctionDefaults< NDIM >::recompute_cell_info(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::FunctionDefaults< NDIM >::set_cubic_cell(), solve(), madness::Nemo::solve_cphf(), madness::TensorTrain< T >::splitdim(), test_asymmetric(), test_sliced_addition(), test_sliced_assignment(), test_syev(), test_sygv(), madness::FunctionImpl< T, NDIM >::tnorm(), madness::TensorTrain< T >::truncate(), madness::Localizer::undo_reordering(), madness::Localizer::undo_rotation(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), madness::SCF::update_subspace(), Subspace::update_subspace(), and madness::FunctionImpl< T, NDIM >::vtransform().
|
static |
Entire tensor.
Function<double,NDIM> madness::abs | ( | const Function< double_complex, NDIM > & | z, |
bool | fence = true |
||
) |
Returns a new function that is the absolute value of the input.
References unary_op().
Function<typename TensorTypeData<Q>::scalar_type,NDIM> madness::abs | ( | const Function< Q, NDIM > & | func | ) |
References func(), and unary_op_coeffs().
Function<T,NDIM> madness::abs | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Create a new function that is the abs of f - global comm only if not reconstructed.
References madness::Function< T, NDIM >::abs(), copy(), f, and PROFILE_FUNC.
double madness::abs | ( | double | x | ) |
Referenced by madness::BandlimitedPropagator::BandlimitedPropagator(), SphericalHarmonics::SphericalHarmonics(), madness::Solver< T, NDIM >::apply_hf_exchange(), madness::OEP::compute_delta_rho(), madness::F12Potentials::compute_f12_correction(), madness::F12Potentials::compute_f12_pair_energies(), madness::F12Potentials::compute_f12_pair_energy(), QuasiNewton::hessian_update_bfgs(), QuasiNewton::hessian_update_sr1(), QuasiNewton::line_search(), main(), make_pw_matrix(), QuasiNewton::new_search_direction(), madness::detail::abssqop< NDIM >::operator()(), madness::detail::absop< NDIM >::operator()(), madness::abs_square_op< Q, NDIM >::operator()(), madness::abs_op< Q, NDIM >::operator()(), madness::detail::absinplace< T, NDIM >::operator()(), madness::detail::abssquareinplace< T, NDIM >::operator()(), madness::WorldAbsMaxOp< T >::operator()(), madness::WorldAbsMinOp< T >::operator()(), madness::Znemo::save_orbitals(), tensor_abs(), test_chin_chen(), OptimizationTargetInterface::test_gradient(), test_hermiticity(), test_kinetic(), test_partial_inner(), test_rnlp(), test_trotter(), testPeriodicCoulomb3d(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), and Subspace::update_subspace().
Function<typename TensorTypeData<Q>::scalar_type,NDIM> madness::abs_square | ( | const Function< Q, NDIM > & | func | ) |
References func(), and unary_op().
Referenced by abssq(), madness::Znemo::compute_current_density(), madness::Zcis::compute_potentials(), madness::Zcis::iterate(), test_coulomb(), and test_XCOperator().
std::enable_if<!TensorTypeData<T>::iscomplex, Function<T,NDIM> >::type madness::abs_square | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Create a new function that is the abs_square of f - global comm only if not reconstructed.
References madness::Function< T, NDIM >::abs_square(), copy(), f, and PROFILE_FUNC.
std::enable_if<TensorTypeData<T>::iscomplex, Function<typename Tensor<T>::scalar_type,NDIM> >::type madness::abs_square | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Create a new function that is the abs_square of f - global comm only if not reconstructed.
References f, and unary_op().
Function<double,NDIM> madness::abssq | ( | const Function< double_complex, NDIM > & | z, |
bool | fence = true |
||
) |
Returns a new function that is the square of the absolute value of the input.
References unary_op().
Referenced by madness::NemoBase::compute_density(), madness::Solver< T, NDIM >::compute_rho(), madness::Solver< T, NDIM >::compute_rho_slow(), madness::SCF::make_density(), make_density(), squaremod(), squaremod_large(), and squaremod_small().
std::vector< Function<typename Tensor<T>::scalar_type,NDIM> > madness::abssq | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Computes the square of a vector of functions — q[i] = abs(v[i])**2.
References abs_square(), madness::WorldGopInterface::fence(), madness::World::gop, reconstruct(), and v.
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::add | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right, | ||
bool | fence = true |
||
) |
Same as operator+
but with optional fence and no automatic compression.
References gaxpy_oop(), L, R, and TENSOR_RESULT_TYPE().
Referenced by add(), doit(), madness::TDHF::get_tda_potential(), operator+(), and TEST_CASE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::add | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Returns new vector of functions — q[i] = a + b[i].
References a, add(), b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, NDIM, PROFILE_BLOCK, R, T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::add | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true , |
||
unsigned int | blk = 1 |
||
) |
Returns new vector of functions — q[i] = a + b[i].
References a, add(), b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, NDIM, PROFILE_BLOCK, R, T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::add | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Returns new vector of functions — q[i] = a[i] + b[i].
References a, add(), b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::add | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true , |
||
unsigned int | blk = 1 |
||
) |
Returns new vector of functions — q[i] = a[i] + b[i].
References a, add(), b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, T(), and TENSOR_RESULT_TYPE().
funcT::returnT madness::adq | ( | double | lo, |
double | hi, | ||
const funcT & | func, | ||
double | thresh | ||
) |
References adq1(), func(), gauss_legendre(), lo, and thresh.
Referenced by madness::detail::adqtest::runtest().
funcT::returnT madness::adq1 | ( | double | lo, |
double | hi, | ||
const funcT & | func, | ||
double | thresh, | ||
int | n, | ||
const double * | x, | ||
const double * | w, | ||
int | level | ||
) |
References d(), do_adq(), e(), func(), lo, madness::detail::norm(), thresh, and w().
Referenced by adq(), and madness::GenericConvolution1D< Q, opT >::rnlp().
void madness::aligned_add | ( | long | n, |
double *MADNESS_RESTRICT | a, | ||
const double *MADNESS_RESTRICT | b | ||
) |
Referenced by main().
void madness::aligned_add | ( | long | n, |
double_complex *MADNESS_RESTRICT | a, | ||
const double_complex *MADNESS_RESTRICT | b | ||
) |
|
inline |
References a, madness::cblas::axpy(), and b.
|
inline |
References a, madness::cblas::axpy(), and b.
|
inline |
References a, madness::cblas::axpy(), and b.
|
inlinestatic |
void madness::aligned_sub | ( | long | n, |
double *MADNESS_RESTRICT | a, | ||
const double *MADNESS_RESTRICT | b | ||
) |
Referenced by main().
void madness::aligned_sub | ( | long | n, |
double_complex *MADNESS_RESTRICT | a, | ||
const double_complex *MADNESS_RESTRICT | b | ||
) |
|
inlinestatic |
Referenced by madness::Tensor< T >::allocate().
|
inline |
Allocates a new AmArg with nbytes of user data ... delete with free_am_arg.
Referenced by copy_am_arg(), and new_am_arg().
|
static |
References pow().
std::vector<Function<T,NDIM> > madness::append | ( | const std::vector< Function< T, NDIM > > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
combine two vectors
References v.
Referenced by madness::TDHF::apply_excitation_operators(), madness::CCPairFunction< T, NDIM >::collect_same_types(), madness::F12Potentials::compute_cispd_f12_energies(), madness::Zcis::compute_residuals(), madness::PNOPairs::extract(), flatten(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), madness::PNO::grow_rank(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_internal(), madness::BasisFunctions::guess_with_exop(), madness::PNO::initialize_pairs(), madness::Zcis::iterate(), madness::Zcis::make_guess(), madness::LRFunctorF12< T, NDIM, LDIM >::norm2(), madness::LowRankFunction< T, NDIM, LDIM >::operator+=(), madness::LowRankFunction< T, NDIM, LDIM >::operator-=(), madness::F12Potentials::read_cabs_from_file(), madness::PNO::transform_pairs(), madness::PNO::truncate_pairs(), and madness::PNO::update_pno().
complex_functionT madness::APPLY | ( | const complex_operatorT * | q1d, |
const complex_functionT & | psi | ||
) |
References apply_1d_realspace_push(), madness::Function< T, NDIM >::broaden(), lo, psi(), madness::Function< T, NDIM >::reconstruct(), and madness::Function< T, NDIM >::sum_down().
Referenced by applyexpLt(), chin_chen(), q_c(), sympgrad4(), sympgrad6(), and trotter().
Function<T,NDIM> madness::apply | ( | const Derivative< T, NDIM > & | D, |
const Function< T, NDIM > & | f, | ||
bool | fence = true |
||
) |
Applies derivative operator to function (for syntactic equivalence to integral operator apply)
References f.
Function<TENSOR_RESULT_TYPE(typename opT::opT,R), NDIM> madness::apply | ( | const opT & | op, |
const Function< R, NDIM > & | f, | ||
bool | fence = true |
||
) |
Apply operator in non-standard form.
Returns a new function with the same distribution
!!! For the moment does NOT respect fence option ... always fences if the operator acts on one particle only the result will be sorted as g.particle=1: g(f) = \int g(x,x') f(x',y) dx' = result(x,y) g.particle=2: g(f) = \int g(y,y') f(x,y') dy' = result(x,y) for the second case it will notably not be as it is implemented in the partial inner product! g.particle=2 g(f) = result(x,y) inner(g(y,y'),f(x,y'),1,1) = result(y,x) also note the confusion with the counting of the particles/integration variables
References apply_only(), madness::Function< T, NDIM >::change_tree_state(), madness::Function< T, NDIM >::clear(), f, madness::WorldGopInterface::fence(), madness::Function< T, NDIM >::get_impl(), madness::World::gop, MADNESS_ASSERT, madness::Function< T, NDIM >::make_nonstandard(), nonstandard_after_apply, op(), madness::Function< T, NDIM >::print_size(), print_timings, R, madness::Function< T, NDIM >::reconstruct(), redundant, madness::Function< T, NDIM >::standard(), TENSOR_RESULT_TYPE(), TT_2D, VERIFY_TREE, madness::Function< T, NDIM >::verify_tree(), and madness::Function< T, NDIM >::world().
Function<TENSOR_RESULT_TYPE(typename opT::opT,T), LDIM+LDIM> madness::apply | ( | const opT & | op, |
const std::vector< Function< T, LDIM >> & | f1, | ||
const std::vector< Function< T, LDIM >> & | f2, | ||
bool | fence = true |
||
) |
Apply operator on a hartree product of two low-dimensional functions.
Supposed to be something like result= G( f(1)*f(2)) the hartree product is never constructed explicitly, but its coeffs are constructed on the fly and processed immediately.
[in] | op | the operator |
[in] | f1 | function of particle 1 |
[in] | f2 | function of particle 2 |
[in] | fence | if we shall fence |
References madness::FunctionFactory< T, NDIM >::empty(), f, f1, f2, madness::WorldGopInterface::fence(), madness::FunctionFactory< T, NDIM >::fence(), madness::Function< T, NDIM >::get_impl(), get_impl(), madness::World::gop, madness::FunctionFactory< T, NDIM >::k(), op(), reconstruct(), standard(), T(), TENSOR_RESULT_TYPE(), and madness::FunctionFactory< T, NDIM >::thresh().
CCPairFunction<T,NDIM> madness::apply | ( | const ProjectorBase & | projector, |
const CCPairFunction< T, NDIM > & | argument | ||
) |
References apply(), and MADNESS_CHECK.
std::vector< CCPairFunction< T, NDIM > > madness::apply | ( | const ProjectorBase & | projector, |
const std::vector< CCPairFunction< T, NDIM >> & | argument | ||
) |
apply the projector on the argument function, potentially yielding a vector of CCPairfunctions as result
result can be Q12 f12 |ij> = (1 - O1) (1 - O2) f12 i(1) j(2) = f12 ij - \sum_k k(1) f_ik(2) j(2) - \sum_k k(2) f_ij(1)j(1) which is a pure function and a decomposed function
References madness::CCPairFunction< T, NDIM >::apply().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::apply | ( | const SeparatedConvolution< T, KDIM > & | op, |
const std::vector< Function< R, NDIM > > | f | ||
) |
CCPairFunction< T, NDIM > madness::apply | ( | const SeparatedConvolution< T, NDIM > & | G, |
const CCPairFunction< T, NDIM > & | argument | ||
) |
apply the operator on a CCPairfunction, both with the same dimension
note there is another function, where the operator works only on some dimensions of the CCPairFunction!
References madness::timer::end(), G, madness::CCPairFunction< T, NDIM >::get_a(), madness::CCPairFunction< T, NDIM >::get_b(), madness::CCPairFunction< T, NDIM >::get_function(), madness::CCPairFunction< T, NDIM >::is_decomposed_no_op(), madness::CCPairFunction< T, NDIM >::is_pure(), MADNESS_ASSERT, MADNESS_EXCEPTION, madness::CCPairFunction< T, NDIM >::name(), and madness::CCPairFunction< T, NDIM >::world().
CCPairFunction<T,NDIM> madness::apply | ( | const SeparatedConvolution< T, NDIM > & | G, |
const std::vector< CCPairFunction< T, NDIM >> & | argument | ||
) |
std::vector<CCPairFunction<T,NDIM> > madness::apply | ( | const SeparatedConvolution< T, NDIM > & | op, |
const std::vector< CCPairFunction< T, NDIM >> & | argument | ||
) |
CCPairFunction< T, NDIM > madness::apply | ( | const SeparatedConvolution< T, NDIM/2 > & | op, |
const CCPairFunction< T, NDIM > & | arg | ||
) |
apply the operator to the argument
the operator is applied to one particle only, the other one is left untouched note the ordering of the particles, cf the corresponding comment in mra.h op.particle==1 : op(f(x,y)) = op(x,x') f(x',y) = result(x,y); op.particle==2 : op(f(x,y)) = op(y,y') f(x,y') = result(y,x);
References apply(), arg(), MADNESS_CHECK, MADNESS_CHECK_THROW, op(), and madness::CCPairFunction< T, NDIM >::swap_particles().
std::vector< CCPairFunction< T, NDIM > > madness::apply | ( | const SeparatedConvolution< T, NDIM/2 > & | op, |
const std::vector< CCPairFunction< T, NDIM >> & | argument | ||
) |
apply the operator to the argument
the operator is applied to one particle only, the other one is left untouched note the ordering of the particles, cf the corresponding comment in mra.h op.particle==1 : op(f(x,y)) = op(x,x') f(x',y) = result(x,y); op.particle==2 : op(f(x,y)) = op(y,y') f(x,y') = result(y,x);
References apply(), arg(), op(), and madness::response_space::push_back().
TensorTrain<TENSOR_RESULT_TYPE(T,Q)> madness::apply | ( | const TensorTrain< T > & | op, |
const TensorTrain< Q > & | t, | ||
const double | thresh | ||
) |
apply an operator in TT format on a tensor in TT format
[in] | op | operator in TT format ..(r_1,k',k,r_2).. |
[in] | t | tensor in TT format ..(r_1,k',r_2).. the result tensor will be .. (r_1,k,r_2) = \sum_k' ..(r_1,k',k,r_2).. ..(r_1,k',r_2).. during the apply a rank reduction will be performed 2*ndim allocates are needed |
References B, copy(), madness::Tensor< T >::cycledim(), d(), madness::BaseTensor::dim(), madness::BaseTensor::dims(), madness::TensorTrain< T >::get_core(), inner_result(), k, k0, MADNESS_ASSERT, max, maxR, madness::BaseTensor::ndim(), op(), print(), Q(), R, R1, r2(), R2, rank_revealing_decompose(), madness::TensorTrain< T >::ranks(), madness::Tensor< T >::reshape(), T(), TENSOR_RESULT_TYPE(), and thresh.
std::vector< Function<T,NDIM> > madness::apply | ( | World & | world, |
const Derivative< T, NDIM > & | D, | ||
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Applies a derivative operator to a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, reconstruct(), and v.
std::vector< Function<T,NDIM> > madness::apply | ( | World & | world, |
const Derivative< T, NDIM > & | D, | ||
const std::vector< Function< T, NDIM > > & | v, | ||
const unsigned int | blk = 1 , |
||
const bool | fence = true |
||
) |
Applies a derivative operator to a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, reconstruct(), and v.
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::apply | ( | World & | world, |
const SeparatedConvolution< T, KDIM > & | op, | ||
const std::vector< Function< R, NDIM > > | f | ||
) |
Applies an operator to a vector of functions — q[i] = apply(op,f[i])
References apply_only(), f, madness::WorldGopInterface::fence(), get_impl(), madness::World::gop, make_nonstandard(), NDIM, op(), print_timings, PROFILE_BLOCK, R, madness::World::rank(), reconstruct(), T(), TENSOR_RESULT_TYPE(), TT_2D, and wall_time().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::apply | ( | World & | world, |
const SeparatedConvolution< T, NDIM > & | op, | ||
const std::vector< Function< R, NDIM > > | f, | ||
const unsigned int | blk = 1 |
||
) |
Applies an operator to a vector of functions — q[i] = apply(op,f[i])
References apply_only(), f, madness::WorldGopInterface::fence(), madness::World::gop, NDIM, nonstandard, op(), PROFILE_BLOCK, R, reconstruct(), standard(), T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(typename opT::opT,R), NDIM> > madness::apply | ( | World & | world, |
const std::vector< std::shared_ptr< opT > > & | op, | ||
const std::vector< Function< R, NDIM > > | f | ||
) |
Applies a vector of operators to a vector of functions — q[i] = apply(op[i],f[i])
References apply_only(), f, madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, make_nonstandard(), NDIM, nonstandard_after_apply, op(), PROFILE_BLOCK, R, reconstruct(), madness::BaseTensor::size(), standard(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(typename opT::opT,R), NDIM> > madness::apply | ( | World & | world, |
const std::vector< std::shared_ptr< opT > > & | op, | ||
const std::vector< Function< R, NDIM > > | f, | ||
const unsigned int | blk = 1 |
||
) |
Applies a vector of operators to a vector of functions — q[i] = apply(op[i],f[i])
References apply_only(), f, madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, NDIM, nonstandard, op(), PROFILE_BLOCK, R, reconstruct(), madness::BaseTensor::size(), standard(), and TENSOR_RESULT_TYPE().
response_space madness::apply | ( | World & | world, |
real_derivative_3d & | op, | ||
response_space & | f | ||
) |
References apply(), f, MADNESS_ASSERT, op(), and madness::response_space::push_back().
response_space madness::apply | ( | World & | world, |
std::vector< std::shared_ptr< real_convolution_3d >> & | op, | ||
response_space & | f | ||
) |
response_space madness::apply | ( | World & | world, |
std::vector< std::vector< std::shared_ptr< real_convolution_3d >>> & | op, | ||
response_space & | f | ||
) |
References f, MADNESS_ASSERT, op(), and madness::BaseTensor::size().
Referenced by madness::DFTNuclearChargeDensityOp< T, NDIM >::DFTNuclearChargeDensityOp(), NuclearChargeDensityOp< T, NDIM >::NuclearChargeDensityOp(), madness::Solver< T, NDIM >::Solver(), madness::CCPairFunction< T, NDIM >::apply(), KPeriodicBSHOperator::apply(), Fcwf::apply(), apply(), apply_bsh(), madness::TDHF::apply_G(), madness::Solver< T, NDIM >::apply_hf_exchange(), madness::Solver< T, NDIM >::apply_hf_exchange3(), madness::Solver< T, NDIM >::apply_hf_exchange4(), apply_periodic_bsh(), madness::Diamagnetic_potential_factor::apply_potential(), madness::Solver< T, NDIM >::apply_potential(), apply_potential(), madness::F12Potentials::apply_regularized_potential(), madness::HartreeFock< T, NDIM >::calculate_coulomb_energy(), madness::HartreeFock< T, NDIM >::calculate_exchange_energy(), madness::DFT< T, NDIM >::calculate_tot_coulomb_energy(), madness::DFT< T, NDIM >::calculate_tot_pe_sp(), chin_chen(), madness::Nemo::compute_all_cphf(), madness::PNO::compute_cispd_correction_es(), madness::PNO::compute_cispd_correction_gs(), madness::PNO::compute_cispd_f12_correction_es(), madness::PNO::compute_cispd_f12_correction_gs(), madness::F12Potentials::compute_cispd_f12_energies(), madness::Znemo::compute_energy(), compute_energy(), madness::Nemo::compute_energy_regularized(), compute_energy_simple(), madness::PNO::compute_fluctuation_matrix(), madness::F12Potentials::compute_fQc_integrals_ij(), madness::F12Potentials::compute_fQg_integral(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::NemoBase::compute_kinetic_energy(), madness::NemoBase::compute_kinetic_energy1a(), madness::NemoBase::compute_kinetic_energy2(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::compute_offdiagonal_batch_in_symmetric_matrix(), madness::PNO::compute_projected_mp2_energies(), madness::F12Potentials::compute_regularized_fluctuation_matrix(), madness::SCF::compute_residual(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), madness::OEP::compute_total_kinetic_density(), madness::PNO::compute_V_aj_i(), madness::PNO::compute_Vreg_aj_i_commutator_response(), madness::PNO::compute_Vreg_aj_i_fock_residue(), madness::F12Potentials::compute_xyab_integrals(), converge(), converge2s(), madness::F12Potentials::convolve_with_fg(), madness::F12Potentials::convolve_with_fU(), madness::F12Potentials::convolve_with_gradslater(), madness::F12Potentials::convolve_with_slater_potential(), div(), madness::SCF::do_plots(), doit(), madness::smooth< T, NDIM >::gaussian_smoothing(), grad(), grad_ble_one(), grad_ble_two(), grad_bpsline_two(), grad_bspline_one(), grad_bspline_three(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), madness::LRFunctorF12< T, NDIM, LDIM >::inner(), iterate(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_small_memory(), madness::SCF::kinetic_energy_matrix(), madness::Kinetic< T, NDIM >::kinetic_energy_matrix(), MiniDFT::kinetic_energy_matrix(), madness::Nemo::kinetic_energy_potential(), main(), madness::SCF::make_coulomb_potential(), DF::make_fermi_potential(), make_kinetic_matrix(), madness::Solver< T, NDIM >::make_kinetic_matrix(), madness::Solver< T, NDIM >::make_nuclear_charge_density_impl(), madness::TDHF::make_perturbed_fock_matrix(), Calculation::make_reference(), madness::EigSolver< T, NDIM >::multi_solve(), madness::HartreeFockExchangeOp< T, NDIM >::op_o(), madness::HartreeFockCoulombOp< T, NDIM >::op_r(), madness::Projector< T, NDIM >::operator()(), madness::QProjector< T, NDIM >::operator()(), madness::StrongOrthogonalityProjector< T, NDIM >::operator()(), madness::CCConvolutionOperator< T, NDIM >::operator()(), madness::SeparatedConvolution< Q, NDIM >::operator()(), MicroTask::operator()(), madness::Nuclear< T, NDIM >::operator()(), madness::Lz< T, NDIM >::operator()(), madness::BSHApply< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), MyDerivativeOperator< T, NDIM >::operator()(), madness::DerivativeOperator< T, NDIM >::operator()(), madness::TDHF::oscillator_strength_velocity(), madness::DFTCoulombOp< T, NDIM >::prepare_op(), madness::DFTCoulombPeriodicOp< T, NDIM >::prepare_op(), rot(), madness::Solver< T, NDIM >::solve(), madness::EigSolver< T, NDIM >::solve(), madness::SCF::solve(), madness::Nemo::solve_cphf(), test(), madness::smooth< T, NDIM >::test_1d(), test_he_potential(), test_hf_be(), test_hf_he(), test_inner(), test_nuclear_potential(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), test_op(), test_per(), test_periodic_bsh(), testbsh(), testNavierStokes(), testPeriodicCoulomb3d(), trotter(), madness::SCF::twoint(), MiniDFT::update(), and madness::PNO::update_pno().
Function<TENSOR_RESULT_TYPE(typename opT::opT,R), NDIM> madness::apply_1d_realspace_push | ( | const opT & | op, |
const Function< R, NDIM > & | f, | ||
int | axis, | ||
bool | fence = true |
||
) |
References axis, f, madness::Function< T, NDIM >::get_impl(), NDIM, op(), PROFILE_FUNC, R, madness::Function< T, NDIM >::reconstruct(), redundant_after_merge, TENSOR_RESULT_TYPE(), VERIFY_TREE, and madness::Function< T, NDIM >::verify_tree().
Referenced by APPLY(), APPLY(), madness::SCF::APPLY(), chin_chen(), test_apply_push_1d(), test_qm(), and trotter().
Function<TENSOR_RESULT_TYPE(typename opT::opT,R), NDIM> madness::apply_only | ( | const opT & | op, |
const Function< R, NDIM > & | f, | ||
bool | fence = true |
||
) |
Apply operator ONLY in non-standard form - required other steps missing !!
References f, NDIM, op(), R, and TENSOR_RESULT_TYPE().
Referenced by apply(), and test_coulomb().
CalcType madness::assign_calctype | ( | const std::string | name | ) |
std::string madness::assign_name | ( | const CalcType & | inp | ) |
std::string madness::assign_name | ( | const CCState & | input | ) |
Assigns strings to enums for formated output.
References EXCITED_STATE, GROUND_STATE, and MADNESS_EXCEPTION.
Referenced by madness::CCConvolutionOperator< T, NDIM >::clear_intermediates(), madness::CC2::initialize_pairs(), madness::CCIntermediatePotentials::insert(), madness::CC2::iterate_pair(), madness::CC2::iterate_singles(), madness::CCPair::name(), madness::CCIntermediatePotentials::operator()(), madness::CC2::solve(), madness::CC2::update_constant_part_adc2(), and madness::CCConvolutionOperator< T, NDIM >::update_elements().
std::string madness::assign_name | ( | const FuncType & | inp | ) |
std::string madness::assign_name | ( | const PotentialType & | inp | ) |
std::string madness::atomic_number_to_symbol | ( | const unsigned int | atomic_number | ) |
return the lower-case element symbol corresponding to the atomic number
References atomic_data, and madness::AtomicData::symbol_lowercase.
Referenced by do_vtk_plots(), madness::Nemo::gradient(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_internal(), madness::SCF::initial_guess(), madness::BasisFunctions::predefined_guess(), DF::print_molecule(), madness::BasisFunctions::read_basis_from_file(), madness::F12Potentials::read_cabs_from_file(), madness::BasisFunctions::read_contracted_basis_from_file(), and write_molecules_to_file().
bool madness::autoc | ( | int | k, |
Tensor< double > * | c | ||
) |
Return the autocorrelation coefficients for scaling functions of given order.
Returned is a view of the cached data ... do not modify.
The autocorrelation functions are defined as
and are expanded in the double order Legendre scaling functions on either side of the origin
The expansion coefficients cminus
and cplus
have been precomputed with Maple to a precision of about 1e-30. Only cplus
is stored and we use
The returned tensor concatenates cminus and cplus.
Return true on success, false on failure (which also prints error message to stdout).
References _c, _cread, c, k, kcur, and kread.
Referenced by madness::Convolution1D< Q >::Convolution1D().
void madness::bandlimited_propagator_plot | ( | ) |
References madness::BandlimitedPropagator::plot().
Referenced by main().
|
inline |
Referenced by madness::ThreadBase::main().
void madness::bgq_mtxmq_padded | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
long | extb, | ||
__complex__ double * | c_x, | ||
const __complex__ double * | a_x, | ||
const __complex__ double * | b_x | ||
) |
References a, b, c, k, and posix_memalign().
void madness::bgq_mtxmq_padded | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
long | extb, | ||
__complex__ double * | c_x, | ||
const __complex__ double * | a_x, | ||
const double * | b_x | ||
) |
void madness::bgq_mtxmq_padded | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
long | extb, | ||
__complex__ double * | c_x, | ||
const double * | a_x, | ||
const __complex__ double * | b_x | ||
) |
References a, b, c, k, and posix_memalign().
void madness::bgq_mtxmq_padded | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
long | extb, | ||
double * | c_x, | ||
const double * | a_x, | ||
const double * | b_x | ||
) |
References a, b, c, k, and posix_memalign().
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::binary_op | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right, | ||
const opT & | op, | ||
bool | fence = true |
||
) |
Generate new function = op(left,right) where op acts on the function values.
References madness::Function< T, NDIM >::get_impl(), madness::Function< T, NDIM >::is_reconstructed(), L, NDIM, op(), PROFILE_FUNC, R, madness::Function< T, NDIM >::reconstruct(), and TENSOR_RESULT_TYPE().
Referenced by madness::Nemo::kinetic_energy_potential(), main(), SurfaceMoleculeInteraction::make_surfcharge(), and test_xc2().
|
inlinestatic |
Factory function generating separated kernel for convolution with BSH kernel in general NDIM.
References k, lo, MADNESS_EXCEPTION, mu, OT_BSH, print(), and madness::World::rank().
|
inlinestatic |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D.
References k, lo, mu, and OT_BSH.
Referenced by apply_BSH_new(), converge(), converge2s(), doit(), iterate(), iterate_excite(), iterate_ground(), iterate_xy(), main(), make_bsh_operator(), test_modified(), and test_periodic_bsh().
|
inlinestatic |
Factory function generating separated kernel for convolution with BSH kernel in general NDIM.
References k, lo, MADNESS_EXCEPTION, mu, OT_BSH, print(), and madness::World::rank().
|
inlinestatic |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D.
References BC_PERIODIC, madness::GFit< T, NDIM >::BSHFit(), fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, and madness::Tensor< T >::normf().
Referenced by madness::F12Potentials::F12Potentials(), apply_BSH(), madness::TDHF::apply_G(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), madness::CC2::iterate_singles(), madness::Solver< T, NDIM >::make_bsh_operators(), MiniDFT::make_bsh_operators(), make_bsh_operators(), madness::PNO::make_bsh_operators(), and madness::SCF::make_bsh_operators().
int madness::c_rks_vwn5__ | ( | const double * | r__, |
double * | f, | ||
double * | dfdra | ||
) |
References a2, c_b7, f, and pow().
Referenced by da_ldaop(), madness::XCfunctional::exc(), madness::xc_lda_potential::operator()(), test_xc1(), and madness::XCfunctional::vxc().
int madness::c_uks_vwn5__ | ( | double * | ra, |
double * | rb, | ||
double * | f, | ||
double * | dfdra, | ||
double * | dfdrb | ||
) |
std::shared_ptr<CCConvolutionOperator<T,NDIM> > madness::CCConvolutionOperatorPtr | ( | World & | world, |
const OpType | type, | ||
typename CCConvolutionOperator< T, NDIM >::Parameters | param | ||
) |
void madness::change_tensor_type | ( | GenTensor< T > & | t, |
const TensorArgs & | targs | ||
) |
change representation to targ.tt
References MADNESS_ASSERT, madness::TensorArgs::tt, and TT_FULL.
Referenced by madness::FunctionImpl< T, NDIM >::add_scalar_inplace(), madness::FunctionImpl< T, NDIM >::do_change_tensor_type::operator()(), madness::FunctionImpl< T, NDIM >::do_unary_op_value_inplace< opT >::operator()(), and madness::FunctionImpl< T, NDIM >::unary_op_coeff_inplace().
const std::vector<Function<T,NDIM> >& madness::change_tree_state | ( | const std::vector< Function< T, NDIM >> & | v, |
const TreeState | finalstate, | ||
const bool | fence = true |
||
) |
change tree state of the functions
will respect fence
References compressed, f, madness::WorldGopInterface::fence(), madness::World::gop, madness::Function< T, NDIM >::is_initialized(), nonstandard, nonstandard_with_leaves, reconstructed, redundant, v, and madness::Function< T, NDIM >::world().
Referenced by madness::projector_irrep::apply_symmetry_operators(), compress(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), hartree_product(), inner(), innerXX(), make_nonstandard(), madness::CompositeFunctorInterface< T, NDIM, MDIM >::make_redundant(), make_redundant(), reconstruct(), standard(), test_conversion(), test_transform(), and transform_reconstructed().
|
static |
References arg().
Referenced by operator>>().
|
static |
bool madness::check_if_pseudo_atom | ( | const std::string & | symbol | ) |
Referenced by madness::Molecule::read(), and madness::Molecule::read_xyz().
void madness::check_linear_dependence | ( | const Tensor< C > & | Q, |
Tensor< C > & | c, | ||
const double | rcondtol, | ||
const double | cabsmax, | ||
bool | do_print = true |
||
) |
check for subspace linear dependency
[in] | Q | the input matrix for KAIN |
[in,out] | c | the coefficients for constructing the new solution |
[in] | rcondtol | rcond less than this will cause the subspace to be shrunk due to linear dependence |
[in] | cabsmax | maximum element of c greater than this will cause the subspace to be shrunk due to linear dependence |
References c, e(), KAIN(), m, print(), and Q().
Referenced by madness::NonlinearSolverND< NDIM >::update(), and madness::XNonlinearSolver< T, C, Alloc >::update().
unsigned long madness::checksum_file | ( | const char * | filename | ) |
Simple checksum for ASCII characters in file.
References c, filename, and sum().
Referenced by read_twoscale(), and test_autoc().
void madness::cholesky | ( | char | uplo, |
integer | n, | ||
complex_real4 * | A, | ||
integer | lda | ||
) |
References cpotrf_(), LINALG_ASSERT, and madness::cblas::to_cptr().
void madness::cholesky | ( | char | uplo, |
integer | n, | ||
complex_real8 * | A, | ||
integer | lda | ||
) |
References LINALG_ASSERT, madness::cblas::to_zptr(), and zpotrf_().
References LINALG_ASSERT, and spotrf_().
References dpotrf_(), and LINALG_ASSERT.
Compute the Cholesky Factorization via LAPACK.
template void madness::cholesky | ( | Tensor< double > & | A | ) |
template void madness::cholesky | ( | Tensor< double_complex > & | A | ) |
Compute the Cholesky factorization.
Solves symmetric or Hermitian generalized eigenvalue problem.
Compute the Cholesky factorization of the symmetric positive definite matrix A
For memory efficiency A is modified inplace. Its upper triangle will hold the result and the lower trianlge will be zeroed such that input = inner(transpose(output),output).
Cholesky factorization
References A(), mask_info(), potrf_(), and TENSOR_ASSERT.
Referenced by orthonormalize_cd(), and test_cholesky().
DistributedMatrix<T> madness::column_distributed_matrix | ( | World & | world, |
int64_t | n, | ||
int64_t | m, | ||
int64_t | coltile = 0 |
||
) |
Generates an (n,m) matrix distributed by columns (row dimension is not distributed)
Quietly forces an even column tile size for ease of use in the systolic matrix algorithms
[in] | world | The world |
[in] | n | The column (first) dimension |
[in] | m | The row (second) dimension |
[in] | coltile | Tile size for columns forced to be even (default is to use all processes) |
References column_distributed_matrix_distribution(), and m.
|
inlinestatic |
Generates distribution for an (n,m) matrix distributed by columns (row dimension is not distributed)
Quietly forces an even column tile size for ease of use in the systolic matrix algorithms
[in] | world | The world |
[in] | n | The column (first) dimension |
[in] | m | The row (second) dimension |
[in] | coltile | Tile size for columns forced to be even (default is to use all processes) |
Referenced by column_distributed_matrix().
const std::vector< Function<T,NDIM> >& madness::compress | ( | const std::vector< Function< T, NDIM > > & | v | ) |
compress a vector of functions
implies fence return v for chaining
References change_tree_state(), compressed, and v.
void madness::compress | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Compress a vector of functions.
References change_tree_state(), compressed, PROFILE_BLOCK, and v.
Referenced by add(), madness::GTHPseudopotential< Q >::apply_potential(), madness::FunctionImpl< T, NDIM >::change_tree_state(), madness::NemoBase::compute_gradient(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::Solver< T, NDIM >::compute_rho(), cross(), madness::FunctionImpl< R, NDIM >::do_print_grid(), DF::exchange(), gaxpy(), gaxpy_oop(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), inner(), kinetic_energy_matrix(), madness::SCF::kinetic_energy_matrix(), madness::Kinetic< T, NDIM >::kinetic_energy_matrix(), madness::Nemo::make_density(), madness::SCF::make_density(), MiniDFT::make_density(), madness::FunctionImpl< T, NDIM >::make_redundant(), Calculation::make_reference(), matrix_inner(), matrix_inner_old(), molresponseExchange(), MiniDFT::orthogonalize(), orthogonalize(), madness::projector_irrep::project_on_irreps(), q_c(), madness::MacroTask< taskT >::MacroTaskInternal::run(), sub(), sum(), test2(), test_cross(), test_inner(), test_math(), test_rot(), madness::TDHF::transform(), transform(), madness::Zcis::transform(), madness::PNO::transform_pairs(), truncate(), madness::PNO::truncate_pairs(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), madness::SCF::update_subspace(), and Subspace::update_subspace().
void madness::compress | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Compress a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
DistributedMatrix<T> madness::concatenate_columns | ( | const DistributedMatrix< T > & | a, |
const DistributedMatrix< T > & | b | ||
) |
Generates a row-distributed matrix with rows of a
and b
contatenated.
I.e., c[i,j] = a[i,j] if i<ma or b[i-ma,j] if i>=ma
The matrices a and b must have the same row size (i.e., the same number of columns) and be row distributed with the same row tilesze. The result is also row distributed with the same row tilesize as the input matrices.
[in] | a | The first matrix |
[in] | b | The second matrix |
DistributedMatrix<T> madness::concatenate_rows | ( | const DistributedMatrix< T > & | a, |
const DistributedMatrix< T > & | b | ||
) |
Generates a column-distributed matrix with rows of a
and b
contatenated.
I.e., c[i,j] = a[i,j] if j<na or b[i,j-na] if j>=na
The matrices a and b must have the same column size (i.e., the same number of rows) and be column distributed with the same column tilesze. The result is also column distributed with the same column tilesize as the input matrices.
[in] | a | The first matrix |
[in] | b | The second matrix |
Referenced by distributed_localize_PM().
DistributedMatrix<T> madness::concatenate_rows | ( | const DistributedMatrix< T > & | a, |
const DistributedMatrix< T > & | b, | ||
const DistributedMatrix< T > & | c, | ||
const DistributedMatrix< T > & | d | ||
) |
Generates a column-distributed matrix with rows of a
, b
, c
, and d
contatenated in order.
I.e., c[i,j] = a[i,j] if j in [0,na), b[i,j-na] if j in [na,na+nb), c[i,j-na-nb] if j in [na+nb,na+nb+nc), etc. The matrices must have the same column size (i.e., the same number of rows) and be column distributed with the same column tilesze. The result is also column distributed with the same column tilesize as the input matrices.
[in] | a | The first matrix |
[in] | b | The second matrix |
[in] | c | The third matrix |
[in] | d | The fourth matrix |
References _(), ___, a, b, c, d(), madness::DistributedMatrix< T >::data(), and MADNESS_CHECK.
For real types return value, for complex return conjugate.
References op().
Referenced by madness::Tensor< T >::conj(), conj(), madness::Tensor< T >::TENSOR_RESULT_TYPE(), and madness::Localizer::undo_reordering().
Function<T,NDIM> madness::conj | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Return the complex conjugate of the input function with the same distribution and optional fence.
!!! The fence is actually not optional in the current implementation !!!
References madness::Function< T, NDIM >::conj(), copy(), f, and PROFILE_FUNC.
Referenced by madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl(), madness::Solver< T, NDIM >::apply_hf_exchange(), madness::Solver< T, NDIM >::apply_hf_exchange4(), madness::RandomizedMatrixDecomposition< T >::check_range(), madness::Znemo::compute_current_density(), madness::Znemo::compute_potentials(), madness::Zcis::compute_potentials(), madness::SVDTensor< T >::compute_svd_from_range(), madness::FunctionImpl< T, NDIM >::conj(), conj_transpose(), DF::diagonalize(), madness::RandomizedMatrixDecomposition< T >::do_compute_range(), DF::exchange(), madness::Znemo::hcore_guess(), inner(), madness::VectorSpace< T, NDIM >::inner(), inner_func(), madness::Zcis::iterate(), kinetic_energy_matrix_slow(), Fcwf::KramersPair(), madness::Zcis::make_guess(), matrix_inner_old(), moments(), madness::conditional_conj_struct< Q, true >::op(), madness::conj_op< Q, NDIM >::operator()(), orthonormalize_fock(), madness::SVDTensor< T >::recompute_from_range(), madness::SRConf< T >::reconstruct(), su_complex(), test_exchange(), test_exchange(), and madness::Localizer::undo_reordering().
|
inline |
|
inline |
std::vector< Function<T,NDIM> > madness::conj | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Returns the complex conjugate of the vector of functions.
References copy(), madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
Function<Q,NDIM> madness::convert | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Type conversion implies a deep copy. No communication except for optional fence.
Works in either basis but any loss of precision may result in different errors in applied in a different basis.
The new function is formed with the options from the default constructor.
There is no automatic type conversion since this is generally a rather dangerous thing and because there would be no way to make the fence optional.
References f, madness::Function< T, NDIM >::get_impl(), PROFILE_FUNC, and madness::Function< T, NDIM >::set_impl().
type conversion implies a deep copy
References copy(), madness::GenTensor< T >::get_tensor(), madness::GenTensor< T >::is_full_tensor(), madness::GenTensor< T >::is_svd_tensor(), madness::GenTensor< T >::is_tensortrain(), and MADNESS_EXCEPTION.
std::vector< Function<R,NDIM> > madness::convert | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Returns a deep copy of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
DistributedMatrix<T> madness::copy | ( | const DistributedMatrix< T > & | A | ) |
Function<T,NDIM> madness::copy | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Create a new copy of the function with the same distribution and optional fence.
References copy(), f, and PROFILE_FUNC.
Function<T,NDIM> madness::copy | ( | const Function< T, NDIM > & | f, |
const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > & | pmap, | ||
bool | fence = true |
||
) |
Create a new copy of the function with different distribution and optional fence.
Works in either basis. Different distributions imply asynchronous communication and the optional fence is collective.
References f, madness::Function< T, NDIM >::get_impl(), PROFILE_FUNC, madness::Function< T, NDIM >::set_impl(), VERIFY_TREE, and madness::Function< T, NDIM >::verify_tree().
Referenced by madness::ConvolutionData1D< Q >::ConvolutionData1D(), madness::DFTNuclearPotentialOp< T, NDIM >::DFTNuclearPotentialOp(), Fcwf::Fcwf(), madness::Solver< T, NDIM >::Solver(), madness::FunctionCommonData< T, NDIM >::_init_twoscale(), abs(), abs_square(), madness::FunctionNode< T, NDIM >::accumulate(), RealFuncIdentOp::action(), ComplexFuncIdentOp::action(), madness::BSHApply< T, NDIM >::add_coupling_and_levelshift(), madness::SeparatedConvolution< Q, NDIM >::apply(), apply(), apply(), madness::SeparatedConvolution< Q, NDIM >::apply2(), madness::SeparatedConvolution< Q, NDIM >::apply2_lowdim(), madness::TDHF::apply_excitation_operators(), madness::Solver< T, NDIM >::apply_potential(), madness::SCF::apply_potential(), madness::projector_irrep::apply_symmetry_operators(), apply_U_mix(), apply_U_ncf(), apply_V(), applyexpLt(), madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::DFT< T, NDIM >::calculate_tot_pe_sp(), madness::DFT< T, NDIM >::calculate_tot_xc_energy(), madness::Localizer::check_core_valence_separation(), madness::TwoBodyFunctionPureComponent< T, NDIM >::clone(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::clone(), madness::CCPairFunction< T, NDIM >::collect_same_types(), madness::Localizer::compute_core_valence_separation_transformation_matrix(), compute_energy(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::compute_error_from_inaccurate_refinement(), madness::MP2::compute_gQf_cc2interface(), madness::CC2::compute_local_coupling(), madness::OEP::compute_ocep_correction(), madness::OEP::compute_Pauli_kinetic_density(), madness::Zcis::compute_potentials(), compute_R2f2_psi(), madness::MolecularOptimizer::compute_reduced_mass(), compute_reduced_mass(), madness::Zcis::compute_residuals(), madness::SVDTensor< T >::compute_svd(), madness::SVDTensor< T >::compute_svd_from_range(), madness::OEP::compute_total_kinetic_density(), conj(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::continue_recursion(), convert(), madness::X_space::copy(), copy(), copy(), madness::SCF::copy_data(), cplxfunc0(), cplxfunc2(), madness::CCPairFunction< T, NDIM >::dec_to_pure(), madness::TensorTrain< T >::decompose(), diag_and_transform(), madness::FunctionImpl< T, NDIM >::dirac_convolution_op(), distributed_localize_PM(), dnuclear_anchor_test(), madness::Derivative< T, NDIM >::do_diff2b(), madness::SCF::do_plots(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), MiniDFT::doit(), doit(), eigenvector_test(), madness::CC2::enforce_core_valence_separation(), fixphases(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_node(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), geev(), gelss(), general_transform(), gesv(), data< T, NDIM >::get_ccpairfunctions(), madness::HartreeFock< T, NDIM >::get_coulomb_potential(), madness::MP2::get_fock_matrix(), madness::Convolution1D< Q >::get_rnlp(), madness::MolecularOrbitals< T, NDIM >::get_subset(), ggev(), GMRES(), ground_exchange(), madness::BasisFunctions::guess_with_exop(), madness::SCF::initial_guess(), inner(), madness::LRFunctorF12< T, NDIM, LDIM >::inner(), madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), inner_func(), madness::CCPairFunction< T, NDIM >::inner_internal(), inverse(), madness::MP2::iterate(), madness::OEP::iterate(), iterate(), madness::CC2::iterate_pair(), madness::CC2::iterate_singles(), madness::MolecularOrbitals< T, NDIM >::load_mos(), madness::SCF::load_mos(), loadbal(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), Ansatz0::make_bra(), madness::Nemo::make_ddensity(), madness::smooth< T, NDIM >::make_explog(), madness::SCF::make_fock_matrix(), madness::Zcis::make_guess(), madness::Nemo::make_laplacian_density(), madness::SCF::make_lda_potential(), MiniDFT::make_lda_potential(), make_lda_potential(), madness::Solver< T, NDIM >::make_lda_potential(), madness::TDHF::make_mo_ket(), madness::Solver< T, NDIM >::make_nuclear_potential_impl(), make_potential(), madness::FunctionImpl< T, NDIM >::make_redundant_op(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::make_sum_coeffs(), SurfaceMoleculeInteraction::make_surfcharge(), madness::MP2::make_Uphi0(), madness::CCPairFunction< T, NDIM >::make_xy_u(), madness::TwoElectronInterface< T, NDIM >::map_coeff(), map_tensor(), madness::Convolution1D< Q >::mod_nonstandard(), madness::FunctionImpl< T, NDIM >::mul(), madness::FunctionImpl< T, NDIM >::multiply(), multiply_by_V(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::smooth< T, NDIM >::munge_density(), madness::Znemo::normalize(), nuclear_anchor_test(), madness::CCPairFunction< T, NDIM >::op_dec_to_pure(), madness::XCFunctionalLDA< T, NDIM >::op_r(), madness::CCConvolutionOperator< T, NDIM >::operator()(), madness::StrongOrthogonalityProjector< T, NDIM >::operator()(), madness::pg_operator::operator()(), madness::divide_add_interpolate::operator()(), madness::XCOperator< T, NDIM >::logme::operator()(), madness::XCOperator< T, NDIM >::expme::operator()(), madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), test_multiop< T, NDIM >::operator()(), myunaryop_square< T, NDIM >::operator()(), madness::BinaryOpStructure< NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::pointwise_multiplier< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::add_op::operator()(), Metric::operator()(), madness::BSHApply< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_truncate_NS_leafs::operator()(), madness::FunctionImpl< T, NDIM >::do_keep_sum_coeffs::operator()(), madness::FunctionImpl< T, NDIM >::do_check_symmetry_local::operator()(), madness::FunctionImpl< T, NDIM >::do_mapdim::operator()(), madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()(), BoysLocalization::operator()(), operator*(), operator*(), madness::DistributedMatrix< T >::operator+(), Fcwf::operator+(), Spinor::operator+(), Fcwf::operator+=(), Fcwf::operator-(), Spinor::operator-(), operator-(), Fcwf::operator-=(), F::operator=(), madness::FunctionNode< T, NDIM >::operator=(), orth(), ortho5(), madness::Znemo::orthonormalize(), orthonormalize(), outer(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), plot_cubefile(), print_tree_jsonfile(), madness::projector_irrep::project_on_irreps(), madness::FunctionImpl< T, NDIM >::project_refine_op(), propagate(), madness::Nemo::purify_hessian(), rank_revealing_decompose(), Plotter::read(), madness::InitParameters::read(), real(), realfunc0(), realfunc2(), madness::FunctionDefaults< NDIM >::recompute_cell_info(), madness::SVDTensor< T >::recompute_from_range(), madness::FunctionNode< T, NDIM >::recompute_snorm_and_dnorm(), madness::FunctionImpl< T, NDIM >::reconstruct_op(), reconstruct_psi(), madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map(), reduce(), madness::FunctionImpl< T, NDIM >::refine_op(), madness::FunctionImpl< T, NDIM >::refine_to_common_level(), residual(), madness::OEP::selftest(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_bra_and_ket(), madness::FunctionDefaults< NDIM >::set_cell(), madness::AtomicBasis::set_guess_info(), madness::MolecularOptimizer::set_hessian(), madness::QuasiNewton::set_hessian(), madness::Localizer::set_metric(), madness::LocalPotentialOperator< T, NDIM >::set_potential(), madness::apply_kernel_helper::slater_apply(), madness::smooth< T, NDIM >::smooth_density(), madness::CC2::solve(), madness::Nemo::solve(), madness::OEP::solve(), solve(), madness::Nemo::solve_cphf(), madness::CC2::solve_lrcc2(), madness::CC2::solve_mp2_coupled(), madness::Zcis::split(), square(), madness::archive::ArchiveStoreImpl< Archive, GenTensor< T > >::store(), madness::archive::ArchiveStoreImpl< Archive, Tensor< T > >::store(), madness::FunctionImpl< T, NDIM >::sum_down_spawn(), svd(), test2(), Test5(), Test7(), test_adaptive_tree(), test_add(), test_addition(), test_asymmetric(), test_bsh(), test_chin_chen(), test_cholesky(), test_compress(), test_constructor(), test_conversion(), test_convolution(), test_coulomb(), test_hermiticity(), test_Kcommutator(), test_multiply(), test_partial_inner_3d(), test_projector(), test_qr(), test_recursive_application(), test_rr_cholesky(), test_scalar_multiplication(), test_slater_exchange(), test_sliced_addition(), test_swap_particles(), test_tight_diffuse(), test_transformations(), test_trotter(), test_truncation(), test_U_el(), test_unaryop(), test_vector_composite(), test_xc2(), madness::FunctionImpl< T, NDIM >::tnorm(), to_response_vector(), transform(), transform_dir(), transpose(), trotter(), madness::TensorTrain< T >::truncate(), two_scale_coefficients(), madness::Localizer::undo_reordering(), madness::Localizer::undo_rotation(), madness::NonlinearSolverND< NDIM >::update(), madness::XNonlinearSolver< T, C, Alloc >::update(), madness::MolecularOrbitals< T, NDIM >::update_mos_and_eps(), CoreFittingTarget::value(), madness::FunctionImpl< T, NDIM >::vtransform(), and madness::MolecularOrbitals< T, NDIM >::write_to().
std::vector< Function<T,NDIM> > madness::copy | ( | const std::vector< Function< T, NDIM > > & | v, |
bool | fence = true |
||
) |
Returns a deep copy of a vector of functions.
References copy(), PROFILE_BLOCK, and v.
std::vector< Function<T,NDIM> > madness::copy | ( | World & | world, |
const Function< T, NDIM > & | v, | ||
const unsigned int | n, | ||
bool | fence = true |
||
) |
Returns a vector of n
deep copies of a function.
Returns a vector of deep copies of of a function.
References copy(), madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
std::vector< Function<T,NDIM> > madness::copy | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Returns a deep copy of a vector of functions.
References copy(), madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
std::vector<Function<T, NDIM> > madness::copy | ( | World & | world, |
const std::vector< Function< T, NDIM >> & | v, | ||
const std::shared_ptr< WorldDCPmapInterface< Key< NDIM >>> & | pmap, | ||
bool | fence = true |
||
) |
Returns a deep copy of a vector of functions.
Create a new copy of the function with different distribution and optional fence Works in either basis. Different distributions imply asynchronous communication and the optional fence is collective.
References copy(), madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
|
static |
References m.
Referenced by madness::Convolution1D< Q >::nonstandard().
References alloc_am_arg(), and arg().
Referenced by madness::WorldGopInterface::bcast_task(), and madness::WorldGopInterface::group_bcast_task().
|
inlinestatic |
Factory function generating separated kernel for convolution with 1/r in 3D.
Referenced by madness::MP2::compute_gQf(), GygiPot::ESP(), GygiPot::GuessPotential(), iterate(), iterate_excite(), iterate_xy(), main(), MiniDFT::make_coulomb_potential(), make_coulomb_potential(), MicroTask::operator()(), SurfaceMoleculeInteraction::perturbed_molecular_pot(), DF::solve_occupied(), test(), test_coulomb(), test_exchange(), test_Kcommutator(), test_nuclear_potential(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), test_periodic2(), and testNavierStokes().
|
inlinestatic |
Factory function generating separated kernel for convolution with 1/r in 3D.
Referenced by madness::F12Potentials::F12Potentials(), madness::MP2::MP2(), madness::PNO::PNO(), madness::Solver< T, NDIM >::Solver(), madness::Znemo::Znemo(), madness::Solver< T, NDIM >::initial_guess(), main(), madness::Solver< T, NDIM >::make_nuclear_potential(), madness::Znemo::recompute_factors_and_potentials(), madness::Coulomb< T, NDIM >::reset_poisson_operator_ptr(), set_poisson(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::set_poisson(), madness::Nemo::set_protocol(), Calculation::set_protocol(), and madness::SCF::set_protocol().
double madness::cpu_frequency | ( | ) |
Estimate the processor frequency, in Hz.
First call may take about 0.1s to execute. Subsequent calls return the value, cached from the first call, so it does not respond to changing processor frequency.
If cycle_count()
returns wall_time()
in nanoseconds, this will return 1GHz.
If not available returns 0.
References cycle_count(), and wall_time().
Referenced by cpu_time(), main(), and startup().
|
inline |
Do nothing and especially do not touch memory.
Referenced by madness::MutexReaderWriter::convert_read_lock_to_write_lock(), madness::Barrier::enter(), madness::MutexFair::lock(), madness::MutexReaderWriter::lock(), myusleep(), madness::MutexReaderWriter::read_lock(), madness::MutexWaiter::wait(), madness::ConditionVariable::wait(), and madness::MutexReaderWriter::write_lock().
|
inlinestatic |
Returns the cpu time in seconds relative to an arbitrary origin.
As accurate and lightweight as we can get it, but may not be any better than the clock system call.
References cpu_frequency(), and cycle_count().
Referenced by madness::test_output::test_output(), madness::Znemo::timer::timer(), madness::WorldProfileObj::~WorldProfileObj(), madness::SeparatedConvolution< Q, NDIM >::apply(), madness::SeparatedConvolution< Q, NDIM >::apply2(), madness::SeparatedConvolution< Q, NDIM >::apply2_lowdim(), madness::ThreadPool::await(), madness::test_output::checkpoint(), madness::WorldProfile::clear(), madness::FunctionImpl< T, NDIM >::compress_op(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::compute_offdiagonal_batch_in_symmetric_matrix(), madness::FunctionImpl< T, NDIM >::do_apply_kernel3(), madness::test_output::end(), madness::Znemo::timer::end(), molresponse::end_timer(), DF::end_timer(), END_TIMER(), madness::Solver< T, NDIM >::END_TIMER(), madness::MP2::END_TIMER(), DF::get_times(), madness::timer::interrupt(), main(), myusleep(), madness::BSHApply< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_change_tensor_type::operator()(), madness::WorldProfile::print(), print_stats(), madness::timer::resume(), madness::MacroTask< taskT >::MacroTaskInternal::run(), madness::MacroTaskQ::run_all(), madness::CCTimer::start(), madness::MyTimer::start(), molresponse::start_timer(), DF::start_timer(), START_TIMER(), madness::Solver< T, NDIM >::START_TIMER(), madness::MP2::START_TIMER(), madness::CCTimer::stop(), madness::MyTimer::stop(), madness::Znemo::timer::tag(), test9(), test_bsh(), test_Kcommutator(), test_lowrank_function(), test_multi(), test_partial_inner(), test_time(), time_transform(), and madness::CCTimer::update_time().
std::shared_ptr< NuclearCorrelationFactor > madness::create_nuclear_correlation_factor | ( | World & | world, |
const Molecule & | molecule, | ||
const std::shared_ptr< PotentialManager > | pm, | ||
const std::pair< std::string, double > & | ncf | ||
) |
References create_nuclear_correlation_factor(), and molecule.
std::shared_ptr< NuclearCorrelationFactor > madness::create_nuclear_correlation_factor | ( | World & | world, |
const Molecule & | molecule, | ||
const std::shared_ptr< PotentialManager > | potentialmanager, | ||
const std::string | inputline | ||
) |
create and return a new nuclear correlation factor
note there is also an Ad-hoc nuclear correlation factor, which can only be created directly
[in] | world | the world |
[in] | calc | the calculation as read from the input file |
References a, lowercase(), MADNESS_EXCEPTION, molecule, print(), and madness::World::rank().
Referenced by madness::NemoBase::construct_nuclear_correlation_factor(), create_nuclear_correlation_factor(), dnuclear_anchor_test(), main(), and nuclear_anchor_test().
auto madness::create_response_matrix | ( | const size_t & | num_states, |
const size_t & | num_orbitals | ||
) | -> response_matrix |
Create a response matrix object.
num_states | |
num_orbitals |
References xi.
Referenced by molresponseExchange().
std::vector<Function<TENSOR_RESULT_TYPE(T,R),NDIM> > madness::cross | ( | const std::vector< Function< T, NDIM > > & | f, |
const std::vector< Function< R, NDIM > > & | g, | ||
bool | do_refine = false , |
||
bool | fence = true |
||
) |
shorthand cross operator
returns the cross product of vectors f and g
[in] | f | the vector of functions on which the rot operator works on |
[in] | g | the vector of functions on which the rot operator works on |
[in] | fence | fence after completion; currently always fences |
References compress(), d(), f, madness::WorldGopInterface::fence(), g, madness::World::gop, MADNESS_ASSERT, mul(), NDIM, R, reconstruct(), T(), and TENSOR_RESULT_TYPE().
Referenced by madness::Diamagnetic_potential_factor::compute_nabla_R_div_R(), madness::Diamagnetic_potential_factor::compute_U2(), madness::Diamagnetic_potential_factor::compute_v_vector(), madness::Diamagnetic_potential_factor::custom_factor(), madness::Diamagnetic_potential_factor::factor_with_phase(), madness::R_times_arg_div_R::operator()(), and test_cross().
std::uint64_t madness::cstr_to_memory_size | ( | const char * | str | ) |
Unit-aware conversion of a C string to a size_t.
See https://en.wikipedia.org/wiki/Kilobyte for units. This assumes memory units throughout, i.e. MiB
and MB
both mean 1024*1024 bytes, etc. To reduce confusion, KiB
, kB
, and KB
all mean 1024 bytes.
str | The C string to convert. |
References MADNESS_ASSERT.
Referenced by madness::RMI::RmiTask::RmiTask(), and madness::WorldGopInterface::initial_max_reducebcast_msg_size().
std::vector< std::string > madness::cubefile_header | ( | std::string | filename = "input" , |
const bool & | no_orient = false |
||
) |
read molecule from the input file and return part of the header for a Gaussian cube file.
[in] | filename | input file name (usually "input") |
References madness::Molecule::cubefile_header(), filename, molecule, madness::Molecule::orient(), and madness::Molecule::read_file().
Referenced by main(), and madness::MolecularOrbitals< T, NDIM >::print_cubefiles().
|
inlinestatic |
On some machines we have access to a cycle count.
For small intervals this is probably the most lightweight and accurate timer but may not be meaningful over long intervals due to O/S scheduling, migration to different cores, frequency shifts, etc. On x86 uses rtdsc. Otherwise uses wall_time() in nanoseconds.
References a, d(), and wall_time().
Referenced by cpu_frequency(), and cpu_time().
double madness::d2smoothed_potential | ( | double | r | ) |
second radial derivative of the regularized 1/r potential
invoke as d2smoothed_potential(r*rc) * rc*rc*rc with rc the reciprocal smoothing radius d2u[r*rc]*rc*rc*rc \approx 2/r^3
References e(), and madness::constants::pi.
Referenced by madness::Molecule::nuclear_attraction_potential_second_derivative().
|
constexpr |
Key<NDIM> madness::displacement | ( | const Key< NDIM > & | source, |
const Key< NDIM > & | target | ||
) |
given a source and a target, return the displacement in translation
[in] | source | the source key |
[in] | target | the target key |
References MADNESS_ASSERT, source(), and target().
Referenced by madness::MolecularOptimizer::converged(), and madness::MolecularOptimizer::optimize_conjugate_gradients().
|
inline |
Default function for computing the distance between two doubles.
Referenced by madness::Molecule::atomic_attraction_potential(), madness::Molecule::core_potential_derivative(), madness::Molecule::find_symmetry_equivalent_atom(), xc_functor< NDIM >::get_distance(), madness::atom_information< NDIM >::get_distance(), madness::int_factor_functor< NDIM >::get_distance(), madness::lr_pot_functor< NDIM >::get_distance(), MolecularEntity::inter_atomic_distance(), madness::Molecule::inter_atomic_distance(), main(), madness::Molecule::mol_nuclear_charge_density(), madness::Molecule::molecular_core_potential(), MolecularEntity::nuclear_attraction_potential(), madness::Molecule::nuclear_attraction_potential(), madness::Molecule::nuclear_attraction_potential_derivative(), and madness::Molecule::symmetrize_for_op().
|
inlinestatic |
double madness::distance | ( | madness::Function< std::complex< double >, 1ul > & | a, |
madness::Function< std::complex< double >, 1ul > & | b | ||
) |
|
inline |
Default function for computing the distance between two complex numbers.
References a, std::abs(), and b.
|
inlinestatic |
Referenced by madness::Molecule::nuclear_charge_density().
DistributedMatrix<double> madness::distributed_localize_PM | ( | World & | world, |
const std::vector< Function< double, 3 >> & | mo, | ||
const std::vector< Function< double, 3 >> & | ao, | ||
const std::vector< int > & | set, | ||
const std::vector< int > & | at_to_bf, | ||
const std::vector< int > & | at_nbf, | ||
const double | thresh = 1e-9 , |
||
const double | thetamax = 0.5 , |
||
const bool | randomize = true , |
||
const bool | doprint = false |
||
) |
DistributedMatrix<double> madness::distributed_localize_PM | ( | World & | world, |
const vecfuncT & | mo, | ||
const vecfuncT & | ao, | ||
const std::vector< int > & | set, | ||
const std::vector< int > & | at_to_bf, | ||
const std::vector< int > & | at_nbf, | ||
const double | thresh, | ||
const double | thetamax, | ||
const bool | randomize, | ||
const bool | doprint | ||
) |
References A(), a, madness::WorldTaskQueue::add(), at_nbf, at_to_bf, concatenate_rows(), copy(), madness::BaseTensor::dim(), madness::DistributedMatrix< T >::extract_columns(), madness::WorldTaskQueue::fence(), madness::DistributedMatrix< T >::fill_identity(), matrix_inner(), madness::World::taskq, and thresh.
Referenced by madness::Localizer::localize_PM().
Function<T,NDIM> madness::div | ( | const std::vector< Function< T, NDIM > > & | v, |
bool | do_refine = false , |
||
bool | fence = true |
||
) |
shorthand div operator
returns the dot product of nabla with a vector f
[in] | f | the vector of functions on which the div operator works on |
[in] | refine | refinement before diff'ing makes the result more accurate |
[in] | fence | fence after completion; currently always fences |
References apply(), madness::WorldGopInterface::fence(), madness::World::gop, grad(), MADNESS_ASSERT, NDIM, reconstruct(), refine(), sum(), and v.
Referenced by madness::Znemo::compute_current_density(), madness::Diamagnetic_potential_factor::compute_R_times_T_commutator_scalar_term_numerically(), test_rot(), and testNavierStokes().
funcT::returnT madness::do_adq | ( | double | lo, |
double | hi, | ||
const funcT & | func, | ||
int | n, | ||
const double * | x, | ||
const double * | w | ||
) |
void madness::do_response_density_vtk_plots | ( | World & | world, |
int | npt_plot, | ||
double | L, | ||
const Molecule & | molecule, | ||
const real_function_3d & | ground_density, | ||
const vector_real_function_3d & | response_density | ||
) |
void madness::do_response_orbital_vtk_plots | ( | World & | world, |
int | npt_plot, | ||
double | L, | ||
const Molecule & | molecule, | ||
const vector_real_function_3d & | ground_orbs, | ||
const response_matrix & | responseMatrix | ||
) |
void madness::do_vtk_plots | ( | World & | world, |
int | npt_plot, | ||
double | L, | ||
int | lowest_orbital, | ||
int | highest_orbital, | ||
const Molecule & | molecule, | ||
std::vector< real_function_3d > | densities, | ||
const std::string & | name | ||
) |
void madness::do_vtk_plots | ( | World & | world, |
int | npt_plot, | ||
double | L, | ||
Molecule | molecule, | ||
real_function_3d & | rho_0, | ||
std::vector< real_function_3d > & | rho_omega, | ||
std::vector< real_function_3d > & | ground_orbitals, | ||
X_space & | Chi | ||
) |
Function<TENSOR_RESULT_TYPE(T,R), NDIM> madness::dot | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Multiplies and sums two vectors of functions r = \sum_i a[i] * b[i].
References a, b, MADNESS_CHECK, mul(), and sum().
Referenced by madness::TDHF::analyze(), madness::Nemo::compute_all_cphf(), madness::Znemo::compute_current_density(), madness::OEP::compute_dcep_correction(), madness::OEP::compute_density(), madness::OEP::compute_energy_weighted_density_local(), madness::OEP::compute_exchange_energy_vir(), madness::NemoBase::compute_kinetic_energy(), madness::Diamagnetic_potential_factor::compute_lz_commutator(), madness::OEP::compute_mrks_correction(), madness::OEP::compute_ocep_correction(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::compute_offdiagonal_batch_in_symmetric_matrix(), madness::OEP::compute_Pauli_kinetic_density(), madness::Zcis::compute_potentials(), madness::OEP::compute_slater_potential(), madness::OEP::compute_total_kinetic_density(), madness::Zcis::iterate(), madness::Nemo::kinetic_energy_potential(), main(), madness::Zcis::make_guess(), madness::Nemo::make_incomplete_hessian_response_part(), madness::Nemo::make_sigma(), madness::NuclearCorrelationFactor::U3_atomic_functor::operator()(), madness::NuclearCorrelationFactor::U3X_functor::operator()(), madness::XCOperator< T, NDIM >::prep_xc_args(), madness::XCOperator< T, NDIM >::prep_xc_args_response(), madness::Nemo::solve_cphf(), and test_inner().
madness::DPEC | ( | double | , |
double | , | ||
double | |||
) |
madness::DPEC | ( | double_complex | , |
double_complex | , | ||
double_complex | |||
) |
madness::DPEC | ( | float | , |
float | , | ||
float | |||
) |
madness::DPEC | ( | float_complex | , |
float_complex | , | ||
float_complex | |||
) |
madness::DPEC | ( | int | , |
int | , | ||
int | |||
) |
madness::DPEC | ( | long | , |
long | , | ||
long | |||
) |
void madness::drot | ( | long | n, |
double *MADNESS_RESTRICT | a, | ||
double *MADNESS_RESTRICT | b, | ||
double | s, | ||
double | c, | ||
long | inc | ||
) |
Simple (?) version of BLAS-1 DROT(N, DX, INCX, DY, INCY, DC, DS)
Referenced by madness::SystolicPMOrbitalLocalize::localize_PM_ij(), main(), and BoysLocalization::operator()().
double madness::dsmoothed_potential | ( | double | r | ) |
Derivative of the regularized 1/r potential.
dV/dx = (x/r) * du(r/c)/(c*c)
Referenced by madness::CorePotential::eval_derivative(), madness::Molecule::nuclear_attraction_potential_derivative(), Vderiv::operator()(), and madness::PseudoNuclearCorrelationFactor::U2X_spherical().
|
inlinestatic |
|
inlinestatic |
References f.
|
inline |
Referenced by madness::ThreadBase::main(), and print_stats().
|
static |
References cpu_time(), pop(), print_timings, madness::World::rank(), sss, ttt, and wall_time().
Referenced by madness::SCF::analyze_vectors(), KPeriodicBSHOperator::apply(), apply_potential(), madness::SCF::apply_potential(), madness::SCF::compute_residual(), madness::SCF::derivatives(), madness::SCF::diag_fock_matrix(), madness::SCF::dipole(), madness::SCF::do_plots(), madness::SCF::initial_guess(), madness::SCF::kinetic_energy_matrix(), main(), make_coulomb_potential(), make_density(), madness::SCF::make_fock_matrix(), make_kinetic_matrix(), make_lda_potential(), madness::SCF::make_nuclear_potential(), Calculation::make_reference(), Calculation::make_Upsi(), makeao(), orthogonalize(), madness::SCF::orthonormalize(), madness::SCF::solve(), test_coulomb(), test_cross(), test_diff(), test_inner(), test_matrix_mul_sparse(), test_op(), test_rot(), test_transform(), and madness::SCF::update_subspace().
|
inlinestatic |
void madness::error | ( | const char * | msg | ) |
[in] | msg | Message associated with the error. |
References SafeMPI::Intracomm::Abort(), and SafeMPI::COMM_WORLD.
Referenced by madness::DomainMaskSDFFunctor< NDIM >::DomainMaskSDFFunctor(), EmbeddedDirichlet::EmbeddedDirichlet(), madness::DependencyInterface::~DependencyInterface(), madness::WorldGopInterface::barrier(), check(), madness::Localizer::check_core_valence_separation(), madness::PNO::check_orthonormality(), check_vector(), madness::test_output::checkpoint(), madness::CCConvolutionOperator< T, NDIM >::clear_intermediates(), compare(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::compute_error_from_inaccurate_refinement(), madness::DependencyInterface::dec(), madness::DependencyInterface::dec_debug(), doit(), madness::DependencyInterface::inc(), madness::DependencyInterface::inc_debug(), madness::CC2::initialize_pairs(), madness::CC2::iterate_pair(), madness::LowRankFunction< T, NDIM, LDIM >::l2error(), Calculation::load_mos(), main(), madness::ThreadBase::main(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::make_sum_coeffs(), madness::MP2::make_Uphi0(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::operator()(), madness::hartree_leaf_op< T, NDIM >::operator()(), madness::hartree_convolute_leaf_op< T, NDIM, LDIM, opT >::operator()(), EmbeddedDirichlet::operator()(), madness::DomainMaskSDFFunctor< NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local_on_demand< R >::operator()(), madness::FunctionImpl< T, NDIM >::do_truncate_NS_leafs::operator()(), madness::FunctionImpl< T, NDIM >::print_plane_local(), madness::test_output::print_success_fail(), madness::CalculationParameters::set_derived_values(), madness::DomainMaskSDFFunctor< NDIM >::setMaskFunction(), madness::TDHF::test(), test(), Test1(), Test5(), Test6(), Test6a(), Test7(), test_add(), test_addition(), test_combined_operators(), test_construction_optimization(), test_custom_worldobject(), test_emul(), test_G_R_vectors(), test_gaussian_num_coeffs(), test_gconv(), test_hf_be(), test_hf_he(), test_integration(), test_lowrank_function(), madness::Diamagnetic_potential_factor::test_lz_commutator(), test_molecular_grid(), test_multi_to_multi_op(), test_nuclear_energy(), test_nuclear_potential(), test_nuclear_potential2(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), test_orthogonalization(), test_per(), test_projector(), test_qr(), test_reconstruct(), test_reduce_rank(), test_sliced_addition(), test_sliced_assignment(), test_spherical_box(), test_stuff(), madness::Znemo::test_U_potentials(), madness::Diamagnetic_potential_factor::test_vector_potentials(), testNavierStokes(), testPeriodicCoulomb3d(), and madness::CCConvolutionOperator< T, NDIM >::update_elements().
|
static |
Prints an error message, along with some data, and aborts the program.
T | The type of data. |
[in] | msg | The error message. |
[in] | data | The data to be printed. |
References SafeMPI::Intracomm::Abort(), and SafeMPI::COMM_WORLD.
double madness::estimate_area | ( | double | x | ) |
References madness::FunctionDefaults< NDIM >::get_thresh(), and thresh.
void madness::exception_break | ( | bool | message | ) |
This function is executed just before a MadnessException
is thrown.
[in] | message | True to print an error message to cerr ; false otherwise. |
int madness::exchange_anchor_test | ( | World & | world, |
Exchange< T, 3 > & | K, | ||
const double | thresh | ||
) |
anchor test for the exchange operator – partially hardwired
References alpha, check_err(), diff(), madness::Tensor< T >::fill(), madness::FunctionFactory< T, NDIM >::functor(), k, K(), matrix_inner(), norm2s(), print(), madness::BaseTensor::size(), sub(), thresh, madness::FunctionFactory< T, NDIM >::thresh(), and madness::FunctionFactory< T, NDIM >::truncate_on_project().
Referenced by test_exchange(), and test_exchange().
|
inlinestatic |
|
inlinestatic |
|
inline |
a(n,m) --> b(m,n) ... optimized for smallish matrices
References a, a1, a2, b, m, and T().
Referenced by madness::SeparatedConvolution< Q, NDIM >::apply_transformation(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation2(), madness::Convolution1D< Q >::mod_nonstandard(), and madness::Convolution1D< Q >::nonstandard().
Tensor< T > madness::fcube | ( | const Key< NDIM > & | key, |
T(*)(const Vector< double, NDIM > &) | f, | ||
const Tensor< double > & | qx | ||
) |
References madness::BaseTensor::dim(), f, and NDIM.
Referenced by fcube(), madness::FunctionImpl< T, NDIM >::fcube(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_node(), madness::guessfactory::ExopUnaryOpStructure::operator()(), madness::BinaryOpStructure< NDIM >::operator()(), madness::UnaryOpStructure< NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::project(), and madness::ElementaryInterface< T, NDIM >::values().
Tensor< T > madness::fcube | ( | const Key< NDIM > & | key, |
const FunctionFunctorInterface< T, NDIM > & | f, | ||
const Tensor< double > & | qx | ||
) |
References madness::BaseTensor::dim(), f, fcube(), and NDIM.
void madness::fcube | ( | const Key< NDIM > & | key, |
const FunctionFunctorInterface< T, NDIM > & | f, | ||
const Tensor< double > & | qx, | ||
Tensor< T > & | fval | ||
) |
forward declaration
References ___, c, madness::BaseTensor::dim(), f, madness::FunctionDefaults< NDIM >::get_cell(), madness::FunctionDefaults< NDIM >::get_cell_width(), h(), std::isnan(), k, madness::Key< NDIM >::level(), m, MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, p(), pow(), madness::Tensor< T >::ptr(), T(), and madness::Key< NDIM >::translation().
|
inlinestatic |
|
inlinestatic |
void madness::finalize | ( | ) |
Call this once at the very end of your main program instead of MPI_Finalize().
Referenced by main(), main(), TEST_CASE(), test_G_R_vectors(), test_gaussian_num_coeffs(), test_nuclear_energy(), test_nuclear_potential(), test_nuclear_potential2(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), and testNavierStokes().
|
inline |
Applies member function of obj to each child key of parent.
|
inline |
Applies op(key) to each child key of parent.
References op().
|
inline |
Frees an AmArg allocated with alloc_am_arg.
References arg().
Referenced by madness::WorldAmInterface::SendReq::free(), and madness::detail::PendingMsg::invokehandler().
Derivative<T,NDIM> madness::free_space_derivative | ( | World & | world, |
int | axis, | ||
int | k = FunctionDefaults<NDIM>::get_k() |
||
) |
void madness::madness::from_json | ( | const nlohmann::json & | j, |
ResponseParameters & | p | ||
) |
std::shared_ptr< FunctionFunctorInterface<double,3> > madness::func | ( | new | opTg | ) |
Referenced by spherical_harmonic::spherical_harmonic(), abs(), abs_square(), adq(), adq1(), madness::PotentialManager::core_projector_derivative(), madness::SCF::derivatives(), do_adq(), madness::FunctionImpl< T, NDIM >::err_box(), madness::FunctionImpl< T, NDIM >::errsq_local(), madness::WorldAmInterface::handler(), imag(), madness::RMI::isend(), make_func(), madness::FunctionImpl< T, NDIM >::make_Vphi(), madness::EigSolverOp< T, NDIM >::op_o(), madness::EigSolverOp< T, NDIM >::op_r(), spherical_harmonic::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local_on_demand< R >::operator()(), madness::RMI::RmiTask::process_some(), real(), madness::CCPair::serialize(), madness::NuclearCorrelationFactor::square_times_V_derivative(), test2(), test_hydro(), unary_op(), unary_op_coeffs(), madness::FunctionImpl< T, NDIM >::unaryXX(), madness::FunctionImpl< T, NDIM >::unaryXXa(), and madness::FunctionImpl< T, NDIM >::unaryXXvalues().
Function<std::complex<Q>,NDIM> madness::function_real2complex | ( | const Function< Q, NDIM > & | r | ) |
References unary_op_coeffs().
Referenced by madness::InitParameters::read(), and madness::InitParameters::readnw().
|
static |
|
static |
|
static |
Factory for a vectors of futures.
Rationale for this function can be found in Futures.
T | The type of future in the vector. |
[in] | n | The size of the vector to create. |
References madness::Future< T >::default_initializer().
bool madness::gauss_legendre | ( | int | n, |
double | xlo, | ||
double | xhi, | ||
double * | x, | ||
double * | w | ||
) |
Return precomputed (most accurate) or if not available computed (not quite as accurate) points and weights for Gauss Legendre quadrature rule on the specified interval.
References gauss_legendre_numeric(), max_npt, points, read_data(), w(), and weights.
Referenced by madness::Convolution1D< Q >::Convolution1D(), madness::SpectralPropagator::SpectralPropagator(), madness::FunctionCommonData< T, NDIM >::_init_quadrature(), adq(), gauss_legendre_test(), and readin().
bool madness::gauss_legendre_numeric | ( | int | n, |
double | xlo, | ||
double | xhi, | ||
double * | x, | ||
double * | w | ||
) |
Compute the Gauss-Legendre quadrature points and weights.
Return in x and w, which should be arrays of n elements, the points and weights for the n-point Gauss Legendre quadrature rule in [xlo,xhi].
!!!! This routine delivers accurate points, but some weights are accurate only to about 1e-13 for higher order rules. Need a more intelligent way to compute them. See internal comments for more info.
References std::abs(), delta, e(), k, legendre_polynomials(), p(), pi, scale(), and w().
Referenced by gauss_legendre().
bool madness::gauss_legendre_test | ( | bool | ) |
Check error in numerical integ(x+x^2+...+x^(2n-1),x=0..1) using n-pt rule.
References std::abs(), gauss_legendre(), print(), sum(), testf(), and w().
Referenced by startup().
|
inlinestatic |
|
inlinestatic |
void madness::gaxpy | ( | const double | a, |
ScalarResult< T > & | left, | ||
const double | b, | ||
const T & | right, | ||
const bool | fence = true |
||
) |
the result type of a macrotask must implement gaxpy
References a, b, and madness::ScalarResult< T >::gaxpy().
Referenced by madness::PotentialManager::apply_nonlocal_potential(), madness::GTHPseudopotential< Q >::apply_potential(), apply_potential(), madness::SCF::apply_potential(), madness::projector_irrep::apply_symmetry_operators(), madness::SCF::compute_residual(), madness::Solver< T, NDIM >::do_rhs(), DF::exchange(), gaxpy(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_small_memory(), kinetic_energy_matrix(), madness::Nemo::kinetic_energy_potential(), main(), Calculation::make_reference(), madness::EigSolver< T, NDIM >::multi_solve(), madness::response_space::operator+=(), madness::X_space::operator+=(), operator+=(), operator-=(), q_c(), madness::MacroTask< taskT >::MacroTaskInternal::run(), madness::Nemo::solve_cphf(), madness::Solver< T, NDIM >::step_restriction(), test_custom_worldobject(), testNavierStokes(), madness::TDHF::transform(), transform(), madness::Zcis::transform(), transform(), update(), MiniDFT::update(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), madness::SCF::update_subspace(), and Subspace::update_subspace().
void madness::gaxpy | ( | TENSOR_RESULT_TYPE(L, R) | alpha, |
Function< L, NDIM > & | left, | ||
TENSOR_RESULT_TYPE(L, R) | beta, | ||
const Function< R, NDIM > & | right, | ||
bool | fence = true |
||
) |
adds beta*right only left: alpha*left + beta*right optional fence and no automatic compression
left and right might live in different worlds, the accumulation is non-blocking
References alpha, beta, madness::Function< T, NDIM >::gaxpy(), L, NDIM, PROFILE_FUNC, R, and TENSOR_RESULT_TYPE().
void madness::gaxpy | ( | World & | world, |
Q | alpha, | ||
std::vector< Function< T, NDIM > > & | a, | ||
Q | beta, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i].
References a, aa, alpha, b, beta, compress(), madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, MADNESS_CHECK_THROW, and PROFILE_BLOCK.
void madness::gaxpy | ( | World & | world, |
Q | alpha, | ||
std::vector< Function< T, NDIM > > & | a, | ||
Q | beta, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Generalized A*X+Y for vectors of functions -— a[i] = alpha*a[i] + beta*b[i].
References a, alpha, b, beta, compress(), madness::WorldGopInterface::fence(), gaxpy(), madness::World::gop, MADNESS_ASSERT, and PROFILE_BLOCK.
std::vector<Function<TENSOR_RESULT_TYPE(Q,TENSOR_RESULT_TYPE(T,R)),NDIM> > madness::gaxpy_oop | ( | Q | alpha, |
const std::vector< Function< T, NDIM > > & | a, | ||
Q | beta, | ||
const Function< R, NDIM > & | b, | ||
bool | fence = true |
||
) |
out-of-place gaxpy for a vectors and a function: result[i] = alpha * a[i] + beta * b
References a, alpha, b, beta, compress(), gaxpy_oop(), Q(), R, T(), and TENSOR_RESULT_TYPE().
std::vector<Function<TENSOR_RESULT_TYPE(Q,TENSOR_RESULT_TYPE(T,R)),NDIM> > madness::gaxpy_oop | ( | Q | alpha, |
const std::vector< Function< T, NDIM > > & | a, | ||
Q | beta, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
out-of-place gaxpy for two vectors: result[i] = alpha * a[i] + beta * b[i]
References a, alpha, b, beta, compress(), gaxpy_oop(), MADNESS_ASSERT, Q(), R, T(), and TENSOR_RESULT_TYPE().
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::gaxpy_oop | ( | TENSOR_RESULT_TYPE(L, R) | alpha, |
const Function< L, NDIM > & | left, | ||
TENSOR_RESULT_TYPE(L, R) | beta, | ||
const Function< R, NDIM > & | right, | ||
bool | fence = true |
||
) |
Returns new function alpha*left + beta*right optional fence and no automatic compression.
References alpha, beta, L, NDIM, PROFILE_FUNC, R, and TENSOR_RESULT_TYPE().
Referenced by add(), gaxpy_oop(), madness::response_space::operator+(), operator+(), madness::response_space::operator-(), operator-(), response_exchange_multiworld(), sub(), and test_add().
Function<T,NDIM> madness::gaxpy_oop_reconstructed | ( | const double | alpha, |
const Function< T, NDIM > & | left, | ||
const double | beta, | ||
const Function< T, NDIM > & | right, | ||
const bool | fence = true |
||
) |
Returns new function alpha*left + beta*right optional fence, having both addends reconstructed.
References alpha, beta, madness::Function< T, NDIM >::get_impl(), madness::Function< T, NDIM >::is_reconstructed(), MADNESS_ASSERT, and madness::Function< T, NDIM >::set_impl().
Referenced by operator+(), operator-(), and test_add().
template void madness::geev | ( | const Tensor< double > & | A, |
Tensor< double > & | V, | ||
Tensor< double_complex > & | e | ||
) |
void madness::geev | ( | const Tensor< T > & | A, |
Tensor< T > & | VR, | ||
Tensor< std::complex< T >> & | e | ||
) |
Real non-symmetric or complex non-Hermitian eigenproblem.
Solves non-symmetric or non-Hermitian eigenvalue problem.
A is a real non-symmetric or complex non-Hermitian matrix. Return V and e where V is a matrix whose columns are the right eigenvectors and e is a vector containing the corresponding eigenvalues. If the LAPACK routine fails, it raises a TensorException with value=infor. The input matrix is unchanged. The eigenvalues are sorted into ascending order. s/dgeev are used for real non-symmetric matrices; c/zgeev are used for complex non-Hermitian.
Note on the eigenvectors: If the j-th eigenvalue is real, then j-th eigenvector is VR(:,j), the j-th column of VR. If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then j-th eigenvector is VR(:,j) + i*VR(:,j+1) and j+1-th eigenvector is VR(:,j) - i*VR(:,j+1).
The results will satisfy A*V(_,i) = V(_,i)*e(i).
References copy(), e(), geev_(), mask_info(), max, madness::Tensor< T >::ptr(), and TENSOR_ASSERT.
Referenced by geevp().
template void madness::gelss | ( | const Tensor< double > & | a, |
const Tensor< double > & | b, | ||
double | rcond, | ||
Tensor< double > & | x, | ||
Tensor< Tensor< double >::scalar_type > & | s, | ||
long & | rank, | ||
Tensor< Tensor< double >::scalar_type > & | sumsq | ||
) |
template void madness::gelss | ( | const Tensor< double_complex > & | a, |
const Tensor< double_complex > & | b, | ||
double | rcond, | ||
Tensor< double_complex > & | x, | ||
Tensor< Tensor< double_complex >::scalar_type > & | s, | ||
long & | rank, | ||
Tensor< Tensor< double_complex >::scalar_type > & | sumsq | ||
) |
void madness::gelss | ( | const Tensor< T > & | a, |
const Tensor< T > & | b, | ||
double | rcond, | ||
Tensor< T > & | x, | ||
Tensor< typename Tensor< T >::scalar_type > & | s, | ||
long & | rank, | ||
Tensor< typename Tensor< T >::scalar_type > & | sumsq | ||
) |
Solve Ax = b for general A using the LAPACK *gelss routines.
Solves linear equations using least squares.
A should be a matrix (float, double, float_complex, double_complex) and b should be either a vector, or a matrix with each vector stored in a column (i.e., b[n,nrhs]).
If the LAPACK routine fails, it throws a TensorException with the LAPACK info as the value. Otherwise, it returns the solution(s). The input A and b are unchanged. There is no need to worry about Python/C/Fortran ordering issues. It will solve Ax=b as written.
This from the LAPACK documentation
RCOND (input) REAL RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead. RANK (output) INTEGER The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
Finally, the optional vector sumsq will store the sum-of-squares residual in the case of a rectangular matrix (least squares regression).
References a, b, copy(), gelss_(), m, mask_info(), max, madness::Tensor< T >::normf(), madness::Tensor< T >::ptr(), TENSOR_ASSERT, and transpose().
Referenced by Calculation::calc_optimal_coeffs(), GMRES(), KAIN(), KAIN(), optimize_coeffs(), and test_gelss().
GenTensor< TENSOR_RESULT_TYPE(R, Q)> madness::general_transform | ( | const GenTensor< R > & | t, |
const Tensor< Q > | c[] | ||
) |
Similar to transform but each dimension is transformed with a distinct matrix.
The first dimension of the matrices c must match the corresponding dimension of t. template <typename R, typename Q>
Referenced by madness::SeparatedConvolution< Q, NDIM >::apply_transformation2(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation3(), madness::FunctionImpl< T, NDIM >::downsample(), madness::FunctionImpl< T, NDIM >::fcube_for_mul(), madness::FunctionImpl< T, NDIM >::NS_fcube_for_mul(), madness::SeparatedConvolution< Q, NDIM >::partial_upsample(), test_general_transform(), madness::SeparatedConvolution< Q, NDIM >::upsample(), and madness::FunctionImpl< T, NDIM >::upsample().
SVDTensor<TENSOR_RESULT_TYPE(R,Q)> madness::general_transform | ( | const SVDTensor< R > & | t, |
const Tensor< Q > | c[] | ||
) |
template void madness::geqp3 | ( | Tensor< double > & | A, |
Tensor< double > & | tau, | ||
Tensor< integer > & | jpvt | ||
) |
template void madness::geqp3 | ( | Tensor< double_complex > & | A, |
Tensor< double_complex > & | tau, | ||
Tensor< integer > & | jpvt | ||
) |
void madness::geqp3 | ( | Tensor< T > & | A, |
Tensor< T > & | tau, | ||
Tensor< integer > & | jpvt | ||
) |
Compute the QR factorization.
Q is returned in the lapack-specific format
References geqp3_result(), m, TENSOR_ASSERT, and transpose().
void madness::geqp3_result | ( | Tensor< T > & | A, |
Tensor< T > & | tau, | ||
Tensor< integer > & | jpvt, | ||
Tensor< T > & | work | ||
) |
References geqp3_(), m, mask_info(), madness::Tensor< T >::ptr(), madness::BaseTensor::size(), and TENSOR_ASSERT.
Referenced by geqp3().
template void madness::gesv | ( | const Tensor< double > & | a, |
const Tensor< double > & | b, | ||
Tensor< double > & | x | ||
) |
template void madness::gesv | ( | const Tensor< double_complex > & | a, |
const Tensor< double_complex > & | b, | ||
Tensor< double_complex > & | x | ||
) |
void madness::gesv | ( | const Tensor< T > & | a, |
const Tensor< T > & | b, | ||
Tensor< T > & | x | ||
) |
Solve Ax = b for general A using the LAPACK *gesv routines.
Solves symmetric or Hermitian eigenvalue problem - MATLAB syntax.
Solves linear equations.
A should be a square matrix (float, double, float_complex, double_complex) and b should be either a vector, or a matrix with each vector stored in a column (i.e., b[n,nrhs]).
If the LAPACK routine fails, it throws a TensorException with the LAPACK info as the value. Otherwise, it returns the solution(s). The input A and b are unchanged. There is no need to worry about Python/C/Fortran ordering issues. It will solve Ax=b as written.
Solves linear equations
References a, b, copy(), gesv_(), m, mask_info(), madness::Tensor< T >::ptr(), TENSOR_ASSERT, and transpose().
Referenced by madness::GFit< T, NDIM >::bsh_fit(), gesvp(), and test_gesv().
void madness::gesvp | ( | World & | world, |
const Tensor< T > & | a, | ||
const Tensor< T > & | b, | ||
Tensor< T > & | x | ||
) |
const AtomicData & madness::get_atomic_data | ( | unsigned int | atomic_number | ) |
References atomic_data, and NUMBER_OF_ATOMS_IN_TABLE.
Referenced by madness::Atom::Atom(), madness::Molecule::Molecule(), madness::Molecule::add_atom(), madness::Molecule::print(), madness::AtomicBasisSet::print(), madness::AtomicBasisSet::print_all(), madness::AtomicBasisSet::print_anal(), and madness::Molecule::to_json().
double madness::get_charge_from_file | ( | const std::string | filename, |
unsigned int | atype | ||
) |
References debug, filename, MADNESS_EXCEPTION, name(), and symbol_to_atomic_number().
Referenced by madness::Molecule::get_structure().
std::vector<std::shared_ptr<FunctionImpl<T,NDIM> > > madness::get_impl | ( | const std::vector< Function< T, NDIM >> & | v | ) |
|
constexpr |
|
constexpr |
given a tuple return the index of the second argument that is a vector of Function<T,NDIM>
std::string madness::get_mra_data_dir | ( | ) |
|
inline |
Referenced by print_stats().
double madness::get_size | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v | ||
) |
Referenced by madness::F12Potentials::F12Potentials(), madness::PNO::compute_fluctuation_matrix(), madness::F12Potentials::compute_fQc_integrals_ij(), madness::Nemo::compute_nemo_potentials(), madness::PNO::initialize_pairs(), madness::PNO::iterate_pairs_internal(), madness::TDHF::print_xfunctions(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), madness::LowRankFunction< T, NDIM, LDIM >::size(), madness::PNOPairs::update_meminfo(), and madness::PNO::update_pno().
template void madness::ggev | ( | const Tensor< double > & | A, |
Tensor< double > & | B, | ||
Tensor< double > & | V, | ||
Tensor< double_complex > & | e | ||
) |
void madness::ggev | ( | const Tensor< T > & | A, |
Tensor< T > & | B, | ||
Tensor< T > & | VR, | ||
Tensor< std::complex< T >> & | e | ||
) |
Generalized real-non-symmetric or complex-non-Hermitian eigenproblem.
Solves non-symmetric or non-Hermitian generalized eigenvalue problem.
This from the LAPACK documentation
S/DGGEV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized non-symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x. C/ZGGEV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized non-Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x.
Note on the eigenvalues: On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will be the generalized eigenvalues. If ALPHAI(j) is zero, then the j-th eigenvalue is real; if positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) negative.
Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) may easily over- or underflow, and BETA(j) may even be zero. Thus, the user should avoid naively computing the ratio alpha/beta. However, ALPHAR and ALPHAI will be always less than and usually comparable with norm(A) in magnitude, and BETA always less than and usually comparable with norm(B).
Note on the eigenvectors: The right eigenvectors v(j) are stored one after another in the columns of VR, in the same order as their eigenvalues. If the j-th eigenvalue is real, then v(j) = VR(:,j), the j-th column of VR. If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1). Each eigenvector is scaled so the largest component has abs(real part)+abs(imag. part)=1.
References beta, copy(), e(), ggev_(), MADNESS_ASSERT, mask_info(), max, madness::Tensor< T >::ptr(), TENSOR_ASSERT, and transpose().
Referenced by ggevp().
void madness::GMRES | ( | const AbstractVectorSpace< T, real_type, scalar_type > & | space, |
const Operator< T > & | op, | ||
const T & | b, | ||
T & | x, | ||
int & | maxiters, | ||
real_type & | resid_thresh, | ||
real_type & | update_thresh, | ||
const bool | outp = false |
||
) |
A GMRES solver routine for linear systems, .
Requires the vector space, the operator, A, the inhomogeneity b, an initial guess x, the maximum number of iterations, the convergence threshold for the solution residual, the convergence threshold for the norm of the update vector, and a flag for producing output.
The vector space object provides a standard way to compute the needed linear algebra operations (norm, inner product, etc.).
The printed output, if desired, shows iteration number, the residual, the norm of the change in solution vectors from one iteration to the next, and the effective rank of the GMRES matrix at that iteration.
On output, x has the computed solution, resid_thresh has its residual, update_thresh has the latest updatenorm, and maxiters has the number of iterations needed.
[in] | space | The AbstractVectorSpace interface for the type |
[in] | op | The Operator |
[in] | b | The right-hand-side vector |
[in,out] | x | Input: The initial guess for . Output: The computed solution for . |
[in,out] | maxiters | Input: Maximum number of iterations to perform. Output: Actual iterations performed. |
[in,out] | resid_thresh | Input: Convergence threshold for the residual . Output: The residual after the final iteration. |
[in,out] | update_thresh | Input: Convergence threshold for the update vector . Output: The value after the final iteration. |
[in] | outp | True if output to stdout is desired, false otherwise, defaults to false if unspecified. |
References b, copy(), madness::AbstractVectorSpace< T, real_type, scalar_type >::destroy(), madness::AbstractVectorSpace< T, real_type, scalar_type >::gaxpy(), gelss(), imag(), madness::AbstractVectorSpace< T, real_type, scalar_type >::inner(), madness::AbstractVectorSpace< T, real_type, scalar_type >::norm(), madness::detail::norm(), madness::Tensor< T >::normf(), op(), madness::World::rank(), real(), madness::AbstractVectorSpace< T, real_type, scalar_type >::scale(), T(), V(), and madness::AbstractVectorSpace< T, real_type, scalar_type >::world.
Referenced by cplxfunc0(), cplxfunc1(), cplxfunc2(), cplxvec0(), cplxvec1(), cplxvec2(), main(), realfunc0(), realfunc1(), realfunc2(), realvec0(), realvec1(), and realvec2().
void madness::gprofexit | ( | int | id, |
int | nproc | ||
) |
std::vector<Function<T,NDIM> > madness::grad | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
shorthand gradient operator
returns the differentiated function f in all NDIM directions
[in] | f | the function on which the grad operator works on |
[in] | refine | refinement before diff'ing makes the result more accurate |
[in] | fence | fence after completion; if reconstruction is needed always fence |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, NDIM, and refine().
Referenced by madness::Znemo::compute_current_density(), compute_energy(), madness::OEP::compute_exchange_energy_vir(), compute_fock_matrix(), madness::NemoBase::compute_gradient(), madness::NemoBase::compute_kinetic_energy1(), madness::NemoBase::compute_kinetic_energy1a(), madness::Znemo::compute_kinetic_momentum(), madness::OEP::compute_Pauli_kinetic_density(), madness::F12Potentials::compute_regularized_fluctuation_matrix(), div(), grad_ble_one(), grad_ble_two(), grad_bpsline_two(), grad_bspline_one(), grad_bspline_three(), MolecularMaskBase::gradient(), madness::Nemo::gradient(), madness::Znemo::gradient(), madness::Nemo::make_sigma(), MolecularSurface::operator()(), MolecularVolumeMaskGrad::operator()(), madness::XCOperator< T, NDIM >::prep_xc_args(), madness::XCOperator< T, NDIM >::prep_xc_args_response(), rot(), test_rot(), and madness::Diamagnetic_potential_factor::test_vector_potentials().
std::vector<Function<T,NDIM> > madness::grad_ble_one | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, grad(), NDIM, and refine().
Referenced by madness::XCOperator< T, NDIM >::prep_xc_args().
std::vector<Function<T,NDIM> > madness::grad_ble_two | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, grad(), NDIM, and refine().
std::vector<Function<T,NDIM> > madness::grad_bpsline_two | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, grad(), NDIM, and refine().
std::vector<Function<T,NDIM> > madness::grad_bspline_one | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, grad(), NDIM, and refine().
Referenced by madness::OEP::compute_Pauli_kinetic_density(), madness::Diamagnetic_potential_factor::compute_R_times_T_commutator_scalar_term_numerically(), and madness::XCOperator< T, NDIM >::prep_xc_args().
std::vector<Function<T,NDIM> > madness::grad_bspline_three | ( | const Function< T, NDIM > & | f, |
bool | refine = false , |
||
bool | fence = true |
||
) |
References apply(), f, madness::WorldGopInterface::fence(), madness::World::gop, grad(), NDIM, and refine().
|
inlinestatic |
Factory function generating operator for convolution with grad(bsh) in 3D.
Returns a 3-vector containing the convolution operator for the x, y, and z components of grad(bsh)
References BC_PERIODIC, madness::GFit< T, NDIM >::BSHFit(), c, d(), madness::BaseTensor::dim(), dir, fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, madness::Tensor< T >::normf(), pi, madness::constants::pi, and pow().
Referenced by apply_BSH().
|
inlinestatic |
Factory function generating operator for convolution with grad(1/r) in 3D.
Returns a 3-vector containing the convolution operator for the x, y, and z components of grad(1/r)
References BC_PERIODIC, c, madness::GFit< T, NDIM >::CoulombFit(), d(), madness::BaseTensor::dim(), dir, fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, madness::Tensor< T >::normf(), pi, madness::constants::pi, and pow().
Referenced by testgradG().
std::vector< std::shared_ptr< Derivative<T,NDIM> > > madness::gradient_operator | ( | World & | world, |
const BoundaryConditions< NDIM > & | bc = FunctionDefaults<NDIM>::get_bc() , |
||
int | k = FunctionDefaults<NDIM>::get_k() |
||
) |
Convenience function returning vector of derivative operators implementing grad ( )
This will only work for BC_ZERO, BC_PERIODIC, BC_FREE and BC_ZERONEUMANN since we are not passing in any boundary functions.
References BC_DIRICHLET, BC_NEUMANN, d(), k, MADNESS_CHECK, and NDIM.
|
inlinestatic |
Factory function generating operator for convolution with grad(e^{-\gamma*r}) in 3D.
Returns a 3-vector containing the convolution operator for the x, y, and z components of grad(e^{-\gamma*r}) maybe move to madness library (operator.h) at some point
References BC_PERIODIC, c, d(), madness::BaseTensor::dim(), dir, fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, madness::Tensor< T >::normf(), pi, madness::constants::pi, pow(), and madness::GFit< T, NDIM >::SlaterFit().
Referenced by madness::F12Potentials::F12Potentials().
Function<T,KDIM+LDIM> madness::hartree_product | ( | const Function< T, KDIM > & | left2, |
const Function< T, LDIM > & | right2 | ||
) |
Performs a Hartree product on the two given low-dimensional functions.
References hartree_product().
Function<T,KDIM+LDIM> madness::hartree_product | ( | const Function< T, KDIM > & | left2, |
const Function< T, LDIM > & | right2, | ||
const opT & | op | ||
) |
Performs a Hartree product on the two given low-dimensional functions.
References madness::Function< T, NDIM >::do_hartree_product(), madness::FunctionFactory< T, NDIM >::empty(), madness::WorldGopInterface::fence(), madness::Function< T, NDIM >::get_impl(), madness::FunctionDefaults< NDIM >::get_thresh(), madness::World::gop, madness::Function< T, NDIM >::k(), madness::FunctionFactory< T, NDIM >::k(), madness::Function< T, NDIM >::make_nonstandard(), op(), print(), madness::World::rank(), madness::Function< T, NDIM >::standard(), thresh, madness::FunctionFactory< T, NDIM >::thresh(), and madness::Function< T, NDIM >::world().
Function<T,KDIM+LDIM> madness::hartree_product | ( | const std::vector< Function< T, KDIM >> & | left, |
const std::vector< Function< T, LDIM >> & | right | ||
) |
Performs a Hartree/outer product on the two given low-dimensional function vectors.
References change_tree_state(), madness::Function< T, NDIM >::do_hartree_product(), madness::FunctionFactory< T, NDIM >::empty(), get_impl(), madness::FunctionDefaults< NDIM >::get_thresh(), madness::Function< T, NDIM >::k(), madness::FunctionFactory< T, NDIM >::k(), MADNESS_CHECK_THROW, nonstandard_with_leaves, madness::Function< T, NDIM >::size(), thresh, madness::FunctionFactory< T, NDIM >::thresh(), and madness::Function< T, NDIM >::world().
Referenced by hartree_product(), main(), madness::StrongOrthogonalityProjector< T, NDIM >::operator()(), madness::Projector< T, NDIM >::operator()(), madness::LowRankFunction< T, NDIM, LDIM >::reconstruct(), test(), test_adaptive_tree(), test_add(), test_compress(), test_convolution(), test_exchange(), test_hartree_product(), test_inner(), test_partial_inner(), and test_recursive_application().
Combine hash values.
This function uses the standard hash function.
T | The type to hash |
[in,out] | seed | The initial hash seed value |
[in] | v | The value to be hashed |
References madness::detail::combine_hash(), and v.
Referenced by Key::Key(), madness::Recordlist< keyT >::compute_record(), madness::GaussianConvolution1DCache< Q >::get(), madness::CC_vecfunction::hash(), madness::CCPair::hash(), madness::Atom::hash(), madness::Molecule::hash(), madness::TwoBodyFunctionPureComponent< T, NDIM >::hash(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::hash(), hash_value(), and madness::Key< NDIM >::rehash().
Combine the hash values of a pointer range.
T | The type to be hashed |
t | A pointer to the beginning of the range to be hashed |
n | The number of elements to hashed |
References hash_range().
Combine the hash values of a C-style array.
T | The type to be hashed |
n | The size of the C-style array |
[in] | t | The array to be hashed |
References hash_range().
|
inline |
Combine the hash values of a pointer range.
T | The type to be hashed |
[in,out] | seed | The initial hash seed value |
[in] | t | A pointer to the beginning of the range to be hashed |
[in] | n | The number of elements to hashed |
References hashlittle(), hashword(), and T().
|
inline |
Combine the hash values of a pointer range.
T | The type to be hashed |
[in,out] | seed | The initial hash seed value |
[in] | t | A pointer to the beginning of the range to be hashed |
[in] | n | The number of elements to hashed |
References hash_range().
Combine the hash values of a C-style array.
T | The type to be hashed |
n | The size of the C-style array |
[in,out] | seed | The initial hash seed value |
[in] | t | The array to be hashed |
References hash_range().
|
inline |
It | the iterator type |
[in,out] | seed | The initial hash seed value |
[in] | first | The first element of the iterator range to be hashed |
[in] | last | The end of the iterator range to be hashed |
References madness::detail::combine_hash().
Referenced by madness::Recordlist< keyT >::compute_record(), madness::Molecule::hash(), madness::QCCalculationParametersBase::hash(), hash_range(), and hash_value().
|
inline |
Combine the hash values of an iterator range.
It | the iterator type |
[in] | first | The first element of the iterator range to be hashed |
[in] | last | The end of the iterator range to be hashed |
References hash_range().
madness::hashT madness::hash_value | ( | const std::array< T, N > & | a | ) |
Hash std::array with madness hash.
T | The type of data stored in the array. |
N | The size of the array. |
[in] | a | The array. |
References a, hash_range(), and N.
Referenced by Key::Key(), madness::Recordlist< keyT >::compute_record(), madness::GaussianConvolution1DCache< Q >::get(), madness::CC_vecfunction::hash(), madness::CCPair::hash(), madness::Atom::hash(), madness::QCParameter::hash(), madness::Vector< T, N >::hash(), madness::TwoBodyFunctionPureComponent< T, NDIM >::hash(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::hash(), std::hash_value(), hash_value(), madness::Hash< T >::operator()(), and madness::Key< NDIM >::rehash().
Hash a std::basic_string.
T | The character type |
t | The string to hash |
References hash_range().
Hash a std::pair.
t | a pair to hash |
t
References hash_combine(), and hash_value().
|
inline |
Hash a class object.
T | The class type |
t | The object to hash |
t.hash()
Hash a pointer address.
T | The pointer type |
t | The pointer to be hashed |
References hash_value().
|
inline |
Hash a single fundamental object.
T | The fundamental type |
t | The object to hash |
References hashword(), T(), and u().
|
inline |
Hash a single fundamental object.
T | The fundamental type |
t | The object to hash |
References hashlittle(), T(), and u().
void madness::hereig | ( | char | jobz, |
char | uplo, | ||
integer | n, | ||
complex_real4 * | A, | ||
integer | lda, | ||
real4 * | W | ||
) |
References cheev_(), LINALG_ASSERT, max, and madness::cblas::to_cptr().
void madness::hereig | ( | char | jobz, |
char | uplo, | ||
integer | n, | ||
complex_real8 * | A, | ||
integer | lda, | ||
real8 * | W | ||
) |
References LINALG_ASSERT, max, madness::cblas::to_zptr(), and zheev_().
void madness::hereig | ( | char | jobz, |
char | uplo, | ||
integer | n, | ||
real4 * | A, | ||
integer | lda, | ||
real4 * | W | ||
) |
References LINALG_ASSERT, and ssyev_().
void madness::hereig | ( | char | jobz, |
char | uplo, | ||
integer | n, | ||
real8 * | A, | ||
integer | lda, | ||
real8 * | W | ||
) |
References dsyev_(), and LINALG_ASSERT.
void madness::hereig | ( | char | jobz, |
char | uplo, | ||
integer | n, | ||
T * | A, | ||
integer | lda, | ||
typename detail::real_type< T >::type * | W | ||
) |
Solve the EVP via LAPACK.
void madness::hereig_gen | ( | integer | itype, |
char | jobz, | ||
char | uplo, | ||
integer | n, | ||
complex_real4 * | A, | ||
integer | lda, | ||
complex_real4 * | B, | ||
integer | ldb, | ||
real4 * | W | ||
) |
References chegv_(), LINALG_ASSERT, max, and madness::cblas::to_cptr().
void madness::hereig_gen | ( | integer | itype, |
char | jobz, | ||
char | uplo, | ||
integer | n, | ||
complex_real8 * | A, | ||
integer | lda, | ||
complex_real8 * | B, | ||
integer | ldb, | ||
real8 * | W | ||
) |
References LINALG_ASSERT, max, madness::cblas::to_zptr(), and zhegv_().
void madness::hereig_gen | ( | integer | itype, |
char | jobz, | ||
char | uplo, | ||
integer | n, | ||
real4 * | A, | ||
integer | lda, | ||
real4 * | B, | ||
integer | ldb, | ||
real4 * | W | ||
) |
References LINALG_ASSERT, and ssygv_().
void madness::hereig_gen | ( | integer | itype, |
char | jobz, | ||
char | uplo, | ||
integer | n, | ||
real8 * | A, | ||
integer | lda, | ||
real8 * | B, | ||
integer | ldb, | ||
real8 * | W | ||
) |
References dsygv_(), and LINALG_ASSERT.
void madness::hereig_gen | ( | integer | itype, |
char | jobz, | ||
char | uplo, | ||
integer | n, | ||
T * | A, | ||
integer | lda, | ||
T * | B, | ||
integer | ldb, | ||
typename detail::real_type< T >::type * | W | ||
) |
Solve the Generalized EVP via LAPACK.
Function<double,NDIM> madness::imag | ( | const Function< double_complex, NDIM > & | z, |
bool | fence = true |
||
) |
Returns a new function that is the imaginary part of the input.
References unary_op_coeffs().
Function<typename TensorTypeData<Q>::scalar_type,NDIM> madness::imag | ( | const Function< Q, NDIM > & | func | ) |
References func(), and unary_op_coeffs().
|
inline |
Referenced by madness::Znemo::analyze(), madness::projector_irrep::apply_symmetry_operators(), madness::Znemo::compute_current_density(), madness::Znemo::compute_energy(), madness::Znemo::compute_kinetic_momentum(), compute_madelung_energy(), EwaldNuclearPotentialFunctor::do_G_sum_v2(), madness::BSHApply< T, NDIM >::eps_in_green(), GMRES(), imag(), madness::VectorSpace< T, NDIM >::norm(), madness::CCPairFunction< T, NDIM >::norm2(), madness::detail::imagop< NDIM >::operator()(), madness::imag_op< Q, NDIM >::operator()(), Spinor::plot(), plot_line_print_value(), plotvtk_data(), Spinor::print_norms(), madness::Znemo::save_orbitals(), tensor_ximag(), and test_G_R_vectors().
std::vector<Function<T,NDIM> > madness::impl2function | ( | const std::vector< std::shared_ptr< FunctionImpl< T, NDIM >>> | vimpl | ) |
References set_impl(), and v.
Referenced by madness::CompositeFunctorInterface< T, NDIM, MDIM >::make_redundant().
void madness::init_tensor_lapack | ( | ) |
World& madness::initialize | ( | int & | argc, |
char **& | argv, | ||
bool | quiet = false |
||
) |
Initializes the MADNESS runtime with default MPI communicator and default number of compute threads Call this once at the very top of your main program to initialize the MADNESS runtime. This function should be called instead of MPI_Init()
or MPI_Init_thread()
.
[in,out] | argc | Application argument count. |
[in,out] | argv | Application argument values. |
[in] | quiet | If false, will announce to std::cout on rank 0 when the runtime has been initialized. |
MAD_NUM_THREADS
; if the environment variable is not given the number of compute thread is set to the system-defined number of hardware threads. References SafeMPI::COMM_WORLD, and quiet().
Referenced by data< T, NDIM >::get_ccpairfunctions(), data< T, NDIM >::get_functions(), initialize(), main(), main(), TEST_CASE(), test_G_R_vectors(), test_gaussian_num_coeffs(), test_nuclear_energy(), test_nuclear_potential(), test_nuclear_potential2(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), and testNavierStokes().
World& madness::initialize | ( | int & | argc, |
char **& | argv, | ||
const MPI_Comm & | comm, | ||
int | nthread, | ||
bool | quiet = false |
||
) |
Initializes the MADNESS runtime with the given MPI communicator and the given number of compute threads Call this once at the very top of your main program to initialize the MADNESS runtime. This function should be called instead of MPI_Init()
or MPI_Init_thread()
.
[in,out] | argc | Application argument count. |
[in,out] | argv | Application argument values. |
comm | The MPI communicator that should be used to construct the World object. | |
[in] | nthread | The total number of compute threads to create (the main thread is counted among the compute threads) if a negative value is given then the default number of compute threads will be used. |
[in] | quiet | If false, will announce to std::cout on rank 0 when the runtime has been initialized. |
MAD_NUM_THREADS
; if the environment variable is not given the number of compute thread is set to the system-defined number of hardware threads. References initialize(), and quiet().
World & madness::initialize | ( | int & | argc, |
char **& | argv, | ||
const SafeMPI::Intracomm & | comm, | ||
bool | quiet = false |
||
) |
Initializes the MADNESS runtime with the given MPI communicator and the default number of compute threads Call this once at the very top of your main program to initialize the MADNESS runtime. This function should be called instead of MPI_Init()
or MPI_Init_thread()
.
[in,out] | argc | Application argument count. |
[in,out] | argv | Application argument values. |
comm | The communicator that should be used to construct the World object. | |
[in] | quiet | If false, will announce to std::cout on rank 0 when the runtime has been initialized. |
MAD_NUM_THREADS
; if the environment variable is not given the number of compute thread is set to the system-defined number of hardware threads. References initialize(), and quiet().
World& madness::initialize | ( | int & | argc, |
char **& | argv, | ||
const SafeMPI::Intracomm & | comm, | ||
int | nthread, | ||
bool | quiet = false |
||
) |
Initializes the MADNESS runtime with the given MPI communicator and the given number of compute threads Call this once at the very top of your main program to initialize the MADNESS runtime. This function should be called instead of MPI_Init()
or MPI_Init_thread()
.
[in,out] | argc | Application argument count. |
[in,out] | argv | Application argument values. |
comm | The communicator that should be used to construct the World object. | |
[in] | nthread | The total number of compute threads to create (the main thread is counted among the compute threads); if a negative value is given then the default number of compute threads will be used. |
[in] | quiet | If false, will announce to std::cout on rank 0 when the runtime has been initialized. |
MAD_NUM_THREADS
; if the environment variable is not given the number of compute thread is set to the system-defined number of hardware threads. World& madness::initialize | ( | int & | argc, |
char **& | argv, | ||
int | nthread, | ||
bool | quiet = false |
||
) |
Initializes the MADNESS runtime with default MPI communicator and the given number of compute threads Call this once at the very top of your main program to initialize the MADNESS runtime. This function should be called instead of MPI_Init()
or MPI_Init_thread()
.
[in,out] | argc | Application argument count. |
[in,out] | argv | Application argument values. |
[in] | nthread | The total number of compute threads to create (the main thread is counted among the compute threads) if a negative value is given then the default number of compute threads will be used. |
[in] | quiet | If false, will announce to std::cout on rank 0 when the runtime has been initialized. |
MAD_NUM_THREADS
; if the environment variable is not given the number of compute thread is set to the system-defined number of hardware threads. References SafeMPI::COMM_WORLD, initialize(), and quiet().
void madness::initialize_legendre_stuff | ( | ) |
|
inline |
bool madness::initialized | ( | ) |
Check if the MADNESS runtime has been initialized (and not subsequently finalized).
madness::initialize
had been called more recently than madness::finalize
, false otherwise. Referenced by madness::WorldObject< Derived >::~WorldObject(), madness::archive::archive_initialize_type_names(), madness::FunctionDefaults< NDIM >::get_pmap(), SafeMPI::Is_initialized(), and wall_time().
Function<T,CCPairFunction<T,NDIM>::LDIM> madness::inner | ( | const CCPairFunction< T, NDIM > & | c, |
const Function< T, CCPairFunction< T, NDIM >::LDIM > & | f, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v1, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v2 | ||
) |
Function<T,CCPairFunction<T,NDIM>::LDIM> madness::inner | ( | const CCPairFunction< T, NDIM > & | c, |
const Function< T, CCPairFunction< T, NDIM >::LDIM > & | f, | ||
const std::tuple< int, int, int > | v1, | ||
const std::tuple< int, int, int > | v2 | ||
) |
CCPairFunction<T,NDIM> madness::inner | ( | const CCPairFunction< T, NDIM > & | c1, |
const CCPairFunction< T, NDIM > & | c2, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v1, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v2 | ||
) |
CCPairFunction<T,NDIM> madness::inner | ( | const CCPairFunction< T, NDIM > & | c1, |
const CCPairFunction< T, NDIM > & | c2, | ||
const std::tuple< int, int, int > | v1, | ||
const std::tuple< int, int, int > | v2 | ||
) |
LowRankFunction<T,NDIM> madness::inner | ( | const Function< T, NDIM > & | f1, |
const LowRankFunction< T, NDIM > & | f2, | ||
const particle< PDIM > | p1, | ||
const particle< PDIM > | p2 | ||
) |
lrf(1,3) = inner(full(1,2), lrf(2,3))
inner product: LowRankFunction lrf; Function f, g; double d lrf(1,3) = inner(lrf(1,2), lrf(2,3)) lrf(1,3) = inner(lrf(1,2), f(2,3)) g(1) = inner(lrf(1,2), f(2)) d = inner(lrf(1,2), f(1,2)) d = inner(lrf(1,2), lrf(1,2))
[in] | f1 | the first function |
[in] | f2 | the second function |
[in] | p1 | the integration variable of the first function |
[in] | p2 | the integration variable of the second function |
double madness::inner | ( | const LowRankFunction< T, NDIM > & | a, |
const LowRankFunction< T, NDIM > & | b | ||
) |
References a, b, and matrix_inner().
LowRankFunction<T,NDIM> madness::inner | ( | const LowRankFunction< T, NDIM > & | f1, |
const Function< T, NDIM > & | f2, | ||
const particle< PDIM > | p1, | ||
const particle< PDIM > | p2 | ||
) |
lrf(1,3) = inner(lrf(1,2), full(2,3))
[in] | f1 | the first function |
[in] | f2 | the second function |
[in] | p1 | the integration variable of the first function |
[in] | p2 | the integration variable of the second function |
References change_tree_state(), f1, f2, madness::LowRankFunction< T, NDIM, LDIM >::g, madness::particle< PDIM >::get_array(), madness::LowRankFunction< T, NDIM, LDIM >::h, madness::particle< PDIM >::is_first(), madness::particle< PDIM >::is_last(), NDIM, and reconstructed.
LowRankFunction<T,NDIM> madness::inner | ( | const LowRankFunction< T, NDIM > & | f1, |
const LowRankFunction< T, NDIM > & | f2, | ||
const particle< PDIM > | p1, | ||
const particle< PDIM > | p2 | ||
) |
lrf(1,3) = inner(lrf(1,2), lrf(2,3))
[in] | f1 | the first function |
[in] | f2 | the second function |
[in] | p1 | the integration variable of the first function |
[in] | p2 | the integration variable of the second function |
References madness::particle< PDIM >::complement(), copy(), f1, f2, matrix_inner(), NDIM, and transform().
std::vector<Function<T,NDIM-PDIM> > madness::inner | ( | const LowRankFunction< T, NDIM > & | f1, |
const std::vector< Function< T, PDIM >> & | vf, | ||
const particle< PDIM > | p1, | ||
const particle< PDIM > | p2 = particle<PDIM>::particle1() |
||
) |
f(1) = inner(lrf(1,2), f(2))
[in] | f1 | the first function |
[in] | vf | vector of the second functions |
[in] | p1 | the integration variable of the first function |
[in] | p2 | the integration variable of the second function, dummy variable for consistent notation |
References madness::particle< PDIM >::complement(), f1, MADNESS_CHECK, matrix_inner(), NDIM, and transform().
double madness::inner | ( | const std::valarray< double > & | bra, |
const std::valarray< double > & | ket | ||
) |
inner product for std::valarray
std::vector<CCPairFunction<T,NDIM> > madness::inner | ( | const std::vector< CCPairFunction< T, NDIM >> & | c1, |
const std::vector< CCPairFunction< T, NDIM >> & | c2, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v1, | ||
const std::array< int, CCPairFunction< T, NDIM >::LDIM > & | v2 | ||
) |
std::vector<CCPairFunction<T,NDIM> > madness::inner | ( | const std::vector< CCPairFunction< T, NDIM >> & | c1, |
const std::vector< CCPairFunction< T, NDIM >> & | c2, | ||
const std::tuple< int, int, int > | v1, | ||
const std::tuple< int, int, int > | v2 | ||
) |
References inner().
T madness::inner | ( | const Vector< T, N > & | l, |
const Vector< T, N > & | r | ||
) |
|
inline |
References a, b, and MADNESS_ASSERT.
Referenced by madness::Znemo::analyze(), madness::SCF::analyze_vectors(), madness::Solver< T, NDIM >::apply_hf_exchange3(), madness::Solver< T, NDIM >::apply_hf_exchange4(), madness::Solver< T, NDIM >::apply_potential(), madness::SCF::apply_potential(), madness::projector_irrep::apply_symmetry_operators(), madness::Diamagnetic_potential_factor::bare_diamagnetic_potential(), bend(), Calculation::calc_optimal_coeffs(), madness::HartreeFock< T, NDIM >::calculate_coulomb_energy(), madness::HartreeFock< T, NDIM >::calculate_exchange_energy(), madness::HartreeFock< T, NDIM >::calculate_ke_sp(), madness::DFT< T, NDIM >::calculate_ke_sp(), madness::Solver< T, NDIM >::calculate_kinetic_energy(), madness::DFT< T, NDIM >::calculate_tot_pe_sp(), madness::RandomizedMatrixDecomposition< T >::check_range(), madness::SRConf< T >::check_right_orthonormality(), madness::OEP::compute_and_print_final_energies(), madness::MolecularOrbitals< T, NDIM >::compute_center(), madness::guessfactory::compute_centroids(), madness::PNO::compute_cispd_correction_gs(), madness::PNO::compute_cispd_f12_correction_es(), madness::PNO::compute_cispd_f12_correction_gs(), madness::F12Potentials::compute_cispd_f12_energies(), madness::Localizer::compute_core_valence_separation_transformation_matrix(), madness::OEP::compute_E_first(), madness::Znemo::compute_energy(), madness::OEP::compute_energy(), compute_energy(), madness::Nemo::compute_energy_regularized(), compute_energy_simple(), compute_energy_with_U(), madness::OEP::compute_exchange_energy_conv(), madness::OEP::compute_exchange_energy_vir(), madness::OEP::compute_fock_diagonal_elements(), compute_fock_matrix(), madness::Zcis::compute_fock_pt(), madness::F12Potentials::compute_fQc_integrals_ij(), madness::F12Potentials::compute_fQg_integral(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), compute_frequencies(), madness::MP2::compute_gQf(), madness::Nemo::compute_IR_intensities(), madness::NemoBase::compute_kinetic_energy(), madness::NemoBase::compute_kinetic_energy2(), madness::Znemo::compute_kinetic_momentum(), madness::Znemo::compute_linear_moment(), madness::Znemo::compute_magnetic_potential_expectation(), madness::MP3::compute_mp3_cd(), madness::MP3::compute_mp3_ef(), madness::MP3::compute_mp3_ef_low_scaling(), madness::MP3::compute_mp3_ef_with_permutational_symmetry(), madness::MP3::compute_mp3_ghij(), madness::MP3::compute_mp3_ghij_fast(), madness::MP3::compute_mp3_klmn(), madness::MP3::compute_mp3_klmn_fast(), madness::Diamagnetic_potential_factor::compute_nabla_R_div_R(), compute_R2f2_psi(), madness::MolecularOptimizer::compute_reduced_mass(), compute_reduced_mass(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), madness::SVDTensor< T >::compute_svd_from_range(), madness::Diamagnetic_potential_factor::compute_U2(), converge(), converge2s(), madness::PotentialManager::core_projection(), madness::PotentialManager::core_projector_derivative(), madness::Diamagnetic_potential_factor::custom_factor(), madness::Znemo::custom_guess(), madness::SCF::derivatives(), dnuclear_anchor_test(), madness::RandomizedMatrixDecomposition< T >::do_compute_range(), madness::Derivative< T, NDIM >::do_diff2b(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), doit(), dx2y2_func(), dxy_func(), dxz_func(), dyz_func(), dz2_func(), eigenvector_test(), energy(), madness::Diamagnetic_potential_factor::factor_with_phase(), fixphases(), madness::TensorTrain< T >::fusedim(), madness::SRConf< T >::general_transform(), general_transform(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), madness::Solver< T, NDIM >::gram_schmidt(), madness::Nemo::hessian(), QuasiNewton::hessian_update_bfgs(), madness::QuasiNewton::hessian_update_bfgs(), QuasiNewton::hessian_update_sr1(), madness::QuasiNewton::hessian_update_sr1(), madness::SCF::initial_guess(), data< T, NDIM >::initialize(), inner(), inner(), Fcwf::inner(), madness::CCPairFunction< T, NDIM >::inner_internal(), is_aligned(), is_centered_normal(), madness::Znemo::iterate(), iterate(), madness::Zcis::iterate(), iterate_excite(), iterate_ground(), madness::CC2::iterate_singles(), madness::TDHF::iterate_vectors(), iterate_xy(), madness::LowRankFunction< T, NDIM, LDIM >::l2error(), madness::Localizer::localize(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), madness::TDHF::make_cis_matrix(), madness::TwoElectronInterface< T, NDIM >::make_coeff(), madness::Nemo::make_incomplete_hessian(), madness::Nemo::make_incomplete_hessian_response_part(), madness::TDHF::make_overlap_matrix(), madness::TDHF::make_perturbed_fock_matrix(), Calculation::make_reference(), madness::RandomizedMatrixDecomposition< T >::make_SVD_decaying_matrix(), madness::MP2::make_Uphi0(), madness::TDHF::make_virtuals(), madness::CCPairFunction< T, NDIM >::make_xy_u(), madness::EigSolver< T, NDIM >::matrix_element(), madness::Solver< T, NDIM >::matrix_exponential(), madness::Localizer::matrix_exponential(), matrix_exponential(), matrix_inner(), madness::AtomicBasisSet::modify_dmat_psp(), moments(), madness::MP3::mp3_test(), madness::EigSolver< T, NDIM >::multi_solve(), QuasiNewton::new_search_direction(), madness::QuasiNewton::new_search_direction(), madness::MolecularOptimizer::new_search_direction2(), Fcwf::norm2(), madness::LRFunctorF12< T, NDIM, LDIM >::norm2(), AnsatzBase::normalize(), madness::FunctionImpl< T, NDIM >::NScoeffs2values(), nuclear_anchor_test(), LProjector::operator()(), madness::R_times_arg_div_R::operator()(), madness::NuclearCorrelationFactor::U1_dot_U1_functor::operator()(), madness::harmonic_potential_boxed::operator()(), madness::spherical_box< NDIM >::operator()(), madness::Exchange< T, NDIM >::operator()(), madness::Coulomb< T, NDIM >::operator()(), madness::Nuclear< T, NDIM >::operator()(), madness::Lz< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), madness::LocalPotentialOperator< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), MicroTask1::operator()(), MatrixOperator::operator()(), madness::BSHApply< T, NDIM >::operator()(), MicroTask2::operator()(), madness::RandomizedMatrixDecomposition< T >::Y_former::operator()(), madness::LRFunctorF12< T, NDIM, LDIM >::operator()(), HO_function< NDIM >::operator()(), slater::operator()(), gaussian::operator()(), madness::LowRankFunction< T, NDIM, LDIM >::optimize(), madness::MolecularOptimizer::optimize_conjugate_gradients(), madness::MolecularOptimizer::optimize_quasi_newton(), ortho3(), ortho5(), MiniDFT::orthogonalize(), orthogonalize(), madness::Zcis::orthonormalize(), orthonormalize_fock(), orthonormalize_symmetric(), madness::TDHF::oscillator_strength_length(), madness::TDHF::oscillator_strength_velocity(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), madness::PNO::pno_compress(), print_info(), madness::EigSolver< T, NDIM >::print_matrix_elements(), print_stats(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), madness::CCPairFunction< T, NDIM >::project_out_decomposed(), projector_external_dof(), madness::MolecularOptimizer::projector_external_dof(), propagate(), px_func(), py_func(), pz_func(), Q3(), madness::Solver< T, NDIM >::Q3(), madness::SVDTensor< T >::recompute_from_range(), madness::SRConf< T >::reconstruct(), madness::TensorTrain< T >::reconstruct(), reconstruct_psi(), remove_external_dof(), madness::MolecularOptimizer::remove_external_dof(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::Convolution1D< Q >::rnlij(), madness::Molecule::rotate(), s_func(), madness::OEP::selftest(), madness::Localizer::separate_core_valence(), show_norms(), madness::EigSolver< T, NDIM >::solve(), madness::SCF::solve(), madness::Nemo::solve_cphf(), su_complex(), madness::PNO::t_solve(), TENSOR_RESULT_TYPE(), test2(), Test7(), test_adaptive_tree(), test_apply(), test_arithmetic(), test_cholesky(), test_combined_operators(), madness::Znemo::test_compute_current_density(), test_consolidate(), test_construction_optimization(), test_converged_function(), test_convergence(), test_conversion(), test_convolution(), test_coulomb(), madness::Diamagnetic_potential_factor::test_factor(), test_full_rank_functor(), test_gelss(), test_gesv(), test_hartree_product(), test_he_potential(), test_inner(), test_integration(), test_inverse(), test_Kcommutator(), test_kinetic(), madness::Znemo::test_landau_wave_function(), test_load_store(), test_lowrank_function(), test_modified(), test_molecular_grid(), test_multiply(), test_multiply_with_f12(), test_norm(), test_operator_apply(), test_partial_inner(), test_partial_inner_3d(), test_partial_inner_6d(), test_projector(), test_projector_outer(), test_Q12_projector(), test_qr(), test_recursive_application(), test_rr_cholesky(), test_scalar_multiplication(), madness::Diamagnetic_potential_factor::test_scalar_potentials(), test_slater_exchange(), test_swap_particles(), test_syev(), test_sygv(), test_tight_diffuse(), test_transformations(), test_two_scale_coefficients(), test_U_el(), madness::Znemo::test_U_potentials(), test_vector_composite(), test_XCOperator(), madness::SRConf< T >::transform(), transform(), transform_dir(), madness::PNO::transform_pairs(), madness::TensorTrain< T >::truncate(), madness::TensorTrain< T >::two_mode_representation(), madness::Localizer::undo_rotation(), madness::NonlinearSolverND< NDIM >::update(), madness::XNonlinearSolver< T, C, Alloc >::update(), madness::PNO::update_pno(), madness::FunctionImpl< T, NDIM >::values2NScoeffs(), and madness::LowRankFunctionFactory< T, NDIM, LDIM >::Yformer().
Tensor< TENSOR_RESULT_TYPE(T,R) > madness::inner | ( | World & | world, |
const Function< T, NDIM > & | f, | ||
const std::vector< Function< R, NDIM > > & | g | ||
) |
Computes the inner product of a function with a function vector - q(i) = inner(f,g[i])
References compress(), f, madness::WorldTaskQueue::fence(), madness::WorldGopInterface::fence(), g, madness::World::gop, PROFILE_BLOCK, madness::Tensor< T >::ptr(), R, madness::WorldGopInterface::sum(), T(), madness::World::taskq, and TENSOR_RESULT_TYPE().
Tensor< TENSOR_RESULT_TYPE(T,R) > madness::inner | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | f, | ||
const std::vector< Function< R, NDIM > > & | g | ||
) |
Computes the element-wise inner product of two function vectors - q(i) = inner(f[i],g[i])
References compress(), f, madness::WorldTaskQueue::fence(), madness::WorldGopInterface::fence(), g, madness::World::gop, m, MADNESS_CHECK, PROFILE_BLOCK, madness::Tensor< T >::ptr(), R, madness::WorldGopInterface::sum(), T(), madness::World::taskq, and TENSOR_RESULT_TYPE().
Function<TENSOR_RESULT_TYPE(T, R), NDIM> madness::innerXX | ( | const Function< T, LDIM > & | f, |
const Function< R, KDIM > & | g, | ||
const std::array< int, CDIM > | v1, | ||
const std::array< int, CDIM > | v2, | ||
int | task = 0 |
||
) |
Computes the partial scalar/inner product between two functions, returns a low-dim function.
syntax similar to the inner product in tensor.h e.g result=inner<3>(f,g),{0},{1}) : r(x,y) = int f(x1,x) g(y,x1) dx1
[in] | task | 0: everything, 1; prepare only (fence), 2: work only (no fence), 3: finalize only (fence) |
std::vector<Function<TENSOR_RESULT_TYPE(T, R), NDIM> > madness::innerXX | ( | const Function< T, LDIM > & | f, |
const std::vector< Function< R, KDIM >> & | vg, | ||
const std::array< int, CDIM > | v1, | ||
const std::array< int, CDIM > | v2, | ||
int | task = 0 |
||
) |
Computes the partial scalar/inner product between two functions, returns a low-dim function.
syntax similar to the inner product in tensor.h e.g result=inner<3>(f,g),{0},{1}) : r(x,y) = int f(x1,x) g(y,x1) dx1
[in] | task | 0: everything, 1; prepare only (fence), 2: work only (no fence), 3: finalize only (fence) |
References change_tree_state(), madness::FunctionFactory< T, NDIM >::empty(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), f, madness::WorldGopInterface::fence(), g, madness::FunctionImpl< T, NDIM >::get_coeffs(), madness::World::gop, madness::FunctionFactory< T, NDIM >::k(), MADNESS_CHECK, NDIM, madness::FunctionFactory< T, NDIM >::nofence(), nonstandard, nonstandard_after_apply, R, madness::FunctionImpl< T, NDIM >::reconstruct(), reconstructed, madness::WorldGopInterface::set_forbid_fence(), madness::World::size(), T(), task(), TENSOR_RESULT_TYPE(), and madness::FunctionFactory< T, NDIM >::thresh().
Referenced by inner().
DistributedMatrix<T> madness::interleave_rows | ( | const DistributedMatrix< T > & | a, |
const DistributedMatrix< T > & | b | ||
) |
Generates a distributed matrix with rows of a
and b
interleaved.
I.e., the even rows of the result will be rows of a
, and the odd rows those of b
.
The matrices a and b must have the same dimensions and be identically distributed. The result will have a doubled column dimension and column tile size. The row dimension is unchanged.
[in] | a | The matrix providing even rows of the result |
[in] | b | The matrix providing odd rows of the result |
template Tensor<double_complex> madness::inverse | ( | const Tensor< double_complex > & | A | ) |
invert general square matrix A
References a, copy(), getrf_(), getri_(), mask_info(), madness::Tensor< T >::ptr(), and TENSOR_ASSERT.
Referenced by madness::projector_irrep::apply_symmetry_operators(), orthonormalize_cd(), madness::PNO::orthonormalize_cholesky(), orthonormalize_rrcd(), madness::Molecule::symmetrize_and_identify_point_group(), and test_inverse().
bool madness::is_collected | ( | const std::vector< CCPairFunction< T, NDIM >> & | other | ) |
References madness::CCPairFunction< T, NDIM >::is_collected().
Referenced by madness::CCPairFunction< T, NDIM >::collect_same_types(), and test_consolidate().
|
inline |
References madness::detail::thread_tag_accessor(), and ThreadTag_MADNESS.
Referenced by madness::DQueue< T >::push_back(), and madness::DQueue< T >::push_front().
bool madness::is_same_tensor_type | ( | const GenTensor< R > & | rhs, |
const GenTensor< Q > & | lhs | ||
) |
Referenced by outer().
Exchange<double,3>::ExchangeImpl madness::junkjunkjunk | ( | World & | world, |
const SCF * | calc, | ||
const int | ispin | ||
) |
Solves non-linear equation using KAIN (returns coefficients to compute next vector)
The Krylov-accelerated inexact-Newton method employs directional derivatives to estimate the Jacobian in the subspace and separately computes updates in the subspace and its complement.
We wish to solve the non-linear equations where and are vectors of the same dimension (e.g., consider both being MADNESS functions).
Define the following matrices and vector (with and denoting previous iterations in the Krylov subspace and the current iteration):
The subspace equation is of dimension (assuming iterations are indexed from zero) and is given by
The interior and exterior updates may be combined into one simple expression as follows. First, define an additional element of the solution vector
and then the new vector (guess for next iteration) is given by
To employ the solver, each iteration
[in] | Q | The matrix of inner products between subspace vectors and residuals. |
[in] | rcond | Threshold for discarding small singular values in the subspace equations. |
References A(), b, c, gelss(), L, m, Q(), and T().
Referenced by check_linear_dependence(), main(), madness::NonlinearSolverND< NDIM >::update(), madness::XNonlinearSolver< T, C, Alloc >::update(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), and madness::SCF::update_subspace().
void madness::legendre_polynomials | ( | double | x, |
long | order, | ||
double * | p | ||
) |
Evaluate the Legendre polynomials up to the given order at x in [-1,1].
p should be an array of order+1 elements.
Referenced by gauss_legendre_numeric(), and legendre_scaling_functions().
void madness::legendre_scaling_functions | ( | double | x, |
long | k, | ||
double * | p | ||
) |
Evaluate the first k Legendre scaling functions.
p should be an array of k elements.
References k, legendre_polynomials(), p(), and phi_norms.
Referenced by madness::FunctionCommonData< T, NDIM >::_init_quadrature(), madness::FunctionImpl< T, NDIM >::eval_cube(), madness::GenericConvolution1D< Q, opT >::Shmoo::operator()(), madness::FunctionImpl< T, NDIM >::phi_for_mul(), and madness::GaussianConvolution1D< Q >::rnlp().
void madness::load_balance | ( | const real_function_6d & | f, |
const bool | leaf | ||
) |
do some load-balancing
[in] | f | the function we want to distribute evenly |
[in] | leaf | if true: weigh leaf nodes only; if false: weigh internal nodes only |
References madness::LoadBalanceDeux< NDIM >::add_tree(), f, madness::LoadBalanceDeux< NDIM >::load_balance(), and madness::FunctionDefaults< NDIM >::redistribute().
Referenced by converge(), madness::MP2::increment(), propagate(), and madness::MP2::solve_residual_equations().
void madness::load_coeffs | ( | World & | world, |
const char * | dir | ||
) |
Collective routine to load and cache twoscale & autorrelation coefficients.
Only process rank 0 will access the files.
References _cread, autocorr_filename, madness::WorldGopInterface::broadcast(), cache, dir, madness::twoscale_cache_class::g0, madness::twoscale_cache_class::g1, madness::World::gop, madness::twoscale_cache_class::h0, madness::twoscale_cache_class::h1, k, kmax, kmax_autoc, kread, loaded, madness::Tensor< T >::ptr(), madness::World::rank(), read_data(), read_twoscale(), and twoscale_filename.
Referenced by startup().
void madness::load_function | ( | World & | world, |
std::vector< Function< T, NDIM > > & | f, | ||
const std::string | name | ||
) |
load a vector of functions
References f, name(), print(), and madness::World::rank().
Referenced by madness::Zcis::compare_to_file(), madness::PNO::load_pnos(), main(), madness::TDHF::make_virtuals(), test_adaptive_tree(), and test_multiply().
void madness::load_quadrature | ( | World & | world, |
const char * | dir | ||
) |
Collective routine to pre-load and cache the quadrature points and weights.
Only process rank 0 will access the file.
References madness::WorldGopInterface::broadcast(), data_is_read, dir, madness::WorldGopInterface::fence(), filename, madness::World::gop, max_npt, points, madness::World::rank(), read_data(), and weights.
Referenced by startup().
|
static |
References lookup_name(), make_func(), and name().
|
static |
|
static |
References name().
Referenced by lookup_func().
std::string madness::lowercase | ( | const std::string & | s | ) |
Referenced by create_nuclear_correlation_factor(), symbol_to_atomic_number(), and symbol_to_atomic_number().
template void madness::lq | ( | Tensor< double_complex > & | A, |
Tensor< double_complex > & | L | ||
) |
compute the LQ decomposition of the matrix A = L Q
LQ decomposition.
[in,out] | A | on entry the (n,m) matrix to be decomposed on exit the Q matrix |
[out] | R | the (n,n) matrix L (square form) |
References lq_result(), m, R, and TENSOR_ASSERT.
Referenced by test_qr().
template void madness::lq_result | ( | Tensor< double > & | A, |
Tensor< double > & | R, | ||
Tensor< double > & | tau, | ||
Tensor< double > & | work, | ||
bool | do_qr | ||
) |
template void madness::lq_result | ( | Tensor< double_complex > & | A, |
Tensor< double_complex > & | R, | ||
Tensor< double_complex > & | tau, | ||
Tensor< double_complex > & | work, | ||
bool | do_qr | ||
) |
void madness::lq_result | ( | Tensor< T > & | A, |
Tensor< T > & | R, | ||
Tensor< T > & | tau, | ||
Tensor< T > & | work, | ||
bool | do_qr | ||
) |
compute the LQ decomposition of the matrix A = L Q
LQ decomposition.
[in,out] | A | on entry the (n,m) matrix to be decomposed on exit the Q matrix |
[in,out] | R | the (n,n) matrix L (square form) |
[in] | do_qr | do QR instead of LQ |
References A(), geqrf_(), k, m, mask_info(), orgqr_(), madness::Tensor< T >::ptr(), R, madness::BaseTensor::size(), T(), and TENSOR_ASSERT.
Referenced by lq(), qr(), and madness::TensorTrain< T >::truncate().
int madness::main | ( | int | argc, |
char ** | argv | ||
) |
References SafeMPI::COMM_WORLD, madness::WorldGopInterface::fence(), finalize(), madness::World::gop, initialize(), print(), madness::World::rank(), madness::FunctionDefaults< NDIM >::set_k(), smalltest, and startup().
Referenced by main().
std::vector<atom_information<3> > madness::make_atom_vec | ( | const Molecule & | molecule, |
double | R1_, | ||
double | R2_ | ||
) |
Creates vector of atom_information for the given molecule
[in] | molecule | the molecule |
[out] | the vector containing the atom_information for each atom in the molecule |
References madness::atom_information< NDIM >::charge, madness::atom_information< NDIM >::coord, madness::Molecule::get_atoms(), molecule, madness::atom_information< NDIM >::R1, madness::atom_information< NDIM >::R2, and slater_radius().
Referenced by madness::ACParameters< NDIM >::initialize().
double madness::make_exp | ( | double | x | ) |
|
static |
References func().
Referenced by lookup_func().
double madness::make_log | ( | double | x | ) |
References RHOMIN.
Referenced by madness::smooth< T, NDIM >::make_explog(), and madness::smooth< T, NDIM >::smooth_density().
void madness::make_nonstandard | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Generates non-standard form of a vector of functions.
References change_tree_state(), nonstandard, PROFILE_BLOCK, and v.
Referenced by apply().
void madness::make_redundant | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
change tree_state of a vector of functions to redundant
References change_tree_state(), PROFILE_BLOCK, redundant, and v.
Referenced by madness::FunctionImpl< T, NDIM >::erase(), and partial_mul().
Function<T,NDIM> madness::map_and_mirror | ( | const Function< T, NDIM > & | f, |
const std::vector< long > & | map, | ||
const std::vector< long > & | mirror, | ||
bool | fence = true |
||
) |
This is replaced with mirror(map(f)), optional fence.
first map then mirror! mirror is similar to mapdim, but maps from x to -x, y to -y, and so on Example: mirror a 3d function on the xy plane: mirror={1,1,-1} Example: c4 rotation of a 3d function around the z axis: x->y, y->-x, z->z: map(1,0,2); mirror(-1,1,1)
[in] | map | array holding dimensions |
[in] | mirror | array of -1 and 1, corresponding to mirror or not |
References f, madness::Function< T, NDIM >::map_and_mirror(), mirror(), and PROFILE_FUNC.
Referenced by madness::pg_operator::operator()().
Function<T,NDIM> madness::mapdim | ( | const Function< T, NDIM > & | f, |
const std::vector< long > & | map, | ||
bool | fence = true |
||
) |
Generate a new function by reordering dimensions ... optional fence.
You provide an array of dimension NDIM that maps old to new dimensions according to
Works in either scaling function or wavelet basis.
Would be easy to modify this to also change the procmap here if desired but presently it uses the same procmap as f.
References f, madness::Function< T, NDIM >::mapdim(), and PROFILE_FUNC.
Referenced by swap_particles().
|
static |
References lo, mask1(), and user_to_sim().
Referenced by run(), Calculation::set_protocol(), and madness::SCF::set_protocol().
|
static |
Referenced by cholesky(), geev(), gelss(), geqp3_result(), gesv(), ggev(), inverse(), lq_result(), orgqr(), rr_cholesky(), svd(), svd_result(), syev(), and sygv().
|
static |
DistributedMatrix<T> madness::matrix_inner | ( | const DistributedMatrixDistribution & | d, |
const std::vector< Function< T, NDIM > > & | f, | ||
const std::vector< Function< T, NDIM > > & | g, | ||
bool | sym = false |
||
) |
References A(), d(), f, g, m, MADNESS_ASSERT, matrix_inner(), P, and PROFILE_FUNC.
void madness::matrix_inner | ( | DistributedMatrix< T > & | A, |
const std::vector< Function< T, NDIM > > & | f, | ||
const std::vector< Function< T, NDIM > > & | g, | ||
bool | sym = false |
||
) |
References f, g, m, MADNESS_ASSERT, and P.
Referenced by madness::SCF::analyze_vectors(), madness::GTHPseudopotential< Q >::apply_potential(), madness::projector_irrep::apply_symmetry_operators(), madness::Solver< T, NDIM >::build_fock_matrix(), Calculation::calc_optimal_coeffs(), madness::Zcis::canonicalize(), madness::TDHF::canonicalize(), madness::LowRankFunction< T, NDIM, LDIM >::check_orthonormality(), madness::PNO::check_orthonormality(), madness::PNO::compute_cispd_correction_es(), madness::PNO::compute_cispd_correction_gs(), madness::PNO::compute_cispd_fluctuation_matrix(), madness::Nemo::compute_cphf_parallel_term(), madness::PNO::compute_fluctuation_matrix(), madness::Nemo::compute_fock_matrix(), compute_fock_matrix(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), madness::MP2::compute_gQf(), madness::PNO::compute_projected_mp2_energies(), madness::F12Potentials::compute_regularized_fluctuation_matrix(), madness::F12Potentials::compute_uijab_integrals(), madness::Znemo::compute_vmat(), madness::F12Potentials::compute_xyab_integrals(), diag_and_transform(), madness::SCF::diag_fock_matrix(), distributed_localize_PM(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), MiniDFT::doit(), doit(), exchange_anchor_test(), exchange_anchor_test(), fixphases(), hamiltonian_matrix(), madness::Znemo::hcore_guess(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), initial_guess(), inner(), madness::CCPairFunction< T, NDIM >::inner_internal(), madness::Znemo::iterate(), madness::OEP::iterate(), iterate(), madness::PNO::iterate_pairs_internal(), madness::SCF::kinetic_energy_matrix(), madness::Kinetic< T, NDIM >::kinetic_energy_matrix(), MiniDFT::kinetic_energy_matrix(), madness::LowRankFunction< T, NDIM, LDIM >::l2error(), Calculation::load_mos(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), madness::TDHF::make_cis_matrix(), madness::SCF::make_fock_matrix(), madness::TDHF::make_guess_from_initial_diagonalization(), make_kinetic_matrix(), madness::Solver< T, NDIM >::make_kinetic_matrix(), matrix_inner(), madness::LowRankFunction< T, NDIM, LDIM >::norm2(), madness::Coulomb< T, NDIM >::operator()(), madness::Nuclear< T, NDIM >::operator()(), madness::Lz< T, NDIM >::operator()(), madness::LocalPotentialOperator< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), madness::Projector< T, NDIM >::operator()(), MyDerivativeOperator< T, NDIM >::operator()(), madness::Exchange< T, NDIM >::operator()(), madness::DerivativeOperator< T, NDIM >::operator()(), BoysLocalization::operator()(), orth(), madness::LowRankFunction< T, NDIM, LDIM >::orthonormalize(), orthonormalize(), madness::NemoBase::orthonormalize(), orthonormalize(), madness::Solver< T, NDIM >::orthonormalize(), madness::SCF::orthonormalize(), orthonormalize_canonical(), orthonormalize_cd(), madness::PNO::orthonormalize_cholesky(), orthonormalize_rrcd(), orthonormalize_symmetric(), madness::Solver< T, NDIM >::print_fock_matrix_eigs(), madness::Solver< T, NDIM >::print_potential_matrix_eigs(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), madness::MolecularOrbitals< T, NDIM >::project_ao(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::SCF::restart_aos(), run(), madness::SCF::save_mos(), madness::MolecularOrbitals< T, NDIM >::save_restartaodata(), madness::Solver< T, NDIM >::solve(), madness::Nemo::solve(), madness::SCF::solve(), test_inner(), test_orthogonalization(), test_projector(), test_swap_particles(), and madness::SCF::twoint().
Tensor< TENSOR_RESULT_TYPE(T,R) > madness::matrix_inner | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | f, | ||
const std::vector< Function< R, NDIM > > & | g, | ||
bool | sym = false |
||
) |
Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j])
For complex types symmetric is interpreted as Hermitian.
The current parallel loop is non-optimal but functional.
References compress(), f, madness::WorldGopInterface::fence(), g, get_impl(), madness::World::gop, madness::FunctionImpl< T, NDIM >::inner_local(), madness::Tensor< T >::ptr(), R, madness::WorldGopInterface::sum(), T(), and TENSOR_RESULT_TYPE().
Tensor< TENSOR_RESULT_TYPE(T,R) > madness::matrix_inner_old | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | f, | ||
const std::vector< Function< R, NDIM > > & | g, | ||
bool | sym = false |
||
) |
Computes the matrix inner product of two function vectors - q(i,j) = inner(f[i],g[j])
For complex types symmetric is interpreted as Hermitian.
The current parallel loop is non-optimal but functional.
References compress(), conj(), f, madness::WorldGopInterface::fence(), g, madness::World::gop, m, MADNESS_ASSERT, PROFILE_BLOCK, madness::Tensor< T >::ptr(), R, madness::WorldGopInterface::sum(), T(), and TENSOR_RESULT_TYPE().
Referenced by test_inner().
std::vector<std::vector<Function<TENSOR_RESULT_TYPE(T, R), NDIM> > > madness::matrix_mul_sparse | ( | World & | world, |
const std::vector< Function< R, NDIM > > & | f, | ||
const std::vector< Function< R, NDIM > > & | g, | ||
double | tol, | ||
bool | fence = true , |
||
bool | symm = false |
||
) |
Outer product of a vector of functions with a vector of functions using sparsity.
T | type parameter for first factor |
R | type parameter for second factor |
NDIM | dimension of first and second factors |
world | the world |
f | first vector of functions |
g | second vector of functions |
tol | threshold for multiplication |
fence | force fence (will always fence if necessary) |
symm | if true, only compute f(i) * g(j) for j<=i |
References f, madness::WorldGopInterface::fence(), g, madness::World::gop, PROFILE_BLOCK, reconstruct(), and vmulXX().
Function<T,NDIM> madness::mirror | ( | const Function< T, NDIM > & | f, |
const std::vector< long > & | mirrormap, | ||
bool | fence = true |
||
) |
Generate a new function by mirroring within the dimensions .. optional fence.
similar to mapdim
[in] | mirror | array with -1 and 1, corresponding to mirror this dimension or not |
References f, madness::Function< T, NDIM >::mirror(), and PROFILE_FUNC.
Referenced by map_and_mirror(), madness::FunctionImpl< T, NDIM >::map_and_mirror(), and madness::pg_operator::operator()().
|
inline |
|
inlinestatic |
References a, b, c, and mTxm_reference().
void madness::mTxm | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
T *MADNESS_RESTRICT | c, | ||
const T * | a, | ||
const T * | b | ||
) |
Matrix += Matrix transpose * matrix ... MKL interface version.
Does C=C+AT*B
References a, b, c, madness::cblas::gemm(), madness::cblas::NoTrans, T(), and madness::cblas::Trans.
Referenced by fast_transform(), inner_result(), and main().
void madness::mTxmq | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
cT *MADNESS_RESTRICT | c, | ||
const aT * | a, | ||
const bT * | b, | ||
long | ldb = -1 |
||
) |
References a, b, c, and mTxmq_reference().
void madness::mTxmq | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
T *MADNESS_RESTRICT | c, | ||
const T * | a, | ||
const T * | b, | ||
long | ldb = -1 |
||
) |
Matrix = Matrix transpose * matrix ... MKL interface version.
Does C=AT*B
whereas mTxm does C=C+AT*B.
ldb
is the last dimension of b in C storage (the leading dimension in fortran storage). It is here to accomodate multiplying by a matrix stored with ldb>dimj
which happens in madness when transforming with low rank matrices. A matrix in dense storage has ldb=dimj
which is the default for backward compatibility.
References a, b, c, madness::cblas::gemm(), MADNESS_ASSERT, madness::cblas::NoTrans, T(), and madness::cblas::Trans.
Referenced by madness::SeparatedConvolution< Q, NDIM >::apply_transformation(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation2(), fast_transform(), main(), timer(), and trantimer().
void madness::mTxmq_padding | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
long | ext_b, | ||
cT * | c, | ||
const aT * | a, | ||
const bT * | b | ||
) |
References a, b, c, k, and malloc().
Referenced by madness::SeparatedConvolution< Q, NDIM >::apply_transformation(), and fast_transform().
void madness::mTxmq_reference | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
cT *MADNESS_RESTRICT | c, | ||
const aT * | a, | ||
const bT * | b, | ||
long | ldb = -1 |
||
) |
Matrix = Matrix transpose * matrix ... slow reference implementation.
This routine does C=AT*B
whereas mTxm does C=C+AT*B.
ldb
is the last dimension of b in C storage (the leading dimension in fortran storage). It is here to accomodate multiplying by a matrix stored with ldb>dimj
which happens in madness when transforming with low rank matrices. A matrix in dense storage has ldb=dimj
which is the default for backward compatibility.
References a, b, c, k, and MADNESS_ASSERT.
Referenced by mTxmq().
|
inline |
|
inlinestatic |
References a, b, c, and mTxmT_reference().
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::mul | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right, | ||
bool | fence = true |
||
) |
Same as operator*
but with optional fence and no automatic reconstruction.
References mul_sparse().
Function<TENSOR_RESULT_TYPE(Q,T),NDIM> madness::mul | ( | const Function< T, NDIM > & | f, |
const Q | alpha, | ||
bool | fence = true |
||
) |
Returns new function equal to f(x)*alpha with optional fence.
References alpha, f, mul(), and PROFILE_FUNC.
Function<TENSOR_RESULT_TYPE(Q,T),NDIM> madness::mul | ( | const Q | alpha, |
const Function< T, NDIM > & | f, | ||
bool | fence = true |
||
) |
Returns new function equal to alpha*f(x) with optional fence.
References alpha, f, NDIM, PROFILE_FUNC, Q(), T(), TENSOR_RESULT_TYPE(), and VERIFY_TREE.
Referenced by madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl(), KPeriodicBSHOperator::apply(), apply_potential(), madness::Nemo::compute_all_cphf(), madness::Nemo::compute_cphf_parallel_term(), madness::PNO::compute_fluctuation_matrix(), madness::Nemo::compute_fock_matrix(), madness::F12Potentials::compute_fQc_integrals_ij(), madness::Zcis::compute_potentials(), madness::F12Potentials::compute_regularized_fluctuation_matrix(), madness::PNO::compute_V_aj_i(), cross(), madness::CCPairFunction< T, NDIM >::dirac_convolution_decomposed(), dot(), DF::exchange(), fixphases(), madness::Nemo::hessian(), inner_func(), DF::iterate(), madness::Nemo::kinetic_energy_potential(), madness::TDHF::make_bra(), madness::Nemo::make_density(), madness::TDHF::make_perturbed_fock_matrix(), molresponseExchange(), mul(), madness::CCConvolutionOperator< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), madness::response_space::operator*(), operator*(), madness::CCPairFunction< T, NDIM >::project_out_op_decomposed(), madness::Nemo::solve(), madness::Nemo::solve_cphf(), test_Kcommutator(), test_math(), and vector_to_PQ().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Multiplies a function against a vector of functions — q[i] = a * v[i].
References a, madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, reconstruct(), v, and vmulXX().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | v, | ||
const unsigned int | blk = 1 , |
||
const bool | fence = true |
||
) |
Multiplies a function against a vector of functions — q[i] = a * v[i].
References a, madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, reconstruct(), v, and vmulXX().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Multiplies two vectors of functions q[i] = a[i] * b[i].
References a, b, madness::WorldGopInterface::fence(), madness::World::gop, mul(), NDIM, PROFILE_BLOCK, q(), R, reconstruct(), T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true , |
||
unsigned int | blk = 1 |
||
) |
Multiplies two vectors of functions q[i] = a[i] * b[i].
References a, b, madness::WorldGopInterface::fence(), madness::World::gop, mul(), NDIM, PROFILE_BLOCK, q(), R, reconstruct(), T(), and TENSOR_RESULT_TYPE().
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::mul_sparse | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right, | ||
double | tol, | ||
bool | fence = true |
||
) |
Sparse multiplication — left and right must be reconstructed and if tol!=0 have tree of norms already created.
References madness::Function< T, NDIM >::get_impl(), madness::Function< T, NDIM >::is_reconstructed(), L, MADNESS_ASSERT, NDIM, PROFILE_FUNC, R, TENSOR_RESULT_TYPE(), madness::Function< T, NDIM >::verify(), VERIFY_TREE, and madness::Function< T, NDIM >::verify_tree().
Referenced by madness::SCF::analyze_vectors(), madness::Solver< T, NDIM >::apply_potential(), madness::GTHPseudopotential< Q >::apply_potential(), MiniDFT::apply_potential(), madness::SCF::apply_potential(), madness::GTHPseudopotential< Q >::apply_potential_simple(), Calculation::calc_optimal_coeffs(), madness::MolecularOrbitals< T, NDIM >::compute_center(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), Calculation::compute_residuals(), madness::F12Potentials::compute_xyab_integrals(), madness::F12Potentials::convolve_with_fU(), madness::F12Potentials::convolve_with_nonlocal_U(), madness::F12Potentials::convolve_with_U(), madness::SCF::initial_guess(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_small_memory(), madness::Localizer::localize_boys(), Calculation::make_reference(), Calculation::make_Upsi(), mul(), BoysLocalization::operator()(), and madness::SCF::twoint().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul_sparse | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | v, | ||
const double | tol, | ||
const bool | fence = true , |
||
const unsigned int | blk = 1 |
||
) |
Multiplies a function against a vector of functions using sparsity of a and v[i] — q[i] = a * v[i].
References a, madness::WorldGopInterface::fence(), madness::World::gop, norm_tree(), PROFILE_BLOCK, reconstruct(), v, and vmulXX().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::mul_sparse | ( | World & | world, |
const Function< T, NDIM > & | a, | ||
const std::vector< Function< R, NDIM > > & | v, | ||
double | tol, | ||
bool | fence = true |
||
) |
Multiplies a function against a vector of functions using sparsity of a and v[i] — q[i] = a * v[i].
References a, madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, reconstruct(), v, and vmulXX().
std::vector<Function<T,NDIM> > madness::multi_to_multi_op_values | ( | const opT & | op, |
const std::vector< Function< T, NDIM > > & | vin, | ||
const bool | fence = true |
||
) |
apply op on the input vector yielding an output vector of functions
[in] | op | the operator working on vin |
[in] | vin | vector of input Functions; needs to be refined to common level! |
References MADNESS_ASSERT, madness::Function< T, NDIM >::multi_to_multi_op_values(), op(), and madness::Function< T, NDIM >::set_impl().
Referenced by madness::XCOperator< T, NDIM >::apply_xc_kernel(), madness::OEP::compute_dcep_correction(), madness::OEP::compute_mrks_correction(), madness::OEP::compute_ocep_correction(), madness::OEP::compute_slater_potential(), and test_multi_to_multi_op().
Function<T,NDIM> madness::multiply | ( | const Function< T, NDIM > | f, |
const Function< T, LDIM > | g, | ||
const int | particle, | ||
const bool | fence = true |
||
) |
multiply a high-dimensional function with a low-dimensional function
[in] | f | NDIM function of 2 particles: f=f(1,2) |
[in] | g | LDIM function of 1 particle: g=g(1) or g=g(2) |
[in] | particle | if g=g(1) or g=g(2) |
References f, madness::WorldGopInterface::fence(), g, madness::Function< T, NDIM >::get_impl(), madness::World::gop, MADNESS_ASSERT, NDIM, reconstructed, redundant, madness::Function< T, NDIM >::set_impl(), and madness::Function< T, NDIM >::world().
Referenced by madness::FunctionImpl< T, NDIM >::assemble_coefficients(), madness::MP3::compute_mp3_ghij(), madness::MP3::compute_mp3_ghij_fast(), madness::MP3::compute_mp3_klmn(), madness::MP3::compute_mp3_klmn_fast(), madness::CCConvolutionOperator< T, NDIM >::operator()(), test_exchange(), test_Kcommutator(), and test_multiply().
|
static |
Referenced by da_ldaop(), and Vdynamic().
|
inline |
|
inlinestatic |
References a, b, c, and mxm_reference().
|
inline |
|
inlinestatic |
References a, b, c, and mxmT_reference().
void madness::mxmT | ( | long | dimi, |
long | dimj, | ||
long | dimk, | ||
T *MADNESS_RESTRICT | c, | ||
const T * | a, | ||
const T * | b | ||
) |
Matrix += Matrix * matrix transpose ... MKL interface version.
Does C=C+A*BT
References a, b, c, madness::cblas::gemm(), madness::cblas::NoTrans, T(), and madness::cblas::Trans.
Referenced by madness::FunctionImpl< T, NDIM >::do_inner_localX(), and inner_result().
References a, and transpose().
STATIC Tensor<double_complex> madness::my_conj_transpose | ( | Tensor< double_complex > | a | ) |
References a, and conj_transpose().
References a, and transpose().
Referenced by test_cholesky(), test_rr_cholesky(), and test_sygv().
STATIC Tensor<float_complex> madness::my_conj_transpose | ( | Tensor< float_complex > | a | ) |
References a, and conj_transpose().
|
inlinestatic |
Sleep or spin for specified number of microseconds.
Wrapper to ensure desired behavior across various platforms.
[in] | us | The number of microseconds. |
References cpu_relax(), cpu_time(), and e().
Referenced by madness::WorldAmInterface::~WorldAmInterface(), madness::ThreadPool::await(), madness::RMI::begin(), madness::RMI::RmiTask::exit(), madness::RMI::RmiTask::process_some(), madness::WorldAmInterface::send(), and madness::MutexWaiter::yield().
|
inline |
References HOLE, MADNESS_CHECK_THROW, MADNESS_EXCEPTION, MIXED, PARTICLE, RESPONSE, and type().
Referenced by madness::Fock< T, NDIM >::add_operator(), assign_calctype(), madness::QCCalculationParametersBase::check_type(), madness::CCConvolutionOperator< T, NDIM >::clear_intermediates(), madness::Gnuplot::db(), madness::Molecule::GeometryParameters::derive_source_type_from_name(), madness::Cloud::do_load(), do_vtk_plots(), madness::Gnuplot::doplot(), AnsatzBase::filename(), madness::WorldProfile::find(), madness::smooth< T, NDIM >::gaussian_smoothing(), get_charge_from_file(), madness::BasisFunctions::guess_virtuals_internal(), madness::CCConvolutionOperator< T, NDIM >::info(), madness::CC2::initialize_singles(), load(), madness::Cloud::load_from_cache(), load_function(), load_function(), madness::ElectronPair::load_pair(), madness::GTHPseudopotential< Q >::load_pseudo_from_file(), madness::Cloud::load_tuple(), lookup_func(), lookup_name(), main(), madness::PoolTaskInterface::make_id(), madness::smooth< T, NDIM >::make_plots(), madness::smooth< T, NDIM >::merge_functions(), madness::CC_vecfunction::name(), madness::CCConvolutionOperator< T, NDIM >::operator()(), operator<<(), p(), madness::MacroTaskPartitioner::partition_tasks(), plot(), plot_plane(), madness::Molecule::position_stream_in_library(), madness::BasisFunctions::predefined_guess(), MatrixOperator::print(), madness::MolecularOrbitals< T, NDIM >::print_cubefiles(), madness::profiling::TaskEvent::print_demangled(), madness::FunctionImpl< T, NDIM >::print_size(), madness::Function< T, NDIM >::print_size(), madness::guessfactory::PolynomialFunctor::read_string(), madness::Molecule::read_structure_from_library(), madness::WorldProfile::recv_stats(), madness::WorldProfile::register_id(), madness::Fock< T, NDIM >::remove_operator(), save(), save_function(), save_function(), show_norms(), madness::SCF::solve(), solve(), madness::CC2::solve_cc2(), madness::Cloud::store_other(), madness::ElectronPair::store_pair(), test_exchange(), test_exchange(), test_kinetic(), test_serialize(), madness::QCCalculationParametersBase::try_setting_user_defined_value(), madness::CCConvolutionOperator< T, NDIM >::update_elements(), and wopen_().
|
inline |
Convenience template for serializing arguments into a new AmArg.
References alloc_am_arg(), serialize_am_args(), and madness::archive::BufferOutputArchive::size().
Referenced by madness::WorldGopInterface::bcast_task(), madness::WorldGopInterface::group_bcast_task(), madness::RemoteReference< T >::reset(), madness::WorldObject< Derived >::send_am(), madness::WorldObject< Derived >::send_task(), madness::WorldTaskQueue::send_task(), madness::FutureImpl< T >::set(), and madness::FutureImpl< T >::set_handler().
|
inlinestatic |
References T().
void madness::nonstandard | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Generates non-standard form of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, reconstruct(), and v.
double madness::norm2 | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v | ||
) |
Computes the 2-norm of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, madness::WorldGopInterface::sum(), and v.
Referenced by Calculation::Calculation(), DipoleVector::DipoleVector(), madness::F12Potentials::F12Potentials(), NuclearVector::NuclearVector(), madness::Solver< T, NDIM >::apply_potential(), madness::MP2::asymmetry(), check(), check_multiplication_table_c2v(), check_operator_multiplications_2d(), check_operator_multiplications_3d(), check_vector(), compare(), compare_calc_and_mos(), madness::NemoBase::compute_kinetic_energy1(), madness::NemoBase::compute_kinetic_energy1a(), Calculation::compute_residuals(), madness::F12Potentials::convolve_with_fU(), madness::TDHF::get_tda_potential(), madness::Solver< T, NDIM >::gram_schmidt(), madness::OEP::iterate(), iterate(), madness::Zcis::iterate(), DF::iterate(), madness::CC2::iterate_lrcc2_pairs(), madness::CC2::iterate_singles(), madness::TDHF::iterate_vectors(), iterate_xy(), madness::Nemo::kinetic_energy_potential(), main(), madness::EigSolver< T, NDIM >::multi_solve(), norm(), madness::response_space::norm2(), madness::X_space::norm2s(), Fcwf::normalize(), AnsatzBase::normalize(), madness::Zcis::normalize(), MatrixOperator::operator()(), print_info(), madness::CCPairFunction< T, NDIM >::print_size(), q_c(), madness::InitParameters::readnw(), madness::OEP::selftest(), SVPESolver::solve(), madness::Nemo::solve(), madness::SCF::solve(), madness::Nemo::solve_cphf(), madness::smooth< T, NDIM >::test_1d(), test_adaptive_tree(), test_add(), TEST_CASE(), test_combined_operators(), test_converged_function(), test_convergence(), test_cross(), madness::Diamagnetic_potential_factor::test_factor(), test_gconv(), test_inner(), test_io(), test_kinetic(), madness::Diamagnetic_potential_factor::test_lz_commutator(), test_math(), test_matrix_mul_sparse(), test_multi_to_multi_op(), test_multiply(), test_projector(), test_projector_outer(), test_Q12_projector(), test_recursive_application(), test_rot(), test_scalar_multiplication(), test_swap_particles(), test_transform(), test_unaryop(), test_vector_composite(), madness::Diamagnetic_potential_factor::test_vector_potentials(), testbsh(), update(), MiniDFT::update(), and madness::Solver< T, NDIM >::update_orbitals().
std::vector<double> madness::norm2s | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v | ||
) |
Computes the 2-norms of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, madness::WorldGopInterface::sum(), and v.
Referenced by madness::TDHF::analyze(), madness::Zcis::compare_to_file(), madness::guessfactory::compute_centroids(), madness::SCF::compute_residual(), madness::Solver< T, NDIM >::compute_rho(), madness::Znemo::do_step_restriction(), madness::SCF::do_step_restriction(), MiniDFT::doit(), doit(), eigenvector_test(), exchange_anchor_test(), exchange_anchor_test(), madness::Zcis::iterate(), madness::TDHF::iterate_vectors(), madness::NemoBase::normalize(), normalize(), normalize2(), Spinor::print_norms(), madness::Solver< T, NDIM >::solve(), madness::Nemo::solve_cphf(), test2(), test_conversion(), and madness::LowRankFunctionFactory< T, NDIM, LDIM >::Yformer().
std::vector<double> madness::norm2s | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const unsigned int | blk = 1 , |
||
const bool | fence = true |
||
) |
Computes the 2-norms of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, madness::WorldGopInterface::sum(), and v.
Tensor<double> madness::norm2s_T | ( | World & | world, |
const std::vector< Function< T, NDIM >> & | v | ||
) |
Computes the 2-norms of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, madness::BaseTensor::size(), madness::WorldGopInterface::sum(), and v.
Referenced by madness::X_space::component_norm2s().
void madness::norm_tree | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Makes the norm tree for all functions in a vector.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
Referenced by madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::FunctionImpl< T, NDIM >::make_redundant_op(), Calculation::make_reference(), mul_sparse(), norm_tree(), madness::FunctionNode< T, NDIM >::set_norm_tree(), and madness::SCF::twoint().
void madness::norm_tree | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true , |
||
unsigned int | blk = 1 |
||
) |
Makes the norm tree for all functions in a vector.
References madness::WorldGopInterface::fence(), madness::World::gop, norm_tree(), PROFILE_BLOCK, and v.
void madness::normalize | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Normalizes a vector of functions — v[i] = v[i].scale(1.0/v[i].norm2())
References madness::WorldGopInterface::fence(), madness::World::gop, norm2s(), PROFILE_BLOCK, scale(), and v.
Referenced by madness::SCF::diag_fock_matrix(), madness::SVDTensor< T >::divide_and_conquer_reduce(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::BasisFunctions::guess_virtual_gaussian_shell(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), Calculation::load_mos(), make_basis(), MiniDFT::makeao(), makeao_slow(), AnsatzBase::normalize(), orth(), madness::SVDTensor< T >::orthonormalize(), orthonormalize(), madness::SCF::orthonormalize(), madness::SVDTensor< T >::orthonormalize_random(), madness::SCF::project(), madness::SCF::project_ao_basis_only(), madness::InitParameters::readnw(), madness::Solver< T, NDIM >::reproject(), madness::SCF::solve(), test_convergence(), update(), MiniDFT::update(), and madness::LowRankFunctionFactory< T, NDIM, LDIM >::Yformer().
|
inline |
Distributed ID inequality comparison operator.
[in] | left | The first key to compare. |
[in] | right | The second key to compare. |
first
or second
of left
and right
are not equal; otherwise false. bool madness::operator!= | ( | const QCCalculationParametersBase & | p1, |
const QCCalculationParametersBase & | p2 | ||
) |
bool madness::madness::operator!= | ( | const ResponseParameters & | p1, |
const ResponseParameters & | p2 | ||
) |
std::vector<CCPairFunction<T,NDIM> > madness::operator* | ( | const double | fac, |
const std::vector< CCPairFunction< T, NDIM > > & | arg | ||
) |
References arg().
Function<TENSOR_RESULT_TYPE(L,R), NDIM> madness::operator* | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right | ||
) |
Multiplies two functions with the new result being of type TensorResultType<L,R>
Using operator notation forces a global fence after each operation but also enables us to automatically reconstruct the input functions as required.
References madness::Function< T, NDIM >::is_on_demand(), madness::Function< T, NDIM >::is_reconstructed(), MADNESS_ASSERT, mul(), and madness::Function< T, NDIM >::reconstruct().
IsSupported< TensorTypeData<Q>, GenTensor<T> >::type madness::operator* | ( | const Q & | x, |
const GenTensor< T > & | t | ||
) |
The class defines tensor op scalar ... here define scalar op tensor.
Vector<T,N> madness::operator* | ( | T | l, |
Vector< U, N > | r | ||
) |
Vector<T,N> madness::operator* | ( | Vector< T, N > | l, |
const Vector< U, N > & | r | ||
) |
Vector<T,N> madness::operator* | ( | Vector< T, N > | l, |
U | r | ||
) |
Function<TENSOR_RESULT_TYPE(L,R), NDIM> madness::operator+ | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right | ||
) |
Adds two functions with the new result being of type TensorResultType<L,R>
Using operator notation forces a global fence after each operation
References add(), madness::Function< T, NDIM >::compress(), gaxpy_oop_reconstructed(), madness::Function< T, NDIM >::is_compressed(), NDIM, madness::Function< T, NDIM >::reconstruct(), VERIFY_TREE, and madness::Function< T, NDIM >::verify_tree().
IsSupported<TensorTypeData<R>, Function<TENSOR_RESULT_TYPE(T,R),NDIM> >::type madness::operator+ | ( | const Function< T, NDIM > & | f, |
R | r | ||
) |
std::vector<Function<T,NDIM> > madness::operator+ | ( | const Function< T, NDIM > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
result[i] = a + b[i]
References gaxpy_oop().
std::vector<CCPairFunction<T,NDIM> > madness::operator+ | ( | const std::vector< CCPairFunction< T, NDIM >> | c1, |
const std::vector< CCPairFunction< T, NDIM > > & | c2 | ||
) |
std::vector<Function<T,NDIM> > madness::operator+ | ( | const std::vector< Function< T, NDIM > > & | lhs, |
const Function< T, NDIM > & | rhs | ||
) |
result[i] = a[i] + b
References gaxpy_oop().
std::vector<Function<T,NDIM> > madness::operator+ | ( | const std::vector< Function< T, NDIM > > & | lhs, |
const std::vector< Function< T, NDIM >> & | rhs | ||
) |
result[i] = a[i] + b[i]
References gaxpy_oop(), and MADNESS_CHECK.
IsSupported<TensorTypeData<R>, Function<TENSOR_RESULT_TYPE(T,R),NDIM> >::type madness::operator+ | ( | R | r, |
const Function< T, NDIM > & | f | ||
) |
Vector<T,N> madness::operator+ | ( | Vector< T, N > | l, |
const Vector< U, N > & | r | ||
) |
Vector<T,N> madness::operator+ | ( | Vector< T, N > | l, |
U | r | ||
) |
std::vector<CCPairFunction<T,NDIM> >& madness::operator+= | ( | std::vector< CCPairFunction< T, NDIM > > & | lhs, |
const CCPairFunction< T, NDIM > & | rhs | ||
) |
std::vector<CCPairFunction<T,NDIM> >& madness::operator+= | ( | std::vector< CCPairFunction< T, NDIM > > & | rhs, |
const std::vector< CCPairFunction< T, NDIM > > & | lhs | ||
) |
std::vector<Function<T,NDIM> > madness::operator+= | ( | std::vector< Function< T, NDIM > > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
References gaxpy(), and MADNESS_CHECK.
Function<TENSOR_RESULT_TYPE(L,R), NDIM> madness::operator- | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right | ||
) |
Subtracts two functions with the new result being of type TensorResultType<L,R>
Using operator notation forces a global fence after each operation
References madness::Function< T, NDIM >::compress(), gaxpy_oop_reconstructed(), madness::Function< T, NDIM >::is_compressed(), NDIM, PROFILE_FUNC, madness::Function< T, NDIM >::reconstruct(), and sub().
IsSupported<TensorTypeData<R>, Function<TENSOR_RESULT_TYPE(T,R),NDIM> >::type madness::operator- | ( | const Function< T, NDIM > & | f, |
R | r | ||
) |
std::vector<Function<T,NDIM> > madness::operator- | ( | const Function< T, NDIM > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
result[i] = a - b[i]
References gaxpy_oop().
std::vector<CCPairFunction<T,NDIM> > madness::operator- | ( | const std::vector< CCPairFunction< T, NDIM >> | c1, |
const std::vector< CCPairFunction< T, NDIM > > & | c2 | ||
) |
std::vector<Function<T,NDIM> > madness::operator- | ( | const std::vector< Function< T, NDIM > > & | lhs, |
const Function< T, NDIM > & | rhs | ||
) |
result[i] = a[i] - b
References gaxpy_oop().
std::vector<Function<T,NDIM> > madness::operator- | ( | const std::vector< Function< T, NDIM > > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
result[i] = a[i] - b[i]
References gaxpy_oop(), and MADNESS_CHECK.
IsSupported<TensorTypeData<R>, Function<TENSOR_RESULT_TYPE(T,R),NDIM> >::type madness::operator- | ( | R | r, |
const Function< T, NDIM > & | f | ||
) |
Vector<T,N> madness::operator- | ( | Vector< T, N > | l, |
const Vector< U, N > & | r | ||
) |
Vector<T,N> madness::operator- | ( | Vector< T, N > | l, |
U | r | ||
) |
std::vector<CCPairFunction<T,NDIM> >& madness::operator-= | ( | std::vector< CCPairFunction< T, NDIM > > & | rhs, |
const std::vector< CCPairFunction< T, NDIM > > & | lhs | ||
) |
std::vector<Function<T,NDIM> > madness::operator-= | ( | std::vector< Function< T, NDIM > > & | lhs, |
const std::vector< Function< T, NDIM > > & | rhs | ||
) |
References gaxpy(), and MADNESS_CHECK.
|
inline |
Overload redirect to std::ostream to be discoverable via ADL.
References madness::operators::operator<<().
std::ostream & madness::operator<< | ( | std::ostream & | os, |
const EnergyType & | en | ||
) |
References HYLLERAAS_ENERGYTYPE, PROJECTED_ENERGYTYPE, and UNKNOWN_ENERGYTYPE.
std::ostream & madness::operator<< | ( | std::ostream & | os, |
const GuessType & | en | ||
) |
std::ostream& madness::operator<< | ( | std::ostream & | os, |
const OpType | type | ||
) |
std::ostream & madness::operator<< | ( | std::ostream & | os, |
const PairType & | en | ||
) |
References ALL_PAIRTYPE, CISPD_PAIRTYPE, MP2_PAIRTYPE, NONE_PAIRTYPE, and UNKNOWN_PAIRTYPE.
std::ostream& madness::operator<< | ( | std::ostream & | os, |
const particle< PDIM > & | p | ||
) |
References p().
std::ostream& madness::operator<< | ( | std::ostream & | os, |
const permutation & | p | ||
) |
References p().
|
inline |
Overload redirect to std::ostream to be discoverable via ADL.
References madness::ProcessKey< Key, Tag >::key(), and madness::ProcessKey< Key, Tag >::proc().
|
inline |
Overload redirect to std::ostream to be discoverable via ADL.
References madness::TaggedKey< Key, Tag >::key().
std::ostream& madness::operator<< | ( | std::ostream & | os, |
const TreeState | treestate | ||
) |
std::ostream& madness::operator<< | ( | std::ostream & | out, |
const Future< T > & | f | ||
) |
Human readable printing of a Future
to a stream.
Stream output operator for a future.
T | The type of future. |
[in,out] | out | The output stream. |
[in] | f | The future. |
T | Description needed. |
[in,out] | The | output stream. |
[in] | f | The future to be output. |
std::ostream& madness::operator<< | ( | std::ostream & | out, |
const Future< void > & | f | ||
) |
Stream output operator for a void
future.
[in,out] | out | The output stream. |
[in] | f | The future. |
std::ostream& madness::operator<< | ( | std::ostream & | out, |
const MadnessException & | e | ||
) |
Enables easy printing of a MadnessException
.
[in,out] | out | Output stream. |
[in] | e | The MadnessException . |
References e().
std::ostream & madness::operator<< | ( | std::ostream & | s, |
const Atom & | atom | ||
) |
References madness::Atom::atomic_number, madness::Atom::q, madness::Atom::x, madness::Atom::y, and madness::Atom::z.
std::ostream& madness::operator<< | ( | std::ostream & | s, |
const AtomicBasis & | c | ||
) |
References c.
std::ostream& madness::operator<< | ( | std::ostream & | s, |
const AtomicBasisFunction & | a | ||
) |
References a.
|
inlinestatic |
References madness::BoundaryConditions< NDIM >::code_as_string(), d(), and NDIM.
std::ostream& madness::operator<< | ( | std::ostream & | s, |
const CoeffTracker< T, NDIM > & | ct | ||
) |
std::ostream& madness::operator<< | ( | std::ostream & | s, |
const ContractedGaussianShell & | c | ||
) |
std::ostream& madness::operator<< | ( | std::ostream & | s, |
const FunctionNode< T, NDIM > & | node | ||
) |
References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::dim(), e(), madness::FunctionNode< T, NDIM >::get_dnorm(), madness::FunctionNode< T, NDIM >::get_norm_tree(), madness::FunctionNode< T, NDIM >::get_snorm(), madness::FunctionNode< T, NDIM >::has_children(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::GenTensor< T >::is_assigned(), madness::detail::norm(), madness::GenTensor< T >::normf(), and madness::GenTensor< T >::rank().
|
inlinestatic |
|
inlinestatic |
References TT_2D, TT_FULL, and TT_TENSORTRAIN.
std::ostream & madness::operator<< | ( | std::ostream & | stream, |
const Slice & | s | ||
) |
|
inline |
Distributed ID equality comparison operator.
[in] | left | The first key to compare. |
[in] | right | The second key to compare. |
first
and second
of left
and right
are equal; otherwise false. bool madness::madness::operator== | ( | const ResponseParameters & | p1, |
const ResponseParameters & | p2 | ||
) |
References madness::QCCalculationParametersBase::to_json().
std::istream & madness::operator>> | ( | std::istream & | is, |
EnergyType & | en | ||
) |
References HYLLERAAS_ENERGYTYPE, MADNESS_EXCEPTION, PROJECTED_ENERGYTYPE, transform(), and UNKNOWN_ENERGYTYPE.
std::istream & madness::operator>> | ( | std::istream & | is, |
GuessType & | en | ||
) |
std::istream & madness::operator>> | ( | std::istream & | is, |
PairType & | en | ||
) |
References ALL_PAIRTYPE, CISPD_PAIRTYPE, MADNESS_EXCEPTION, MP2_PAIRTYPE, NONE_PAIRTYPE, transform(), and UNKNOWN_PAIRTYPE.
std::istream& madness::operator>> | ( | std::istream & | is, |
std::vector< T, A > & | v | ||
) |
inverting the print method from print.h for std::vector TODO: move this where it belongs (into print.h ??)
References c, check_for_inf(), print(), T(), and v.
template void madness::orgqr | ( | Tensor< complex_real4 > & | A, |
const Tensor< complex_real4 > & | tau | ||
) |
template void madness::orgqr | ( | Tensor< double_complex > & | A, |
const Tensor< double_complex > & | tau | ||
) |
reconstruct the orthogonal matrix Q (e.g. from QR factorization)
orgqr generates an M-by-N complex matrix Q with orthonormal columns
[in,out] | A | On entry, the i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by DGEQRF in the first k columns of its array argument A. On exit, the M-by-N matrix Q. |
[in] | tau | TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by DGEQRF. |
which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.
References k, m, mask_info(), orgqr_(), madness::Tensor< T >::ptr(), madness::BaseTensor::size(), T(), TENSOR_ASSERT, and transpose().
void madness::ortho3 | ( | Tensor< T > & | x, |
Tensor< T > & | y, | ||
Tensor< typename Tensor< T >::scalar_type > & | weights, | ||
const double & | thresh | ||
) |
sophisticated version of ortho2
after calling this we will have an optimally rank-reduced representation with the left and right subspaces being bi-orthogonal and normalized; outline of the algorithm:
[in,out] | x | normalized left subspace |
[in,out] | y | normalize right subspace |
[in,out] | weights | weights |
[in] | thresh | truncation threshold |
References _(), std::abs(), madness::Tensor< T >::absmax(), madness::Tensor< T >::clear(), madness::BaseTensor::dim(), e1(), inner(), MADNESS_ASSERT, madness::SRConf< T >::max_sigma(), madness::Tensor< T >::screen(), madness::BaseTensor::size(), svd(), syev(), thresh, wall_time(), and weights.
Referenced by madness::SVDTensor< T >::orthonormalize().
void madness::ortho5 | ( | Tensor< T > & | x1, |
Tensor< T > & | y1, | ||
Tensor< typename Tensor< T >::scalar_type > & | w1, | ||
const Tensor< T > & | x2, | ||
const Tensor< T > & | y2, | ||
const Tensor< typename Tensor< T >::scalar_type > & | w2, | ||
const double & | thresh | ||
) |
specialized version of ortho3
does the same as ortho3, but takes two bi-orthonormal configs as input and saves on the inner product. Result will be written onto the first config
[in,out] | x1 | left subspace, will hold the result on exit |
[in,out] | y1 | right subspace, will hold the result on exit |
[in] | x2 | left subspace, will be accumulated onto x1 |
[in] | y2 | right subspace, will be accumulated onto y1 |
References _(), std::abs(), madness::Tensor< T >::absmax(), madness::Tensor< T >::clear(), copy(), madness::BaseTensor::dim(), e1(), madness::Tensor< T >::emul(), inner(), inner_result(), max, outer(), residual(), s0, madness::Tensor< T >::screen(), svd(), syev(), thresh, transpose(), and wall_time().
Referenced by madness::SRConf< T >::add_SVD().
std::vector<Function<T,NDIM> > madness::orthonormalize | ( | const std::vector< Function< T, NDIM > > & | vf_in | ) |
orthonormalize the vectors
References std::abs(), copy(), matrix_inner(), max, normalize(), Q(), Q2(), transform(), and truncate().
Referenced by madness::SVDTensor< T >::divide_and_conquer_reduce(), iterate(), main(), and run().
std::vector<Function<T,NDIM> > madness::orthonormalize_canonical | ( | const std::vector< Function< T, NDIM > > & | v, |
const double | lindep | ||
) |
convenience routine for canonical routine for symmetric orthonormalization (see e.g. Szabo/Ostlund) overlap matrix is calculated
[in] | the | vector to orthonormalize |
References matrix_inner(), orthonormalize_canonical(), and v.
std::vector<Function<T,NDIM> > madness::orthonormalize_canonical | ( | const std::vector< Function< T, NDIM > > & | v, |
const Tensor< T > & | ovlp, | ||
double | lindep | ||
) |
canonical orthonormalization (see e.g. Szabo/Ostlund)
[in] | the | vector to orthonormalize |
[in] | overlap | matrix |
[in] | lindep | linear dependency threshold relative to largest eigenvalue |
References _(), lo, MADNESS_ASSERT, syev(), transform(), and v.
Referenced by madness::Zcis::make_guess(), madness::LowRankFunction< T, NDIM, LDIM >::orthonormalize(), and orthonormalize_canonical().
std::vector<Function<T,NDIM> > madness::orthonormalize_cd | ( | const std::vector< Function< T, NDIM > > & | v | ) |
convenience routine for cholesky orthonormalization without pivoting
[in] | the | vector to orthonormalize |
[in] | overlap | matrix |
References matrix_inner(), orthonormalize_cd(), and v.
std::vector<Function<T,NDIM> > madness::orthonormalize_cd | ( | const std::vector< Function< T, NDIM > > & | v, |
Tensor< T > & | ovlp | ||
) |
cholesky orthonormalization without pivoting
[in] | the | vector to orthonormalize |
[in] | overlap | matrix, destroyed on return! |
References cholesky(), inverse(), L, transform(), transpose(), and v.
Referenced by orthonormalize_cd().
std::vector<Function<T,NDIM> > madness::orthonormalize_rrcd | ( | const std::vector< Function< T, NDIM > > & | v, |
const double | tol | ||
) |
convenience routine for orthonromalize_cholesky: computes the overlap matrix and then calls orthonromalize_cholesky
[in] | the | vector to orthonormalize |
[in] | tolerance | for numerical rank reduction |
References matrix_inner(), orthonormalize_rrcd(), and v.
std::vector<Function<T,NDIM> > madness::orthonormalize_rrcd | ( | const std::vector< Function< T, NDIM > > & | v, |
Tensor< T > & | ovlp, | ||
const double | tol, | ||
Tensor< integer > & | piv, | ||
int & | rank | ||
) |
[in] | the | vector to orthonormalize |
[in] | overlap | matrix, will be destroyed on return! |
[in] | tolerance | for numerical rank reduction |
[out] | pivoting | vector, no allocation on input needed |
[out] | rank |
References inverse(), L, rr_cholesky(), transform(), transpose(), and v.
Referenced by madness::F12Potentials::compute_hylleraas_f12_energies(), madness::PNO::initialize_pairs(), madness::TDHF::make_guess_from_initial_diagonalization(), madness::LowRankFunction< T, NDIM, LDIM >::orthonormalize(), orthonormalize_rrcd(), and madness::LowRankFunctionFactory< T, NDIM, LDIM >::project().
std::vector<Function<T,NDIM> > madness::orthonormalize_rrcd | ( | const std::vector< Function< T, NDIM > > & | v, |
Tensor< T > | ovlp, | ||
const double | tol | ||
) |
convenience routine for orthonromalize_cholesky: orthonromalize_cholesky without information on pivoting and rank
[in] | the | vector to orthonormalize |
[in] | overlap | matrix |
[in] | tolerance | for numerical rank reduction |
References orthonormalize_rrcd(), and v.
std::vector<Function<T,NDIM> > madness::orthonormalize_symmetric | ( | const std::vector< Function< T, NDIM > > & | v | ) |
convenience routine for symmetric orthonormalization (see e.g. Szabo/Ostlund) overlap matrix is calculated
[in] | the | vector to orthonormalize |
References matrix_inner(), orthonormalize_symmetric(), and v.
std::vector<Function<T,NDIM> > madness::orthonormalize_symmetric | ( | const std::vector< Function< T, NDIM > > & | v, |
const Tensor< T > & | ovlp | ||
) |
symmetric orthonormalization (see e.g. Szabo/Ostlund)
[in] | the | vector to orthonormalize |
[in] | overlap | matrix |
References inner(), syev(), transform(), transpose(), and v.
Referenced by orthonormalize_symmetric(), madness::MolecularOrbitals< T, NDIM >::project_ao(), test_projector(), and test_Q12_projector().
GenTensor<TENSOR_RESULT_TYPE(T,Q)> madness::outer | ( | const GenTensor< T > & | t1, |
const GenTensor< Q > & | t2, | ||
const TensorArgs | final_tensor_args = TensorArgs(-1.0,TT_2D) |
||
) |
outer product of two Tensors, yielding a low rank tensor
do the outer product of two tensors; distinguish these tensortype cases by the use of final_tensor_type
References madness::GenTensor< T >::dim(), madness::BaseTensor::dim(), madness::GenTensor< T >::full_tensor_copy(), madness::GenTensor< T >::get_tensor(), madness::GenTensor< T >::get_tensortrain(), madness::GenTensor< T >::is_full_tensor(), is_same_tensor_type(), madness::GenTensor< T >::is_tensortrain(), k, MADNESS_ASSERT, MADNESS_EXCEPTION, madness::BaseTensor::ndim(), madness::GenTensor< T >::ndim(), outer(), Q(), madness::Tensor< T >::reshape(), madness::BaseTensor::size(), T(), TENSOR_RESULT_TYPE(), TT_2D, TT_FULL, TT_TENSORTRAIN, and weights.
std::enable_if<std::is_base_of<ProjectorBase,projT>::value, OuterProjector<projT,projQ> >::type madness::outer | ( | const projT & | p0, |
const projQ & | p1 | ||
) |
Referenced by madness::Derivative< T, NDIM >::do_diff2b(), madness::SRConf< T >::emul(), QuasiNewton::hessian_update_sr1(), madness::QuasiNewton::hessian_update_sr1(), madness::TwoElectronInterface< T, NDIM >::make_coeff(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::make_sum_coeffs(), madness::FunctionImpl< T, NDIM >::multiply(), madness::SRConf< T >::normf(), madness::FunctionImpl< T, NDIM >::hartree_op< LDIM, leaf_opT >::operator()(), madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::pointwise_multiplier< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local_on_demand< R >::operator()(), ortho5(), outer(), Test7(), test_projector_outer(), and madness::SRConf< T >::trace().
GenTensor<TENSOR_RESULT_TYPE(T,Q)> madness::outer | ( | const Tensor< T > & | lhs2, |
const Tensor< Q > & | rhs2, | ||
const TensorArgs | final_tensor_args | ||
) |
outer product of two Tensors, yielding a low rank tensor
References MADNESS_EXCEPTION, outer(), Q(), T(), TENSOR_RESULT_TYPE(), madness::TensorArgs::thresh, madness::TensorArgs::tt, TT_2D, TT_FULL, and TT_TENSORTRAIN.
TensorTrain<TENSOR_RESULT_TYPE(T,Q)> madness::outer | ( | const TensorTrain< T > & | t1, |
const TensorTrain< Q > & | t2 | ||
) |
computes the outer product of two tensors
result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...)
References copy(), madness::TensorTrain< T >::core, madness::BaseTensor::dim(), k1, k2, madness::BaseTensor::ndim(), Q(), T(), TENSOR_RESULT_TYPE(), and madness::TensorTrain< T >::zero_rank.
void madness::outer_result | ( | const Tensor< T > & | left, |
const Tensor< T > & | right, | ||
Tensor< T > & | result | ||
) |
Outer product ... result(i,j,...,p,q,...) = left(i,k,...)*right(p,q,...)
accumulate into result, no allocation is performed
References madness::TensorIterator< T, Q, R >::_p0, madness::TensorIterator< T, Q, R >::_s0, madness::TensorIterator< T, Q, R >::dimj, madness::Tensor< T >::end(), madness::BaseTensor::ndim(), p(), madness::Tensor< T >::ptr(), madness::TensorIterator< T, Q, R >::reset(), T(), TENSOR_ASSERT, and madness::Tensor< T >::unary_iterator().
Referenced by madness::SRConf< T >::emul(), and outer().
|
inlinestatic |
Return +1 if i is even, -1 if i is odd ... perverse no if-test form.
Referenced by read_data().
std::vector<Function<T,NDIM> > madness::partial_mul | ( | const Function< T, NDIM > | f, |
const std::vector< Function< T, LDIM > > | g, | ||
const int | particle | ||
) |
multiply a high-dimensional function with a low-dimensional function
[in] | f | NDIM function of NDIM dimensions |
[in] | g | LDIM function of LDIM |
[in] | v | dimension indices of f to multiply |
References madness::FunctionImpl< T, NDIM >::change_tree_state(), f, madness::WorldGopInterface::fence(), g, madness::World::gop, make_redundant(), redundant, and madness::FunctionImpl< T, NDIM >::undo_redundant().
Derivative<T,NDIM> madness::periodic_derivative | ( | World & | world, |
int | axis, | ||
int | k = FunctionDefaults<NDIM>::get_k() |
||
) |
Conveinence function returning derivative operator with periodic boundary conditions.
References axis, BC_PERIODIC, and k.
SeparatedConvolution<Q, NDIM> madness::PeriodicBSHOp | ( | World & | world, |
double | mu, | ||
long | k, | ||
double | lo, | ||
double | eps, | ||
Tensor< double > | L | ||
) |
|
inlinestatic |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D.
References BC_PERIODIC, madness::GFit< T, NDIM >::BSHFit(), fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, and madness::Tensor< T >::normf().
Referenced by apply_periodic_bsh().
|
inlinestatic |
Factory function generating separated kernel for convolution with exp(-mu*r)/(4*pi*r) in 3D.
References BC_PERIODIC, madness::GFit< T, NDIM >::BSHFit(), fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), mu, and madness::Tensor< T >::normf().
Referenced by KPeriodicBSHOperator::apply().
SeparatedConvolution<Q, NDIM>* madness::PeriodicBSHOpPtr | ( | World & | world, |
double | mu, | ||
long | k, | ||
double | lo, | ||
double | eps, | ||
Tensor< double > | L | ||
) |
SeparatedConvolution<Q, NDIM> madness::PeriodicCoulombOp | ( | World & | world, |
long | k, | ||
double | lo, | ||
double | eps, | ||
Tensor< double > | L | ||
) |
SeparatedConvolution<Q, NDIM>* madness::PeriodicCoulombOpPtr | ( | World & | world, |
long | k, | ||
double | lo, | ||
double | eps, | ||
Tensor< double > | L | ||
) |
|
inlinestatic |
Factory function generating separated kernel for convolution with 1/r in 3D.
References BC_PERIODIC, madness::GFit< T, NDIM >::CoulombFit(), fit(), madness::FunctionDefaults< NDIM >::get_cell_width(), k, lo, madness::Tensor< T >::max(), and madness::Tensor< T >::normf().
Referenced by madness::Solver< T, NDIM >::apply_hf_exchange(), and madness::Solver< T, NDIM >::apply_hf_exchange4().
|
inlinestatic |
Referenced by check_operator_multiplications_2d().
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
Referenced by check_multiplication_table_c2v(), check_operator_multiplications_3d(), madness::projector_irrep::make_c2_table(), madness::projector_irrep::make_c2h_table(), madness::projector_irrep::make_c2v_table(), madness::projector_irrep::make_d2_table(), madness::projector_irrep::make_d2h_table(), plot_symmetry_operators(), and test_orthogonalization().
|
inlinestatic |
Referenced by check_operator_multiplications_2d(), and plot_symmetry_operators().
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
Referenced by check_multiplication_table_c2v(), check_operator_multiplications_2d(), check_operator_multiplications_3d(), madness::projector_irrep::make_c1_table(), madness::projector_irrep::make_c2_table(), madness::projector_irrep::make_c2h_table(), madness::projector_irrep::make_c2v_table(), madness::projector_irrep::make_ci_table(), madness::projector_irrep::make_cs_table(), madness::projector_irrep::make_d2_table(), madness::projector_irrep::make_d2h_table(), plot_symmetry_operators(), and test_orthogonalization().
|
inlinestatic |
Referenced by check_multiplication_table_c2v(), check_operator_multiplications_2d(), check_operator_multiplications_3d(), madness::projector_irrep::make_c2h_table(), madness::projector_irrep::make_ci_table(), madness::projector_irrep::make_d2h_table(), plot_symmetry_operators(), and test_orthogonalization().
|
inlinestatic |
Referenced by check_operator_multiplications_2d(), and plot_symmetry_operators().
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
Referenced by check_operator_multiplications_2d(), and plot_symmetry_operators().
|
inlinestatic |
|
inlinestatic |
Referenced by madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), madness::Diamagnetic_potential_factor::factor_with_phase(), fixphases(), madness::Diamagnetic_potential_factor::make_fake_orbitals(), read_twoscale(), madness::Gnuplot::test(), test_chin_chen(), test_trotter(), and GaussianGuess< NDIM >::val().
void madness::plot | ( | const std::vector< Function< double, NDIM > > & | vf, |
const std::string & | name, | ||
const std::vector< std::string > & | header | ||
) |
convenience to get plot_plane and plot_cubefile
References name().
Referenced by main(), madness::TDHF::plot(), CalculationParameters::print_info(), and CalculationParameters::read_file().
void madness::plot_along | ( | World & | world, |
trajectory< NDIM > | traj, | ||
const Function< double, NDIM > & | function, | ||
std::string | filename | ||
) |
void madness::plot_along | ( | World & | world, |
trajectory< NDIM > | traj, | ||
double(*)(const Vector< double, NDIM > &) | ff, | ||
std::string | filename | ||
) |
std::enable_if<NDIM==3,void>::type madness::plot_cubefile | ( | World & | world, |
const Function< double, NDIM > & | f, | ||
std::string | filename, | ||
std::vector< std::string > | molecular_info = std::vector<std::string>() , |
||
int | npoints = 100 , |
||
double | zoom = 1.0 |
||
) |
References copy(), f, filename, k, MADNESS_EXCEPTION, madness::Tensor< T >::scale(), and madness::World::size().
void madness::plot_line | ( | const char * | filename, |
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const Function< T, NDIM > & | f | ||
) |
Generates ASCII file tabulating f(r) at npoints along line r=lo,...,hi.
The ordinate is distance from lo
References f, madness::WorldGopInterface::fence(), filename, madness::World::gop, h(), lo, MADNESS_EXCEPTION, NDIM, plot_line_print_value(), madness::World::rank(), and sum().
void madness::plot_line | ( | const char * | filename, |
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const Function< T, NDIM > & | f, | ||
const Function< U, NDIM > & | g | ||
) |
Generates ASCII file tabulating f(r) and g(r) at npoints along line r=lo,...,hi.
The ordinate is distance from lo
References f, madness::WorldGopInterface::fence(), filename, g, madness::World::gop, h(), lo, MADNESS_EXCEPTION, NDIM, plot_line_print_value(), madness::World::rank(), and sum().
void madness::plot_line | ( | const char * | filename, |
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const Function< T, NDIM > & | f, | ||
const Function< U, NDIM > & | g, | ||
const Function< V, NDIM > & | a | ||
) |
Generates ASCII file tabulating f(r), g(r), and a(r) at npoints along line r=lo,...,hi.
The ordinate is distance from lo
References a, f, madness::WorldGopInterface::fence(), filename, g, madness::World::gop, h(), lo, MADNESS_EXCEPTION, NDIM, plot_line_print_value(), madness::World::rank(), and sum().
void madness::plot_line | ( | const char * | filename, |
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const Function< T, NDIM > & | f, | ||
const Function< U, NDIM > & | g, | ||
const Function< V, NDIM > & | a, | ||
const Function< W, NDIM > & | b | ||
) |
Generates ASCII file tabulating f(r), g(r), a(r), b(r) at npoints along line r=lo,...,hi.
The ordinate is distance from lo
References a, b, f, madness::WorldGopInterface::fence(), filename, g, madness::World::gop, h(), lo, NDIM, plot_line_print_value(), madness::World::rank(), and sum().
void madness::plot_line | ( | const char * | filename, |
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const std::vector< Function< T, NDIM >> & | vf | ||
) |
The ordinate is distance from lo.
References f, madness::WorldGopInterface::fence(), filename, madness::World::gop, h(), lo, MADNESS_EXCEPTION, NDIM, madness::World::rank(), and sum().
void madness::plot_line | ( | World & | world, |
const char * | filename, | ||
int | npt, | ||
const Vector< double, NDIM > & | lo, | ||
const Vector< double, NDIM > & | hi, | ||
const opT & | op | ||
) |
Generates ASCII file tabulating f(r) at npoints along line r=lo,...,hi.
The ordinate is distance from lo
References madness::WorldGopInterface::fence(), filename, madness::World::gop, h(), lo, MADNESS_EXCEPTION, NDIM, op(), plot_line_print_value(), madness::World::rank(), and sum().
Referenced by Plotter::dolineplot(), dostuff(), madness::Solver< T, NDIM >::initial_guess(), iterate(), main(), madness::smooth< T, NDIM >::make_plots(), madness::Nemo::make_plots(), SurfaceMoleculeInteraction::make_surfcharge(), SurfaceMoleculeInteraction::perturbed_molecular_pot(), plot(), Calculation::plot_z(), run(), madness::smooth< T, NDIM >::test_1d(), test_apply_push_1d(), test_gconv(), test_plot(), and test_smooth_maxout().
|
inlinestatic |
References f, imag(), real(), and v.
Referenced by DF::make_component_lineplots(), DF::make_component_logplots(), DF::make_density_lineplots(), plot_line(), and Calculation::plot_p().
void madness::plot_plane | ( | World & | world, |
const Function< double, NDIM > & | function, | ||
const std::string | name | ||
) |
References name().
Referenced by madness::TDHF::get_tda_potential(), madness::BasisFunctions::guess_virtuals_internal(), main(), madness::smooth< T, NDIM >::make_plots(), madness::Nemo::make_plots(), madness::CC2::plot(), madness::CCFunction< T, NDIM >::plot(), Spinor::plot(), plot_plane(), and plot_symmetry_operators().
void madness::plot_plane | ( | World & | world, |
const Function< double, NDIM > & | function1, | ||
const Function< double, NDIM > & | function2, | ||
const Function< double, NDIM > & | function3, | ||
const std::string | name | ||
) |
References name(), and plot_plane().
void madness::plot_plane | ( | World & | world, |
const Function< double, NDIM > & | function1, | ||
const Function< double, NDIM > & | function2, | ||
const std::string | name | ||
) |
References name(), and plot_plane().
void madness::plot_plane | ( | World & | world, |
const opT & | op, | ||
const std::string | name, | ||
const PlotParameters | param | ||
) |
References c, f, filename, madness::FunctionDefaults< NDIM >::get_cell_width(), lo, MADNESS_ASSERT, MADNESS_EXCEPTION, name(), NDIM, op(), param, madness::World::rank(), scale(), and madness::World::size().
void madness::plot_plane | ( | World & | world, |
const std::vector< Function< double, NDIM > > & | vfunction, | ||
const std::string | name, | ||
const PlotParameters | param | ||
) |
plot a 2-d slice of a given function and the according MRA structure
the plotting parameters are taken from the input file "input" and its data group "plot", e.g. plotting the xy plane around (0,0,0.7): plot plane x1 x2 zoom 2.0 npoints 100 origin 0.0 0.0 0.7 end
[in] | world | the world |
[in] | vfunction | the function to plot |
[in] | name | the output name |
References c, f, filename, madness::FunctionDefaults< NDIM >::get_cell_width(), lo, MADNESS_ASSERT, MADNESS_EXCEPTION, name(), NDIM, param, madness::World::rank(), scale(), and madness::World::size().
void madness::plot_plane | ( | World & | world, |
const std::vector< Function< double, NDIM > > & | vfunction, | ||
const std::string | name, | ||
const std::string | inputfile = "input" |
||
) |
plot a 2-d slice of a given function and the according MRA structure FIXME: doesn't work for more than 1 rank the plotting parameters are taken from the input file "input" and its data group "plot", e.g. plotting the xy plane around (0,0,0.7): plot plane x1 x2 zoom 2.0 npoints 100 origin 0.0 0.0 0.7 end
[in] | world | the world |
[in] | vfunction | the function to plot |
[in] | name | the output name |
References f, filename, madness::FunctionDefaults< NDIM >::get_cell_width(), lo, MADNESS_ASSERT, MADNESS_EXCEPTION, name(), NDIM, position_stream_to_word(), print(), madness::World::rank(), scale(), and madness::World::size().
void madness::plotdx | ( | const Function< T, NDIM > & | f, |
const char * | filename, | ||
const Tensor< double > & | cell = FunctionDefaults<NDIM>::get_cell() , |
||
const std::vector< long > & | npt = std::vector<long>(NDIM,201L) , |
||
bool | binary = true |
||
) |
Writes an OpenDX format file with a cube/slice of points on a uniform grid.
Collective operation but only process 0 writes the file. By convention OpenDX files end in ".dx" but this choice is up to the user. The binary format is more compact and vastly faster to both write and load but is not as portable.
Now follow some brief tips about how to look at files inside OpenDX.
To view a 1D function file-selector-->import-->plot-->image
.
To view a 2D function as a colored plane file-selector-->import-->autocolor-->image
.
To view a 2D function as a 3D surface file-selector-->import-->rubbersheet-->image
.
To view a 3D function as an isosurface file-selector-->import-->isosurface-->image
.
To select the real/imaginary/absolute value of a complex number insert a compute element after the import.
References c, d(), dxprintvalue(), f, madness::WorldGopInterface::fence(), filename, madness::World::gop, h(), MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, PROFILE_FUNC, madness::Tensor< T >::ptr(), madness::World::rank(), madness::BaseTensor::size(), and T().
Referenced by madness::SCF::do_plots(), Plotter::dovolumeplot(), madness::Solver< T, NDIM >::initial_guess(), main(), madness::Solver< T, NDIM >::solve(), test_plot(), and testPeriodicCoulomb3d().
|
static |
Writes a Povray DF3 format file with a cube of points on a uniform grid.
Collective operation but only process 0 writes the file. By convention Povray files end in ".df3" but this choice is up to the user. The dynamic range of function values is mapped onto [0,1] and values stored in 16-bit fixed precision.
References d(), f, filename, madness::detail::htons_x(), MADNESS_ASSERT, MADNESS_EXCEPTION, madness::Tensor< T >::max(), madness::Tensor< T >::min(), and madness::World::rank().
Referenced by main().
void madness::plotvtk_begin | ( | World & | world, |
const char * | filename, | ||
const Vector< double, NDIM > & | plotlo, | ||
const Vector< double, NDIM > & | plothi, | ||
const Vector< long, NDIM > & | npt, | ||
bool | binary = false |
||
) |
Writes the header information of a VTK file for plotting in an external post-processing package (such as Paraview)
world | World communicator |
filename | String containing the filename to export to |
plotlo | Vector of double values indicating the minimum coordinate to plot to in each dimension |
plothi | Vector of double values indicating the maximum coordinate to plot to in each dimension |
npt | Vector of long integers indicating the number of points to plot in each dimension |
binary | (optional) Boolean indicating whether to print in binary The VTK routines are also designed for SERIAL data, parallel coming... |
This header is templated by the dimension of the data.
To plot with the plotvtk_* routines: plotvtk_begin(...) plotvtk_data(...) plotvtk_data(...) ... plotvtk_end(...)
NOTE: Paraview expects the structured mesh points in a particular order, which is why the LowDimIndexIterator is used...
References f, madness::WorldGopInterface::fence(), filename, madness::World::gop, MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, PROFILE_FUNC, and madness::World::rank().
Referenced by Plotter::dovolumeplot(), and testNavierStokes().
void madness::plotvtk_data | ( | const Function< std::complex< T >, NDIM > & | function, |
const char * | fieldname, | ||
World & | world, | ||
const char * | filename, | ||
const Vector< double, NDIM > & | plotlo, | ||
const Vector< double, NDIM > & | plothi, | ||
const Vector< long, NDIM > & | npt, | ||
bool | binary = false , |
||
bool | plot_refine = false |
||
) |
VTK data writer for complex-valued madness::functions.
The complex-value is written as two reals (a vector from VTK's perspective. The first (X) component is the real part and the second (Y) component is the imaginary part. Set plot_refine=true to get a plot of the refinement levels of the given function.
References madness::WorldGopInterface::barrier(), f, madness::WorldGopInterface::fence(), filename, madness::World::gop, imag(), MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, PROFILE_FUNC, madness::World::rank(), and real().
void madness::plotvtk_data | ( | const Function< T, NDIM > & | function, |
const char * | fieldname, | ||
World & | world, | ||
const char * | filename, | ||
const Vector< double, NDIM > & | plotlo, | ||
const Vector< double, NDIM > & | plothi, | ||
const Vector< long, NDIM > & | npt, | ||
bool | binary = false , |
||
bool | plot_refine = false |
||
) |
VTK data writer for real-valued (not complex) madness::functions.
Set plot_refine=true to get a plot of the refinement levels of the given function.
References madness::WorldGopInterface::barrier(), f, madness::WorldGopInterface::fence(), filename, madness::World::gop, MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, PROFILE_FUNC, and madness::World::rank().
void madness::plotvtk_data | ( | const T & | function, |
const char * | fieldname, | ||
World & | world, | ||
const char * | filename, | ||
const Vector< double, NDIM > & | plotlo, | ||
const Vector< double, NDIM > & | plothi, | ||
const Vector< long, NDIM > & | npt, | ||
bool | binary = false |
||
) |
Generic VTK data writer. Specific type instances of this function are defined for both real and complex valued functions.
function | Function (real or complex) that we wish to export the data of |
fieldname | A string containing the name we wish to refer to this field as in the exported data |
world | World communicator |
filename | String containing the filename to export to |
plotlo | Vector of double values indicating the minimum coordinate to plot to in each dimension |
plothi | Vector of double values indicating the maximum coordinate to plot to in each dimension |
npt | Vector of long integers indicating the number of points to plot in each dimension |
binary | (optional) Boolean indicating whether to print in binary This templated function won't do anything except print a warning message. Specialized versions of this function should be used. |
References MADNESS_EXCEPTION.
Referenced by Plotter::dovolumeplot(), and testNavierStokes().
void madness::plotvtk_end | ( | World & | world, |
const char * | filename, | ||
bool | binary = false |
||
) |
Writes the footer information of a VTK file for plotting in an external post-processing package (such as Paraview)
world | World communicator |
filename | Name of VTK file |
binary | (Optional) Boolean indicating whether to print in binary |
References f, madness::WorldGopInterface::fence(), filename, madness::World::gop, MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, PROFILE_FUNC, and madness::World::rank().
|
inlinestatic |
Referenced by madness::SystolicPMOrbitalLocalize::localize_PM_ij().
|
static |
References MADNESS_ASSERT, and v.
Referenced by madness::Displacements< NDIM >::Displacements(), madness::Vector< T, N >::Vector(), madness::Tensor< T >::allocate(), madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push_op(), madness::Key< NDIM >::break_apart(), DF::end_timer(), END_TIMER(), madness::FunctionCommonData< T, NDIM >::get(), madness::GaussianConvolution1DCache< Q >::get(), madness::WorldObject< Derived >::handler(), madness::WorldObject< Derived >::is_ready(), main(), madness::Displacements< NDIM >::make_disp_periodicsum(), madness::Tensor< T >::operator=(), madness::WorldObject< Derived >::process_pending(), and madness::archive::BufferOutputArchive::store().
std::istream & madness::position_stream | ( | std::istream & | f, |
const std::string & | tag, | ||
bool | rewind = true |
||
) |
References errmsg(), f, and MADNESS_EXCEPTION.
Referenced by main(), madness::DFParameters::read(), madness::Molecule::read(), madness::BasisFunctions::read_basis_from_file(), madness::BasisFunctions::read_contracted_basis_from_file(), madness::ElectronicStructureParams::read_file(), and MolecularEntity::read_file().
std::istream& madness::position_stream_to_word | ( | std::istream & | f, |
const std::string & | tag, | ||
const char | comment, | ||
bool | rewind, | ||
bool | silent | ||
) |
position the input stream to tag, which must be a word (not part of a word)
f | input stream |
tag | the word to look for |
comment | a comment character for (parts of) a line |
rewind | rewind to the beginning of the stream |
silent | throws if not successful, but doesn't print error message |
References errmsg(), f, and MADNESS_EXCEPTION.
Referenced by plot_plane(), madness::Molecule::position_stream_in_library(), and madness::QCCalculationParametersBase::read_internal().
|
inline |
References pow().
Referenced by ncf::operator()().
References madness::detail::helper< T, N >::pow().
|
inline |
|
inline |
|
inline |
References power< 2 >(), and power< 5 >().
|
inline |
References power< 3 >(), and power< 4 >().
|
inline |
|
inline |
|
inline |
|
inline |
References power< 2 >(), and power< 3 >().
Referenced by power< 10 >(), and madness::Polynomial< N >::U2X_spherical().
|
inline |
References power< 2 >(), and power< 3 >().
Referenced by madness::GradientalGaussSlater::Srrr_div_S().
|
inline |
References power< 3 >(), and power< 4 >().
|
inline |
References power< 2 >(), and power< 4 >().
|
inline |
References power< 3 >().
void madness::print | ( | const T & | t, |
const Ts &... | ts | ||
) |
Print items to std::cout
(items separated by spaces) and terminate with a new line.
The first item is printed here so that it isn't preceded by a space.
T | Type of the first item to be printed. |
Ts | Argument pack type for the items to be printed. |
[in] | t | The first item to be printed. |
[in] | ts | The remaining items to be printed in the argument pack. |
References ENDL, print_helper(), and madness::detail::printmutex.
Referenced by madness::AdhocNuclearCorrelationFactor::AdhocNuclearCorrelationFactor(), Calculation::Calculation(), madness::cartesian_grid< NDIM >::cartesian_grid(), madness::DependencyInterface::DependencyInterface(), madness::dftgrid< NDIM >::dftgrid(), EwaldNuclearPotentialFunctor::EwaldNuclearPotentialFunctor(), madness::GaussSlater::GaussSlater(), madness::GFit< T, NDIM >::GFit(), madness::GradientalGaussSlater::GradientalGaussSlater(), GridBuilder::GridBuilder(), madness::LinearSlater::LinearSlater(), MolecularNuclearChargeDensityFunctor::MolecularNuclearChargeDensityFunctor(), MolecularNuclearPotentialFunctor2::MolecularNuclearPotentialFunctor2(), madness::MP2::MP2(), madness::poly4erfc::poly4erfc(), madness::Polynomial< N >::Polynomial(), madness::PseudoNuclearCorrelationFactor::PseudoNuclearCorrelationFactor(), madness::Slater::Slater(), TestBarrier::TestBarrier(), TestSystolicMatrixAlgorithm< T >::TestSystolicMatrixAlgorithm(), TimeBarrier::TimeBarrier(), madness::Zcis::Zcis(), B::~B(), madness::DependencyInterface::~DependencyInterface(), madness::FutureImpl< T >::~FutureImpl(), madness::BSHApply< T, NDIM >::add_coupling_and_levelshift(), madness::detail::RemoteCounterBase::add_ref(), madness::Znemo::analyze(), LProjector::analyze(), madness::TDHF::analyze(), apply(), apply_bsh(), madness::projector_irrep::apply_symmetry_operators(), apply_U_mix(), apply_U_ncf(), madness::MP2::asymmetry(), madness::GFit< T, NDIM >::bsh_fit(), madness::GFit< T, NDIM >::bsh_fit_ndim(), madness::GFit< T, NDIM >::BSHFit(), BSHOperator(), BSHOperatorPtr(), madness::Solver< T, NDIM >::build_fock_matrix(), Calculation::calc_optimal_coeffs(), check(), madness::TDHF::check_consistency(), madness::NemoBase::check_convergence(), madness::MP2::check_core_valence_separation(), madness::Localizer::check_core_valence_separation(), check_err(), check_linear_dependence(), check_multiplication_table_c2v(), check_operator_multiplications_2d(), check_operator_multiplications_3d(), madness::LowRankFunction< T, NDIM, LDIM >::check_orthonormality(), madness::PNO::check_orthonormality(), check_small(), madness::Function< T, NDIM >::check_symmetry(), madness::QCCalculationParametersBase::check_type(), check_vector(), madness::test_output::checkpoint(), compare_calc_and_mos(), madness::Zcis::compare_to_file(), madness::FunctionImpl< T, NDIM >::compress_spawn(), madness::Nemo::compute_all_cphf(), madness::OEP::compute_and_print_final_energies(), madness::Localizer::compute_core_valence_separation_transformation_matrix(), madness::Znemo::compute_current_density(), madness::Znemo::compute_energy(), compute_energy(), compute_energy_simple(), compute_energy_with_U(), compute_frequencies(), madness::MP2::compute_gQf(), madness::Localizer::compute_localization_matrix(), madness::MP3::compute_mp3_cd(), madness::MP3::compute_mp3_ef(), madness::MP3::compute_mp3_ghij(), madness::MP3::compute_mp3_ghij_fast(), madness::MP3::compute_mp3_klmn(), compute_R2f2_psi(), madness::SVDTensor< T >::compute_randomized_svd(), madness::SCF::compute_residual(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), Calculation::compute_residuals(), converge(), converge2s(), TestSystolicMatrixAlgorithm< T >::converged(), madness::GenTensor< T >::convert_inplace(), madness::PotentialManager::core_projection(), create_nuclear_correlation_factor(), madness::Solver< T, NDIM >::csqrt(), madness::Znemo::custom_guess(), madness::DependencyInterface::dec_debug(), madness::TensorTrain< T >::decompose(), madness::QCPropertyInterface::density(), madness::SCF::derivatives(), madness::detail::RemoteCounter::destroy(), madness::Localizer::determine_frozen_orbitals(), madness::SCF::dipole(), dnuclear_anchor_test(), madness::Cloud::do_load(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), madness::SCF::do_step_restriction(), MiniDFT::doit(), doit(), doplot(), eigenvector_test(), energy(), madness::MP2::enforce_core_valence_separation(), madness::CC2::enforce_core_valence_separation(), madness::TDHF::enforce_core_valence_separation(), GygiPot::ESP(), madness::XCfunctional::exc(), exchange_anchor_test(), exchange_anchor_test(), madness::GFit< T, NDIM >::F12Fit(), madness::GFit< T, NDIM >::F12sqFit(), madness::GFit< T, NDIM >::F2GFit(), madness::WorldGopInterface::fence_impl(), madness::GFit< T, NDIM >::FGFit(), fixphases(), TTT::fred(), Mary::galahad(), gauss_legendre_test(), madness::GFit< T, NDIM >::GaussFit(), gen_ce(), generate_G_vectors(), generate_R_vectors(), madness::MP2::get_fock_matrix(), madness::randomgrid< NDIM >::get_grid(), madness::molecular_grid< NDIM >::get_grid(), madness::Znemo::get_initial_orbitals(), madness::QCCalculationParametersBase::get_parameter(), madness::MP2::get_residue(), madness::Nemo::gradient(), madness::Znemo::gradient(), CoreFittingTarget::gradient(), madness::SCF::group_orbital_sets(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_from_file(), madness::BasisFunctions::guess_virtuals_internal(), hartree_product(), madness::Znemo::hcore_guess(), DF::help(), madness::CC2::help(), madness::MP2::help(), madness::Nemo::help(), madness::OEP::help(), madness::PNO::help(), madness::SCF::help(), madness::TDHF::help(), madness::Zcis::help(), madness::Znemo::help(), madness::Nemo::hessian(), madness::DependencyInterface::inc_debug(), madness::MP2::increment(), madness::CCConvolutionOperator< T, NDIM >::init_op(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), initial_guess(), initial_loadbal(), madness::SCFProtocol::initialize(), data< T, NDIM >::initialize(), madness::CC2::initialize_pairs(), madness::CC2::initialize_singles(), inner(), madness::Znemo::iterate(), madness::OEP::iterate(), madness::Zcis::iterate(), iterate(), iterate_excite(), iterate_ground(), madness::CC2::iterate_lrcc2_pairs(), madness::PNO::iterate_pairs_internal(), madness::CC2::iterate_singles(), iterate_xy(), KAIN(), madness::Nemo::kinetic_energy_potential(), madness::LowRankFunction< T, NDIM, LDIM >::l2error(), QuasiNewton::line_search(), madness::QuasiNewton::line_search(), madness::detail::RemoteCounter::load_(), madness::LoadBalanceDeux< NDIM >::load_balance(), load_balance(), madness::Cloud::load_from_cache(), madness::MP2::load_function(), madness::Nemo::load_function(), load_function(), load_function(), madness::SCF::load_mos(), Calculation::load_mos(), madness::CCPair::load_pair(), madness::ElectronPair::load_pair(), madness::OEP::load_restartdata(), loadbal(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), main(), madness::ThreadBase::main(), TestCalculationParameters::make_all_parameter_doubles(), TestCalculationParameters::make_all_parameter_singles(), madness::SCF::make_bsh_operators(), make_dimensions(), DF::make_fermi_potential(), GridBuilder::make_grid(), madness::Zcis::make_guess(), madness::TDHF::make_guess_from_initial_diagonalization(), madness::Solver< T, NDIM >::make_nuclear_charge_density_impl(), madness::Solver< T, NDIM >::make_nuclear_potential(), Calculation::make_reference(), madness::SeparatedConvolution< Q, NDIM >::make_tt_representation(), madness::MP2::make_Uphi0(), makeao(), moments(), madness::MP3::mp3_energy_contribution(), madness::MP3::mp3_energy_contribution_macrotask_driver(), madness::MP3::mp3_test(), madness::QCPropertyInterface::multipole_moment(), madness::QCPropertyInterface::no_cusp_density(), madness::QCPropertyInterface::no_cusp_spindensity(), madness::CCPairFunction< T, NDIM >::norm2(), nuclear_anchor_test(), madness::QCPropertyInterface::nuclear_derivative(), madness::CCPairFunction< T, NDIM >::op_dec_to_dec(), LProjector::operator()(), madness::CompositeFunctorInterface< T, NDIM, MDIM >::operator()(), MicroTask::operator()(), madness::BSHApply< T, NDIM >::operator()(), madness::ParametrizedExchange::operator()(), madness::TwoElectronInterface< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local< R >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local_on_demand< R >::operator()(), BoysLocalization::operator()(), madness::SliceLowRankTensor< T >::operator=(), operator>>(), MySteepestDescent::optimize(), SteepestDescent::optimize(), QuasiNewton::optimize(), madness::SteepestDescent::optimize(), madness::QuasiNewton::optimize(), madness::MolecularOptimizer::optimize_quasi_newton(), madness::Molecule::orient(), orth(), madness::LowRankFunction< T, NDIM, LDIM >::orthonormalize(), madness::Solver< T, NDIM >::orthonormalize(), madness::SCF::orthonormalize(), madness::LBDeuxPmap< NDIM >::owner(), SurfaceMoleculeInteraction::perturbed_molecular_pot(), Foo::ping(), Foo::ping_am(), madness::BandlimitedPropagator::plot(), plot_plane(), plot_symmetry_operators(), madness::PNO::pno_compress(), Foo::pong(), Foo::pong_am(), pounder(), preloadbal(), madness::MolecularOrbitals< T, NDIM >::pretty_print(), Metric::print(), ExactSpinor::print(), madness::LBDeuxPmap< NDIM >::print(), madness::MyPmap< D >::print(), madness::QCCalculationParametersBase::print(), madness::PairVectorMap::print(), madness::Timer::print(), MatrixOperator::print(), madness::projector_irrep::print_character_table(), madness::scf_data::print_data(), madness::WorldDCPmapInterface< keyT >::print_data_sizes(), madness::Solver< T, NDIM >::print_fock_matrix_eigs(), madness::MolecularOrbitals< T, NDIM >::print_frozen_orbitals(), print_header1(), print_header2(), print_header3(), Calculation::print_info(), madness::Diamagnetic_potential_factor::print_info(), madness::Localizer::print_info(), madness::projector_irrep::print_info(), madness::MacroTask< taskT >::MacroTaskInternal::print_me(), madness::MacroTaskBase::print_me_as_table(), madness::MacroTask< taskT >::MacroTaskInternal::print_me_as_table(), Spinor::print_norms(), madness::F12Potentials::print_pair_energies(), DF::print_parameters(), madness::CC2::print_parameters(), madness::Molecule::print_parameters(), madness::MP2::print_parameters(), madness::Nemo::print_parameters(), madness::OEP::print_parameters(), madness::PNO::print_parameters(), madness::SCF::print_parameters(), madness::TDHF::print_parameters(), madness::Zcis::print_parameters(), madness::Znemo::print_parameters(), madness::DFParameters::print_params(), madness::InitParameters::print_params(), GroundStateCalculation::print_params(), madness::Solver< T, NDIM >::print_potential_matrix_eigs(), print_seq(), madness::FunctionImpl< T, NDIM >::print_size(), madness::Function< T, NDIM >::print_size(), madness::CCPairFunction< T, NDIM >::print_size(), madness::Cloud::print_size(), madness::FunctionImpl< T, NDIM >::print_stats(), madness::MacroTaskQ::print_taskq(), madness::Cloud::print_timings(), madness::LoadBalanceDeux< NDIM >::print_tree(), madness::TDHF::print_xfunctions(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), Calculation::project_potential_basis(), madness::MolecularOptimizer::projector_external_dof(), propagate(), madness::Nemo::purify_hessian(), madness::TensorTrain< T >::ranks(), Plotter::read(), GroundStateCalculation::read(), madness::InitParameters::read(), madness::Znemo::read_complex_guess(), madness::Molecule::read_core_file(), madness::Znemo::read_explicit_guess_functions(), madness::CorePotentialManager::read_file(), madness::FunctionImpl< T, NDIM >::read_grid(), madness::FunctionImpl< T, NDIM >::read_grid2(), madness::Zcis::read_guess(), madness::QCCalculationParametersBase::read_input_and_commandline_options(), madness::QCCalculationParametersBase::read_internal(), madness::Znemo::read_real_guess(), madness::Znemo::read_reference(), madness::Znemo::read_restartaodata(), madness::MolecularOrbitals< T, NDIM >::read_restartaodata(), read_test_data(), madness::InitParameters::readnw(), madness::Znemo::recompute_factors_and_potentials(), madness::MolecularOrbitals< T, NDIM >::recompute_irreps(), reconstruct_psi(), madness::FunctionImpl< T, NDIM >::recursive_apply(), madness::projector_irrep::reduce(), madness::DependencyInterface::register_callback(), madness::DependencyInterface::register_final_callback(), madness::detail::RemoteCounter::register_ptr_(), madness::detail::RemoteCounterBase::release(), madness::SCF::restart_aos(), madness::MacroTask< taskT >::MacroTaskInternal::run(), TestTask::run(), run(), TestBarrier::run(), madness::MacroTaskQ::run_all(), run_all_calculations(), madness::MP2::save_function(), save_function(), madness::Nemo::save_function(), save_function(), madness::Zcis::save_guess(), madness::Znemo::save_orbitals(), madness::OEP::save_restartdata(), madness::OEP::selftest(), madness::FunctionNode< T, NDIM >::set_coeff(), madness::Molecule::GeometryParameters::set_derived_values(), madness::XCOperator< T, NDIM >::set_extra_truncation(), madness::Function< T, NDIM >::set_functor(), madness::projector_irrep::set_irrep(), madness::projector_irrep::set_ordering(), Calculation::set_protocol(), madness::SCF::set_protocol(), show_norms(), simple_example(), madness::GFit< T, NDIM >::SlaterFit(), madness::Solver< T, NDIM >::solve(), SVPESolver::solve(), madness::Nemo::solve(), madness::OEP::solve(), madness::SpectralPropagator::solve(), madness::PNO::solve(), madness::SCF::solve(), solve(), madness::CC2::solve_cc2(), madness::TDHF::solve_cis(), madness::Nemo::solve_cphf(), madness::CC2::solve_mp2_coupled(), madness::MP2::solve_residual_equations(), madness::QCPropertyInterface::spindensity(), squareit(), startup(), madness::SpectralPropagatorGaussLobatto::step(), madness::SpectralPropagator::step(), madness::Solver< T, NDIM >::step_restriction(), madness::archive::BufferOutputArchive::store(), madness::Cloud::store(), madness::detail::RemoteCounter::store_(), su_complex(), symmetrize(), madness::Molecule::symmetrize_and_identify_point_group(), madness::PNO::t_solve(), madness::IndexIterator::test(), madness::Znemo::test(), madness::TDHF::test(), test(), test0(), test0GaussLobatto(), test1(), test10(), test11(), test12(), test13(), test14(), test15(), test2(), test5(), test6(), test6a(), Test7(), test7(), test8(), test9(), test_2d_partitioning(), test_adaptive_tree(), test_add(), test_addition(), test_apply(), test_apply_push_1d(), test_arithmetic(), test_asymmetric(), test_basic(), test_batch(), test_batch_1D(), test_bsh(), test_capitalization(), TEST_CASE(), test_chin_chen(), test_combined_operators(), test_comment_lines(), test_compress(), madness::Znemo::test_compute_current_density(), test_consolidate(), test_construction_optimization(), test_constructor(), test_conv(), test_converged_function(), test_conversion(), test_convert(), test_convolution(), test_coulomb(), test_cross(), test_custom_worldobject(), test_deferred(), test_derived(), test_diff(), test_dnuclear(), test_empty_lines(), test_emul(), test_ethylene(), test_exchange(), test_exchange(), test_florian(), test_fock(), test_full_rank_functor(), test_G_R_vectors(), test_gaussian_num_coeffs(), test_gconv(), test_general_transform(), test_hartree_product(), test_hermiticity(), test_hf_be(), test_hydro(), test_immediate(), test_inner(), test_integration(), test_io(), test_Kcommutator(), test_kinetic(), madness::Znemo::test_landau_wave_function(), test_lda(), test_local(), test_lowrank_function(), test_math(), test_matrix_mul_sparse(), madness::Diamagnetic_potential_factor::test_me(), test_modified(), test_molecular_grid(), test_multi(), test_multi_to_multi_op(), test_multiply(), test_ne_boys(), test_nemo(), test_norm(), test_not_allowed(), test_nuclear(), test_nuclear_energy(), test_nuclear_potential(), test_nuclear_potential2(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), test_op(), test_opdir(), test_operator_apply(), test_orthogonalization(), test_partial_inner(), test_partial_inner_3d(), test_partial_inner_6d(), test_partitioner(), test_per(), test_periodic(), test_periodic1(), test_periodic2(), test_periodic_bsh(), test_plot(), test_proj(), test_projector(), test_projector_outer(), test_Q12_projector(), test_qm(), test_reconstruct(), test_recursive_application(), test_reduce_rank(), test_rot(), test_same(), test_scalar_multiplication(), test_scalar_task(), test_slater_exchange(), test_sliced_addition(), test_sliced_assignment(), test_smooth_maxout(), test_spherical_box(), test_stuff(), test_swap_particles(), test_task1(), test_tight_diffuse(), test_trailing_characters(), test_transform(), test_trotter(), test_truncation(), test_twice(), test_type_conversion1(), test_type_conversion2(), test_type_conversion3(), test_type_conversion4(), test_type_conversion5(), test_type_conversion6(), test_type_conversion7(), test_type_conversion8(), test_U_el(), test_unaryop(), test_vector_composite(), test_vector_of_scalar_task(), test_xcfunctional(), test_XCOperator(), testbsh(), testgradG(), testNavierStokes(), madness::scf_data::to_json(), trotter(), madness::NuclearCorrelationFactor::U2X_spherical(), madness::NonlinearSolverND< NDIM >::update(), madness::XNonlinearSolver< T, C, Alloc >::update(), update(), MiniDFT::update(), madness::PNO::update_pno(), madness::SubspaceK< T, NDIM >::update_subspace(), madness::Subspace< T, NDIM >::update_subspace(), madness::SCF::update_subspace(), madness::MP2::value(), madness::Nemo::value(), CoreFittingTarget::value(), madness::gridbase::visualize(), madness::XCfunctional::vxc(), and walker2().
void madness::print_centered | ( | const char * | s, |
int | column, | ||
bool | underline | ||
) |
Print a string centered at the given column with optional underlining.
References print_justified().
Referenced by main().
void madness::print_error | ( | const T & | t, |
const Ts &... | ts | ||
) |
Print items to std::cerr
(items separated by spaces) and terminate with a new line.
The first item is printed here so that it isn't preceded by a space.
T | Type of the first item to be printed. |
Ts | Argument pack type for the items to be printed. |
[in] | t | The first item to be printed. |
[in] | ts | The remaining items to be printed in the argument pack. |
References ENDL, print_helper(), and madness::detail::printmutex.
Referenced by madness::RMI::RmiTask::RmiTask(), madness::RMI::RmiTask::exit(), madness::RMI::isend(), and madness::RMI::RmiTask::process_some().
void madness::print_header1 | ( | const std::string & | s | ) |
big section heading
References print().
Referenced by main(), madness::TDHF::make_guess_from_initial_diagonalization(), and madness::CC2::solve().
void madness::print_header2 | ( | const std::string & | s | ) |
medium section heading
References print().
Referenced by DF::help(), madness::CC2::help(), madness::MP2::help(), madness::Nemo::help(), madness::OEP::help(), madness::PNO::help(), madness::SCF::help(), madness::TDHF::help(), madness::Zcis::help(), madness::Znemo::help(), iterate(), main(), madness::MP3::mp3_energy_contribution(), madness::MP3::mp3_energy_contribution_macrotask_driver(), madness::MP3::mp3_test(), run(), madness::TDHF::solve_cis(), madness::CC2::solve_lrcc2(), madness::CC2::solve_mp2_coupled(), test_conversion(), test_full_rank_functor(), and madness::Nemo::value().
void madness::print_header3 | ( | const std::string & | s | ) |
small section heading
References print().
Referenced by madness::MP3::compute_mp3_cd(), madness::MP3::compute_mp3_ef(), madness::MP3::compute_mp3_ef_low_scaling(), madness::MP3::compute_mp3_ef_with_permutational_symmetry(), madness::MP3::compute_mp3_ghij(), madness::MP3::compute_mp3_ghij_fast(), madness::MP3::compute_mp3_klmn(), iterate(), madness::CC2::iterate_lrcc2_pairs(), madness::CC2::solve(), madness::CC2::solve_ccs(), and madness::CC2::solve_mp2_coupled().
|
inline |
Helper function for print
. Base case.
This gets called recursively when there are no items left to print.
[in,out] | out | Output stream. |
Referenced by print(), print_error(), and print_helper().
|
inline |
Helper function for print
. Prints the first item (t
) and recursively passes on the other items.
T | Type of the item to print in this call. |
Ts | Argument pack type for the remaining items. |
[in,out] | out | Output stream. |
[in] | t | The item to print in this call. |
[in] | ts | The remaining items in the argument pack (they get recursively passed on). |
References print_helper().
void madness::print_justified | ( | const char * | s, |
int | column, | ||
bool | underline | ||
) |
Print a string justified on the left to start at the given column with optional underlining.
References ENDL.
Referenced by print_centered().
void madness::print_meminfo | ( | int | rank, |
const String & | tag, | ||
const std::string | filename_prefix = std::string("MEMORY") , |
||
bool | verbose = false |
||
) |
print aggregate memory stats to file filename_prefix
.<rank> , tagged with tag
[in] | rank | process rank |
[in] | tag | record tag as any string type, e.g. const char[] , std::string , or std::wstring |
[in] | filename_prefix | file name prefix; the default value is "MEMORY" |
[in] | verbose | if true, will produce verbose output; is only currently used if TCMalloc is used |
std::locale::global()
if tag
has nontrivial encoding References copy(), filename, print_meminfo_enabled(), print_meminfo_keep_ostream_open(), print_meminfo_ostream(), and madness::detail::Vm_cstr< char >().
Referenced by madness::SCF::apply_potential(), madness::SCF::initial_guess(), main(), MiniDFT::makeao(), and madness::SCF::solve().
void madness::print_meminfo_disable | ( | ) |
disables print_meminfo() profiling (i.e. calling it is a no-op)
References madness::detail::print_meminfo_flag_accessor().
void madness::print_meminfo_enable | ( | ) |
enables print_meminfo() profiling
References madness::detail::print_meminfo_flag_accessor().
bool madness::print_meminfo_enabled | ( | ) |
References madness::detail::print_meminfo_flag_accessor().
Referenced by print_meminfo().
bool madness::print_meminfo_keep_ostream_open | ( | ) |
References madness::detail::print_meminfo_keepstreamopen_accessor().
void madness::print_meminfo_keep_ostream_open | ( | bool | keep_open | ) |
[in] | keep_open | if true, the stream used by print_meminfo() will be kept open |
References madness::detail::print_meminfo_keepstreamopen_accessor().
Referenced by print_meminfo(), and print_meminfo_ostream().
std::basic_ofstream<wchar_t>& madness::print_meminfo_ostream | ( | int | rank = -1 , |
const std::string | filename_prefix = std::string("") |
||
) |
[in] | rank | process rank; the default is -1 |
[in] | filename_prefix | file name prefix; the default is empty string |
std::runtime_error | if:
|
References filename, and print_meminfo_keep_ostream_open().
Referenced by print_meminfo().
Sequentially ordered printing of (serializable) data from every process.
Collective, no fence.
A | Type of data 1. |
[in] | world | The World object. |
[in] | a | Data 1. |
References a, aa, p(), print(), madness::World::rank(), and madness::World::size().
void madness::print_seq | ( | World & | world, |
const A & | a, | ||
const B & | b | ||
) |
Sequentially ordered printing of (serializable) data from every process.
Collective, no fence.
[in] | world | The World object. |
[in] | a | Data 1. |
[in] | b | Data 2. |
References a, aa, b, p(), print(), madness::World::rank(), and madness::World::size().
void madness::print_seq | ( | World & | world, |
const A & | a, | ||
const B & | b, | ||
const C & | c | ||
) |
Sequentially ordered printing of (serializable) data from every process.
Collective, no fence.
[in] | world | The World object. |
[in] | a | Data 1. |
[in] | b | Data 2. |
[in] | c | Data 3. |
References a, aa, b, c, cc, p(), print(), madness::World::rank(), and madness::World::size().
void madness::print_seq | ( | World & | world, |
const A & | a, | ||
const B & | b, | ||
const C & | c, | ||
const D & | d | ||
) |
void madness::print_size | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const std::string & | msg = "vectorfunction" |
||
) |
References madness::World::rank(), and v.
Referenced by madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::CCPair::info(), madness::CCIntermediatePotentials::insert(), madness::Zcis::iterate(), madness::CC2::iterate_lrcc2_pairs(), madness::CC2::iterate_singles(), madness::Zcis::make_guess(), madness::CCIntermediatePotentials::operator()(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::print_size(), madness::F12Potentials::read_cabs_from_file(), and madness::CC2::solve_mp2_coupled().
void madness::print_stats | ( | World & | world | ) |
Print miscellaneous stats on a World.
This requires collective operations within the World.
[in] | world | The World to analyze. |
References cpu_time(), end_papi_measurement(), madness::WorldGopInterface::fence(), get_papi_measurement(), madness::ThreadPool::get_stats(), madness::RMI::get_stats(), madness::World::gop, madness::WorldGopInterface::max(), madness::RMIStats::max_serv_send_q, madness::WorldGopInterface::min(), madness::RMIStats::nbyte_recv, madness::RMIStats::nbyte_sent, madness::RMIStats::nmsg_recv, madness::RMIStats::nmsg_sent, NUMEVENTS, madness::WorldMemInfo::print(), madness::WorldProfile::print(), q(), madness::World::rank(), madness::ThreadPool::size(), madness::World::size(), madness::WorldGopInterface::sum(), wall_time(), and world_mem_info().
Referenced by main(), and propagate().
std::enable_if<NDIM==3,void>::type madness::print_tree_jsonfile | ( | World & | world, |
const Function< double, NDIM > & | f, | ||
std::string | filename | ||
) |
References copy(), f, filename, and madness::World::size().
void madness::printf_msg_energy_time | ( | const std::string | msg, |
const double | energy, | ||
const double | time | ||
) |
References energy.
Referenced by madness::CC2::solve().
Function<T,NDIM> madness::project | ( | const Function< T, NDIM > & | other, |
int | k = FunctionDefaults<NDIM>::get_k() , |
||
double | thresh = FunctionDefaults<NDIM>::get_thresh() , |
||
bool | fence = true |
||
) |
References madness::FunctionFactory< T, NDIM >::empty(), madness::Function< T, NDIM >::get_impl(), k, madness::FunctionFactory< T, NDIM >::k(), PROFILE_FUNC, madness::Function< T, NDIM >::reconstruct(), thresh, madness::FunctionFactory< T, NDIM >::thresh(), and madness::Function< T, NDIM >::world().
Referenced by DF::DF(), madness::smooth< T, NDIM >::cut_oscillations(), MiniDFT::doit(), doit(), madness::smooth< T, NDIM >::linearize(), madness::SCF::load_mos(), Calculation::load_mos(), madness::Solver< T, NDIM >::load_orbitals(), main(), madness::smooth< T, NDIM >::make_inv_mask(), madness::smooth< T, NDIM >::make_mask(), madness::MolecularOrbitals< T, NDIM >::post_process_mos(), madness::SCF::project(), madness::FunctionImpl< T, NDIM >::project_refine_op(), madness::Solver< T, NDIM >::reproject(), madness::GTHPseudopotential< Q >::reproject(), madness::Nemo::smoothen(), and madness::FunctionImpl< T, NDIM >::sock_it_to_me_too().
Given overlap matrix, return rotation with 2nd order error to orthonormalize the vectors.
References Q().
Referenced by madness::CCPairFunction< T, NDIM >::apply(), orthonormalize(), madness::SCF::orthonormalize(), and test_projector_outer().
Given overlap matrix, return rotation with 3rd order error to orthonormalize the vectors.
Referenced by Calculation::load_mos().
Convolution1D< double_complex > * madness::qm_1d_free_particle_propagator | ( | int | k, |
double | bandlimit, | ||
double | timestep, | ||
double | width | ||
) |
References k.
Referenced by MAKE_PROPAGATOR(), propagate(), qm_free_particle_propagator(), qm_free_particle_propagatorPtr(), test_chin_chen(), test_qm(), and test_trotter().
SeparatedConvolution< double_complex, NDIM > madness::qm_free_particle_propagator | ( | World & | world, |
int | k, | ||
double | bandlimit, | ||
double | timestep | ||
) |
SeparatedConvolution< double_complex, NDIM > * madness::qm_free_particle_propagatorPtr | ( | World & | world, |
int | k, | ||
double | bandlimit, | ||
double | timestep | ||
) |
template void madness::qr | ( | Tensor< double_complex > & | A, |
Tensor< double_complex > & | R | ||
) |
template void madness::qr | ( | Tensor< float_complex > & | A, |
Tensor< float_complex > & | R | ||
) |
compute the QR decomposition of the matrix A
QR decomposition.
[in,out] | A | on entry the (n,m) matrix to be decomposed on exit the Q matrix |
[out] | R | the (n,n) matrix R (square form) |
References lq_result(), m, R, TENSOR_ASSERT, and transpose().
Referenced by madness::RandomizedMatrixDecomposition< T >::do_compute_range(), and test_qr().
bool madness::quiet | ( | ) |
Check if the MADNESS runtime was initialized for quiet operation.
madness::initialize
was called with quiet=true
. Referenced by madness::ThreadPool::begin(), madness::WorldGopInterface::initial_max_reducebcast_msg_size(), and initialize().
|
static |
Referenced by apply(), apply_U_ncf(), apply_V(), area_two_spheres(), coul(), d_smoothed_potential(), distances(), dsmoothed_potential(), dsmoothed_potential(), madness::NuclearCorrelationFactor::dsmoothed_unitvec(), exact_dipoleX(), exact_quadrupoleX(), f6d(), gauss_3d(), gauss_6d(), general_transform(), he_orbitals(), helium_pot(), hylleraas_3term(), data< T, NDIM >::initialize(), main(), madness::TwoElectronInterface< T, NDIM >::make_coeff(), make_radius(), mask_functor_box(), madness::BasisFunctions::SolidHarmonicGaussian::operator()(), gaussian::operator()(), slater_functor(), smoothed_potential(), smoothed_potential(), madness::TensorTrain< T >::splitdim(), test_add(), test_apply(), test_consolidate(), test_hartree_product(), test_integration(), test_multiply_with_f12(), test_partial_inner_6d(), madness::Solver< T, NDIM >::test_periodicity(), test_vector_composite(), tightgauss_3d(), transform(), u(), madness::GaussSlater::U2X_spherical(), madness::GradientalGaussSlater::U2X_spherical(), madness::Slater::U2X_spherical(), madness::Polynomial< N >::U2X_spherical(), V(), V_1(), V_times_phi(), and volume_two_spheres().
T madness::RandomValue | ( | ) |
Random value that wraps the default Fibonacci generator.
double madness::RandomValue< double > | ( | ) |
Random double.
References default_random_generator, and madness::Random::get().
Referenced by madness::Localizer::localize_boys(), madness::Localizer::localize_new(), BoysLocalization::operator()(), madness::MyPmap< D >::prepare_not_so_simple_map(), random_gaussian(), RandomGaussian(), RandomValue< double_complex >(), RandomValue< int >(), and RandomValue< long >().
double_complex madness::RandomValue< double_complex > | ( | ) |
Random double_complex.
References RandomValue< double >().
float madness::RandomValue< float > | ( | ) |
Random float.
References default_random_generator, and madness::Random::get().
Referenced by RandomValue< float_complex >().
float_complex madness::RandomValue< float_complex > | ( | ) |
Random float_complex.
References RandomValue< float >().
int madness::RandomValue< int > | ( | ) |
Random int.
References RandomValue< double >().
Referenced by test_transform(), unique_fileid(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().
long madness::RandomValue< long > | ( | ) |
void madness::RandomVector | ( | int | n, |
T * | t | ||
) |
void madness::RandomVector< double > | ( | int | n, |
double * | t | ||
) |
References default_random_generator, and madness::Random::getv().
void madness::RandomVector< double_complex > | ( | int | n, |
double_complex * | t | ||
) |
References default_random_generator, and madness::Random::getv().
void madness::RandomVector< float > | ( | int | n, |
float * | t | ||
) |
References default_random_generator, and madness::Random::getv().
void madness::RandomVector< float_complex > | ( | int | n, |
float_complex * | t | ||
) |
References default_random_generator, and madness::Random::getv().
long madness::rank_revealing_decompose | ( | Tensor< T > & | A, |
Tensor< T > & | U, | ||
const double | thresh, | ||
Tensor< typename Tensor< T >::scalar_type > & | s, | ||
Tensor< T > & | scr | ||
) |
decompose the input tensor A into U and V, skipping singular vectors of small singular values. One deep copy/allocation for U is performed
[in,out] | A | the input matrix, on exit the matrix VT (right sing. vectors) |
[out] | U | contiguous new tensor holding the left sing. vectors |
[in] | thresh | threshold for truncation of the singular vectors |
[in] | s | scratch tensor for the singular values, dimension min(n,m) |
[in] | scr | scratch tensor the dimension of the scratch tensor may be computed as long lwork=std::max(3*std::min(m,n)+std::max(m,n),5*std::min(m,n)) + n*m; |
References _(), A(), copy(), madness::Tensor< T >::flat(), m, MADNESS_ASSERT, max, madness::SRConf< T >::max_sigma(), R1, madness::BaseTensor::size(), svd_result(), and thresh.
Referenced by apply().
|
static |
References madness::AtomCore::atomic_number, e(), eprec, MADNESS_EXCEPTION, read_orbital(), and read_potential().
Referenced by madness::CorePotentialManager::read_file().
|
static |
read_data loads the precomputed Gauss-Legendre data
References data_is_read, f, filename, max_npt, points, and weights.
Referenced by gauss_legendre(), load_coeffs(), load_quadrature(), and madness::guessfactory::PolynomialFunctor::read_string().
|
static |
References _cread, autocorr_filename, ij(), k, kread, p(), parity(), and test_autoc().
|
static |
References c, e(), madness::AtomCore::ncore, madness::AtomCore::orbital, p(), and type().
Referenced by read_atom().
|
static |
References madness::CorePotential::A, madness::CorePotential::alpha, madness::AtomCore::atomic_number, c, e(), eprec, madness::CorePotential::eprec, madness::CorePotential::l, madness::CorePotential::n, madness::AtomCore::ncore, p(), madness::AtomCore::potential, madness::CorePotential::rcut, madness::CorePotential::rcut0, and smoothing_parameter().
Referenced by read_atom().
|
static |
References cache, checksum_file(), e(), madness::twoscale_cache_class::g0, madness::twoscale_cache_class::g1, madness::twoscale_cache_class::h0, madness::twoscale_cache_class::h1, k, kmax, loaded, MADNESS_CHECK, phase(), readmat(), and twoscale_filename.
Referenced by load_coeffs(), and two_scale_coefficients().
|
static |
Referenced by read_twoscale().
Function<double,NDIM> madness::real | ( | const Function< double, NDIM > & | z, |
bool | fence = true |
||
) |
Returns a new function that is the real part of the input.
References copy().
Function<double,NDIM> madness::real | ( | const Function< double_complex, NDIM > & | z, |
bool | fence = true |
||
) |
Returns a new function that is the real part of the input.
References unary_op_coeffs().
Function<typename TensorTypeData<Q>::scalar_type,NDIM> madness::real | ( | const Function< Q, NDIM > & | func | ) |
References func(), and unary_op_coeffs().
|
inline |
Referenced by madness::Znemo::analyze(), madness::Solver< T, NDIM >::apply_hf_exchange3(), madness::Solver< T, NDIM >::apply_hf_exchange4(), madness::projector_irrep::apply_symmetry_operators(), madness::Solver< T, NDIM >::calculate_kinetic_energy(), madness::Znemo::canonicalize(), madness::MolecularOrbitals< T, NDIM >::compute_center(), madness::guessfactory::compute_centroids(), madness::Znemo::compute_energy(), madness::Znemo::compute_linear_moment(), compute_madelung_energy(), compute_madelung_energy_PWSCF(), madness::Znemo::compute_magnetic_potential_expectation(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), madness::Localizer::determine_frozen_orbitals(), DF::diagonalize(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), eigenvector_test(), energy(), madness::BSHApply< T, NDIM >::eps_in_green(), GMRES(), madness::Solver< T, NDIM >::initial_guess(), madness::Znemo::iterate(), iterate(), madness::Zcis::iterate(), DF::iterate(), main(), madness::Zcis::make_guess(), myreal(), madness::VectorSpace< T, NDIM >::norm(), Fcwf::norm2(), madness::CCPairFunction< T, NDIM >::norm2(), AnsatzBase::normalize(), EwaldNuclearPotentialFunctor::operator()(), madness::detail::realop< NDIM >::operator()(), madness::real_op< Q, NDIM >::operator()(), madness::BSHApply< T, NDIM >::operator()(), Spinor::plot(), plot_line_print_value(), plotvtk_data(), Spinor::print_norms(), print_stats(), real(), madness::Znemo::save_orbitals(), madness::Localizer::separate_core_valence(), tensor_xreal(), test_kinetic(), test_XCOperator(), and madness::Localizer::undo_reordering().
const std::vector< Function<T,NDIM> >& madness::reconstruct | ( | const std::vector< Function< T, NDIM > > & | v | ) |
reconstruct a vector of functions
implies fence return v for chaining
References change_tree_state(), reconstructed, and v.
Referenced by abssq(), apply(), apply_potential(), WSTFunctional::apply_xc(), madness::FunctionImpl< T, NDIM >::change_tree_state(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::Solver< T, NDIM >::compute_rho(), cross(), div(), madness::FunctionImpl< R, NDIM >::do_print_grid(), doit(), madness::Projector< T, NDIM >::get_vectors_for_outer_product(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), hamiltonian_matrix(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), madness::CC2::iterate_lrcc2_pairs(), kinetic_energy_matrix(), madness::SCF::kinetic_energy_matrix(), madness::Kinetic< T, NDIM >::kinetic_energy_matrix(), MiniDFT::kinetic_energy_matrix(), kinetic_energy_matrix2(), kinetic_energy_matrix_slow(), madness::SCF::load_mos(), Calculation::load_mos(), madness::Solver< T, NDIM >::load_orbitals(), madness::SCF::make_density(), madness::TDHF::make_mo_bra(), madness::TDHF::make_mo_ket(), Calculation::make_reference(), matrix_mul_sparse(), molresponseExchange(), moments(), mul(), mul_sparse(), nonstandard(), madness::Nuclear< T, NDIM >::operator()(), madness::Lz< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), Calculation::plot_p(), madness::MolecularOrbitals< T, NDIM >::post_process_mos(), madness::SCF::project(), refine_to_common_level(), madness::Solver< T, NDIM >::reproject(), rot(), test2(), madness::SCF::twoint(), and vector_to_PQ().
void madness::reconstruct | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Reconstruct a vector of functions.
References change_tree_state(), PROFILE_BLOCK, reconstructed, and v.
void madness::reconstruct | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Reconstruct a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
void madness::redirectio | ( | const World & | world, |
bool | split = false |
||
) |
redirects standard output and error to rank-specific files
[in] | world | the World object that determines rank of this process |
[in] | split | if true, write standard output to log.<rank> and standard error to err.<rank>, otherwise write both standard output and error to log.<rank>. The default is false. |
References bufsize, filename, MADNESS_EXCEPTION, madness::World::mpi, madness::WorldMpiInterface::rank(), and split().
GenTensor<T> madness::reduce | ( | std::list< GenTensor< T > > & | addends, |
double | eps, | ||
bool | are_optimal = false |
||
) |
add all the GenTensors of a given list
If there are many tensors to add it's beneficial to do a sorted addition and start with those tensors with low ranks
[in] | addends | a list with gentensors of same dimensions; will be destroyed upon return |
[in] | eps | the accuracy threshold |
[in] | are_optimal | flag if the GenTensors in the list are already in SVD format (if TT_2D) |
References copy().
Referenced by madness::SeparatedConvolution< Q, NDIM >::apply2(), and main().
void madness::refine | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | vf, | ||
bool | fence = true |
||
) |
refine the functions according to the autorefine criteria
References f, madness::WorldGopInterface::fence(), and madness::World::gop.
Referenced by madness::OEP::compute_Pauli_kinetic_density(), madness::OEP::compute_total_kinetic_density(), div(), grad(), grad_ble_one(), grad_ble_two(), grad_bpsline_two(), grad_bspline_one(), grad_bspline_three(), madness::Nemo::make_density(), madness::Nemo::make_incomplete_hessian(), madness::FunctionDefaults< NDIM >::print(), rot(), madness::FunctionDefaults< NDIM >::set_defaults(), madness::Exchange< double, 3 >::set_printlevel(), and test().
void madness::refine_to_common_level | ( | World & | world, |
std::vector< Function< T, NDIM > > & | vf, | ||
bool | fence = true |
||
) |
refine all functions to a common (finest) level
if functions are not initialized (impl==NULL) they are ignored
References c, std::distance(), get_impl(), reconstruct(), verify_tree(), and VERIFY_TREE.
Referenced by WSTFunctional::apply_xc(), madness::XCOperator< T, NDIM >::apply_xc_kernel(), madness::OEP::compute_dcep_correction(), madness::OEP::compute_mrks_correction(), madness::OEP::compute_ocep_correction(), madness::OEP::compute_slater_potential(), madness::XCOperator< T, NDIM >::compute_xc_energy(), madness::smooth< T, NDIM >::merge_functions(), madness::FunctionImpl< T, NDIM >::refine_to_common_level(), test_math(), test_multi_to_multi_op(), and test_XCOperator().
|
inline |
std::vector<Function<T,NDIM> > madness::rot | ( | const std::vector< Function< T, NDIM > > & | v, |
bool | do_refine = false , |
||
bool | fence = true |
||
) |
shorthand rot operator
returns the cross product of nabla with a vector f
[in] | f | the vector of functions on which the rot operator works on |
[in] | refine | refinement before diff'ing makes the result more accurate |
[in] | fence | fence after completion; currently always fences |
References apply(), d(), madness::WorldGopInterface::fence(), madness::World::gop, grad(), MADNESS_ASSERT, NDIM, reconstruct(), refine(), and v.
Referenced by madness::Znemo::compute_current_density(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), fixphases(), and test_rot().
DistributedMatrix<T> madness::row_distributed_matrix | ( | World & | world, |
int64_t | n, | ||
int64_t | m, | ||
int64_t | rowtile = 0 |
||
) |
Generates an (n,m) matrix distributed by rows (column dimension is not distributed)
[in] | world | The world |
[in] | n | The column (first) dimension |
[in] | m | The row (second) dimension |
[in] | rowtile | Tile size for row (default is to use all processes) |
References m, and row_distributed_matrix_distribution().
|
inlinestatic |
Generates an (n,m) matrix distribution distributed by rows (column dimension is not distributed)
[in] | world | The world |
[in] | n | The column (first) dimension |
[in] | m | The row (second) dimension |
[in] | rowtile | Tile size for row (default is to use all processes) |
Referenced by row_distributed_matrix().
template void madness::rr_cholesky | ( | Tensor< double > & | A, |
typename Tensor< double >::scalar_type | tol, | ||
Tensor< integer > & | piv, | ||
int & | rank | ||
) |
template void madness::rr_cholesky | ( | Tensor< double_complex > & | A, |
typename Tensor< double_complex >::scalar_type | tol, | ||
Tensor< integer > & | piv, | ||
int & | rank | ||
) |
void madness::rr_cholesky | ( | Tensor< T > & | A, |
typename Tensor< T >::scalar_type | tol, | ||
Tensor< integer > & | piv, | ||
int & | rank | ||
) |
Compute the rank-revealing Cholesky factorization.
rank-revealing Cholesky factorization
Compute the rank-revealing Cholesky factorization of the symmetric positive definite matrix A
For memory efficiency A is modified inplace. Its upper triangle will hold the result and the lower triangle will be zeroed such that input = inner(transpose(output),output).
[in] | A | the positive-semidefinite matrix to be decomposed |
[in] | tol | linear dependency threshold for discarding columns of A |
[in] | piv | pivot vector, its 1-rank entries are the orthogonal vectors |
[in] | rank | numerical rank of A (wrt tol) |
References A(), mask_info(), pstrf_(), madness::Tensor< T >::ptr(), and TENSOR_ASSERT.
Referenced by madness::projector_irrep::apply_symmetry_operators(), madness::PNO::orthonormalize_cholesky(), orthonormalize_rrcd(), and test_rr_cholesky().
|
static |
Referenced by madness::SCF::analyze_vectors(), and smoothed_density().
void madness::save | ( | const Function< T, NDIM > & | f, |
const std::string | name | ||
) |
Referenced by madness::OEP::analyze(), madness::Znemo::analyze(), madness::TDHF::analyze(), madness::Nemo::compute_all_cphf(), madness::Znemo::compute_current_density(), madness::Zcis::compute_potentials(), madness::OEP::compute_slater_potential(), madness::OEP::iterate(), madness::Zcis::iterate(), madness::CC2::iterate_lrcc2_pairs(), madness::CC2::iterate_pair(), madness::Nemo::kinetic_energy_potential(), main(), madness::Nemo::make_laplacian_density(), madness::Znemo::save_orbitals(), madness::OEP::selftest(), madness::OEP::solve(), madness::CC2::solve_cc2(), madness::CC2::solve_mp2_coupled(), madness::Znemo::test_compute_current_density(), madness::CC2::update_constant_part_adc2(), madness::CC2::update_constant_part_cc2_gs(), madness::CC2::update_constant_part_cispd(), madness::CC2::update_constant_part_lrcc2(), and madness::Nemo::value().
void madness::save_function | ( | const std::vector< Function< T, NDIM > > & | f, |
const std::string | name | ||
) |
save a vector of functions
References f, name(), print(), and madness::World::rank().
Referenced by madness::Zcis::compare_to_file(), madness::PNO::save_pnos(), solve(), test_adaptive_tree(), and test_multiply().
std::vector<std::shared_ptr<ScalarResult<T> > > madness::scalar_result_shared_ptr_vector | ( | World & | world, |
std::size_t | n | ||
) |
helper function to create a vector of ScalarResult, circumventing problems with the constructors
References MADNESS_EXCEPTION, madness::World::ptr_from_id(), and v.
response_space madness::scale | ( | response_space | a, |
double | b | ||
) |
Referenced by SVPESolver::SVPESolver(), madness::BSHApply< T, NDIM >::add_coupling_and_levelshift(), madness::Znemo::analyze(), madness::TDHF::apply_G(), madness::FunctionCommonFunctionality< T, NDIM >::coeffs2values(), madness::FunctionImpl< T, NDIM >::coeffs2values(), madness::Diamagnetic_potential_factor::compute_lz_commutator(), madness::Nemo::compute_nemo_potentials(), madness::Zcis::compute_potentials(), madness::SCF::compute_residual(), madness::F12Potentials::convolve_with_fU(), madness::FunctionImpl< T, NDIM >::do_binary_op(), madness::FunctionImpl< T, NDIM >::do_mul(), madness::FunctionImpl< T, NDIM >::err_box(), gauss_legendre_numeric(), madness::TDHF::get_tda_potential(), madness::Znemo::iterate(), madness::CC2::iterate_singles(), madness::Nemo::kinetic_energy_potential(), main(), madness::MP2::make_Uphi0(), madness::Solver< T, NDIM >::matrix_exponential(), madness::Localizer::matrix_exponential(), matrix_exponential(), moments(), madness::FunctionImpl< T, NDIM >::mul(), madness::EigSolver< T, NDIM >::multi_solve(), AnsatzBase::normalize(), madness::NemoBase::normalize(), madness::Zcis::normalize(), normalize(), madness::FunctionImpl< T, NDIM >::NS_fcube_for_mul(), madness::FunctionImpl< T, NDIM >::NScoeffs2values(), madness::FunctionImpl< T, NDIM >::do_unary_op_value_inplace< opT >::operator()(), operator*(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::operator*=(), madness::response_space::operator*=(), madness::FunctionImpl< T, NDIM >::phi_for_mul(), plot_plane(), madness::FunctionImpl< T, NDIM >::print_plane_local(), q_c(), madness::Molecule::read(), MolecularEntity::read_file(), madness::Molecule::read_xyz(), madness::response_space::scale(), scale(), madness::Solver< T, NDIM >::solve(), madness::Nemo::solve_cphf(), squaremod_small(), testNavierStokes(), update(), MiniDFT::update(), madness::PNO::update_pno(), madness::FunctionCommonFunctionality< T, NDIM >::values2coeffs(), madness::FunctionImpl< T, NDIM >::values2coeffs(), and madness::FunctionImpl< T, NDIM >::values2NScoeffs().
void madness::scale | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
const Q | factor, | ||
bool | fence = true |
||
) |
Scales inplace a vector of functions by the same.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, scale(), and v.
void madness::scale | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
const Q | factor, | ||
const unsigned int | blk = 1 , |
||
const bool | fence = true |
||
) |
Scales inplace a vector of functions by the same.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
void madness::scale | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
const std::vector< Q > & | factors, | ||
bool | fence = true |
||
) |
Scales inplace a vector of functions by distinct values.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, scale(), and v.
void madness::scale | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
const std::vector< Q > & | factors, | ||
const unsigned int | blk = 1 , |
||
const bool | fence = true |
||
) |
Scales inplace a vector of functions by distinct values.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
response_space madness::scale_2d | ( | World & | world, |
const response_space & | a, | ||
const Tensor< double > & | b | ||
) |
|
inline |
Terminate argument serialization.
Referenced by new_am_arg(), and serialize_am_args().
|
inline |
Argument serialization.
References serialize_am_args().
void madness::set_impl | ( | std::vector< Function< T, NDIM >> & | v, |
const std::vector< std::shared_ptr< FunctionImpl< T, NDIM >>> | vimpl | ||
) |
References MADNESS_CHECK, and v.
Referenced by madness::MacroTask< taskT >::MacroTaskInternal::get_output(), and impl2function().
|
inline |
sets the thread tag for the thread invoking this function
tag | thread tag for the calling thread |
References madness::detail::thread_tag_accessor().
|
inline |
sets the thread tag for the thread invoking this function
tag | thread tag for the calling thread |
References madness::detail::thread_tag_accessor().
Referenced by madness::ThreadBase::main().
void madness::set_thresh | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
double | thresh, | ||
bool | fence = true |
||
) |
Sets the threshold in a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, thresh, and v.
Referenced by DF::DF(), madness::SCF::compute_residual(), madness::Znemo::get_initial_orbitals(), madness::SCF::load_mos(), main(), madness::TDHF::make_mo_bra(), madness::TDHF::make_mo_ket(), madness::MolecularOrbitals< T, NDIM >::post_process_mos(), madness::Nemo::set_protocol(), and madness::PNO::solve().
|
static |
Convert simulation coords ([0,1]^ndim) to user coords (FunctionDefaults<NDIM>::get_cell())
References madness::FunctionDefaults< NDIM >::get_cell(), and NDIM.
|
inlinestatic |
Returns the box at level n that contains the given point in simulation coordinates
[in] | pt | point in simulation coordinates |
[in] | n | the level of the box |
Referenced by madness::Specialbox_op< T, NDIM >::check_special_points(), madness::NuclearCuspyBox_op< T, NDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::project_refine_op().
double madness::size_of | ( | const intermediateT< T, NDIM > & | im | ) |
Returns the size of an intermediate.
Returns the size of an intermediate
References madness::Pairs< T >::allpairs.
Referenced by madness::CCConvolutionOperator< T, NDIM >::info().
double madness::slater_radius | ( | int | atomic_number | ) |
collection of slater radii needed to calculate R1 and R2; The Journal of Chemical Physics 41, 3199 (1964); doi: 10.1063/1.1725697
[in] | atomic_number | atomic_number of atom |
[out] | slater radius corresponding to atomic_number |
References MADNESS_EXCEPTION.
Referenced by main(), and make_atom_vec().
|
inlinestatic |
References k, lo, mu, and OT_F12.
Referenced by madness::MP2::compute_gQf().
|
inlinestatic |
Factory function generating separated kernel for convolution with (1 - exp(-mu*r))/(2 mu) in 3D.
includes the factor 1/(2 mu)
References k, lo, mu, and OT_F12.
Referenced by madness::F12Potentials::F12Potentials(), test_Kcommutator(), and test_lowrank_function().
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
Factory function generating separated kernel for convolution with exp(-mu*r) in 3D Note that the 1/(2mu) factor of SlaterF12Operator is not included, this is just the exponential function
References k, lo, mu, and OT_SLATER.
Referenced by test_Kcommutator(), and test_lowrank_function().
|
inlinestatic |
double madness::smoothed_density | ( | double | r | ) |
Charge density corresponding to smoothed 1/r potential.
Invoke as rho
(r/c)/c^3 where c
is the radius of the smoothed volume.
References madness::constants::pi, and pow().
Referenced by madness::Molecule::mol_nuclear_charge_density(), MolecularEntity::nuclear_charge_density(), and madness::Molecule::nuclear_charge_density().
double madness::smoothed_potential | ( | double | r | ) |
Smoothed 1/r potential.
Invoke as u
(r/c)/c where c
is the radius of the smoothed volume.
Referenced by madness::Molecule::atomic_attraction_potential(), madness::CorePotential::eval(), madness::CorePotential::eval_derivative(), MolecularEntity::nuclear_attraction_potential(), madness::Molecule::nuclear_attraction_potential(), madness::Molecule::nuclear_attraction_potential_second_derivative(), PotentialBasisFunctor::operator()(), NcOverR::operator()(), madchem::AtomicAttractionFunctor::operator()(), madness::PseudoNuclearCorrelationFactor::Spp_div_S(), V(), V_func_be(), V_func_he(), Ve(), and Vn().
double madness::smoothing_parameter | ( | double | Z, |
double | eprec | ||
) |
Returns radius for smoothing nuclear potential with energy precision eprec.
References c, e(), eprec, pow(), and Z.
Referenced by madness::Molecule::add_atom(), MolecularEntity::add_atom(), Calculation::make_reference(), madness::Molecule::read_core_file(), read_potential(), madness::CorePotentialManager::set_eprec(), madness::PseudoNuclearCorrelationFactor::Spp_div_S(), madness::Molecule::update_rcut_with_eprec(), V_func_be(), and V_func_he().
|
inlinestatic |
|
inlinestatic |
Factory function generating separated kernel for convolution a normalized Gaussian (aka a widened delta function)
Referenced by dostuff(), and madness::Nemo::kinetic_energy_potential().
madness::SPEC | ( | double | , |
double_complex | , | ||
double_complex | |||
) |
madness::SPEC | ( | double | , |
float_complex | , | ||
float_complex | |||
) |
madness::SPEC | ( | float | , |
double | , | ||
double | |||
) |
madness::SPEC | ( | float | , |
double_complex | , | ||
double_complex | |||
) |
madness::SPEC | ( | float | , |
float_complex | , | ||
float_complex | |||
) |
madness::SPEC | ( | float_complex | , |
double_complex | , | ||
double_complex | |||
) |
madness::SPEC | ( | int | , |
double | , | ||
double | |||
) |
madness::SPEC | ( | int | , |
double_complex | , | ||
double_complex | |||
) |
madness::SPEC | ( | int | , |
float | , | ||
float | |||
) |
madness::SPEC | ( | int | , |
float_complex | , | ||
float_complex | |||
) |
madness::SPEC | ( | int | , |
long | , | ||
long | |||
) |
madness::SPEC | ( | long | , |
double | , | ||
double | |||
) |
madness::SPEC | ( | long | , |
double_complex | , | ||
double_complex | |||
) |
madness::SPEC | ( | long | , |
float | , | ||
float | |||
) |
madness::SPEC | ( | long | , |
float_complex | , | ||
float_complex | |||
) |
Function<T,NDIM> madness::square | ( | const Function< T, NDIM > & | f, |
bool | fence = true |
||
) |
Create a new function that is the square of f - global comm only if not reconstructed.
References copy(), f, PROFILE_FUNC, and madness::Function< T, NDIM >::square().
Referenced by compute_energy(), madness::OEP::compute_mrks_correction(), madness::EigSolver< T, NDIM >::compute_rho(), main(), madness::SCF::make_density(), MiniDFT::make_density(), Calculation::make_reference(), nuclear_anchor_test(), run(), test_he_potential(), and test_math().
std::vector< Function<T,NDIM> > madness::square | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Computes the square of a vector of functions — q[i] = v[i]**2.
References v.
void madness::standard | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
bool | fence = true |
||
) |
Generates standard form of a vector of functions.
References change_tree_state(), compressed, PROFILE_BLOCK, and v.
Referenced by apply(), madness::FunctionImpl< T, NDIM >::change_tree_state(), and madness::FunctionImpl< R, NDIM >::do_print_grid().
void madness::standard | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Generates standard form of a vector of functions.
References madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
|
static |
References cpu_time(), madness::WorldGopInterface::fence(), madness::World::gop, sss, ttt, and wall_time().
Referenced by madness::SCF::analyze_vectors(), KPeriodicBSHOperator::apply(), apply_potential(), madness::SCF::apply_potential(), madness::SCF::compute_residual(), madness::SCF::derivatives(), madness::SCF::diag_fock_matrix(), madness::SCF::dipole(), madness::SCF::do_plots(), madness::SCF::initial_guess(), madness::SCF::kinetic_energy_matrix(), main(), make_coulomb_potential(), make_density(), madness::SCF::make_fock_matrix(), make_kinetic_matrix(), make_lda_potential(), madness::SCF::make_nuclear_potential(), Calculation::make_reference(), Calculation::make_Upsi(), makeao(), orthogonalize(), madness::SCF::orthonormalize(), madness::SCF::solve(), test_coulomb(), test_cross(), test_diff(), test_inner(), test_matrix_mul_sparse(), test_op(), test_rot(), test_transform(), and madness::SCF::update_subspace().
void madness::startup | ( | World & | world, |
int | argc, | ||
char ** | argv, | ||
bool | doprint = false , |
||
bool | make_stdcout_nice_to_reals = true |
||
) |
References arg(), cpu_frequency(), madness::WorldGopInterface::fence(), gauss_legendre_test(), madness::World::gop, init_tensor_lapack(), initialize_legendre_stuff(), load_coeffs(), load_quadrature(), MADNESS_CHECK, print(), madness::World::rank(), redirectio(), madness::FunctionDefaults< NDIM >::set_defaults(), madness::World::size(), test_two_scale_coefficients(), time_transform(), and xterm_debug().
Referenced by main(), main(), TEST_CASE(), test_G_R_vectors(), test_gaussian_num_coeffs(), test_he(), test_nuclear_energy(), test_nuclear_potential(), test_nuclear_potential2(), test_nuclear_potential3(), test_nuclear_potential_big_unit_cell(), testNavierStokes(), and testPeriodicCoulomb3d().
|
static |
References arg(), and MADNESS_EXCEPTION.
Referenced by madness::OEP::analyze(), madness::Nemo::compute_all_cphf(), madness::Nemo::compute_nemo_potentials(), madness::Zcis::compute_potentials(), madness::smooth< T, NDIM >::gaussian_smoothing(), madness::BasisFunctions::guess_virtuals_internal(), madness::OEP::iterate(), madness::Zcis::iterate(), madness::CC2::iterate_pair(), madness::CCPair::load_pair(), madness::ElectronPair::load_pair(), main(), madness::guessfactory::make_auto_polynom_strings(), madness::CCFunction< T, NDIM >::name(), madness::CCPair::name(), madness::Znemo::save_orbitals(), madness::smooth< T, NDIM >::smooth_density_from_orbitals(), solve(), madness::MP2::solve_coupled_equations(), madness::Nemo::solve_cphf(), madness::MP2::solve_residual_equations(), madness::CCPair::store_pair(), madness::ElectronPair::store_pair(), madness::smooth< T, NDIM >::test_1d(), test_adaptive_tree(), test_modified(), test_spherical_box(), and madness::Nemo::value().
Function<TENSOR_RESULT_TYPE(L,R),NDIM> madness::sub | ( | const Function< L, NDIM > & | left, |
const Function< R, NDIM > & | right, | ||
bool | fence = true |
||
) |
Same as operator-
but with optional fence and no automatic compression.
References gaxpy_oop(), L, R, and TENSOR_RESULT_TYPE().
Referenced by madness::TDHF::apply_G(), madness::Solver< T, NDIM >::compute_residual(), madness::SCF::compute_residual(), Calculation::compute_residuals(), madness::Znemo::do_step_restriction(), madness::SCF::do_step_restriction(), exchange_anchor_test(), exchange_anchor_test(), madness::TDHF::get_tda_potential(), madness::CC2::iterate_singles(), madness::TDHF::iterate_vectors(), madness::Nemo::kinetic_energy_potential(), madness::DNuclear< T, NDIM >::operator()(), operator-(), operator-(), q_c(), sub(), update(), and madness::SubspaceK< T, NDIM >::update_subspace().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::sub | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true |
||
) |
Returns new vector of functions — q[i] = a[i] - b[i].
References a, b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, sub(), T(), and TENSOR_RESULT_TYPE().
std::vector< Function<TENSOR_RESULT_TYPE(T,R), NDIM> > madness::sub | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | a, | ||
const std::vector< Function< R, NDIM > > & | b, | ||
bool | fence = true , |
||
unsigned int | blk = 1 |
||
) |
Returns new vector of functions — q[i] = a[i] - b[i].
References a, b, compress(), madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, sub(), T(), and TENSOR_RESULT_TYPE().
Function<T, NDIM> madness::sum | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | f, | ||
bool | fence = true |
||
) |
Returns new function — q = sum_i f[i].
References compress(), madness::FunctionFactory< T, NDIM >::compressed(), f, madness::WorldGopInterface::fence(), madness::Function< T, NDIM >::gaxpy(), and madness::World::gop.
Referenced by a(), madness::Molecule::atomic_attraction_potential(), b(), checksum_file(), chunk_example(), madness::F12Potentials::compute_cispd_f12_energies(), madness::NemoBase::compute_density(), madness::Nemo::compute_energy_regularized(), madness::NemoBase::compute_kinetic_energy2(), madness::OEP::compute_Pauli_kinetic_density(), div(), do_adq(), Node::do_sum(), doit(), dot(), dVdx(), dVdy(), dVdz(), errsq(), madness::FunctionImpl< T, NDIM >::eval_cube(), madness::AtomicBasisSet::eval_guess_density(), madness::AtomicBasis::eval_guess_density(), madness::ContractedGaussianShell::eval_radial(), fit(), gauss_legendre_test(), gaussian_func(), madness::PNO::get_average_rank(), madness::WorldDCPmapInterface< keyT >::global_size(), guess(), guess1s(), guess2s(), madness::Nemo::hessian(), TTT::hugh(), inner_func(), madness::FunctionImpl< T, NDIM >::inner_local(), inner_result(), madness::Nemo::kinetic_energy_potential(), madness::WorldDCPmapInterface< keyT >::local_size(), main(), A::member(), madness::Molecule::molecular_core_potential(), mTxmT(), madness::SeparatedConvolution< Q, NDIM >::munorm2_ns(), mxmT(), mxmT_reference(), madness::Molecule::n_core_orb_all(), madness::FunctionImpl< T, NDIM >::nCoeff(), madness::FunctionImpl< T, NDIM >::norm_tree_op(), madness::ContractedGaussianShell::normalize(), MolecularEntity::nuclear_attraction_potential(), madness::Molecule::nuclear_attraction_potential(), madness::Molecule::nuclear_dipole(), madness::Molecule::nuclear_repulsion_derivative(), MolecularEntity::nuclear_repulsion_energy(), madness::Molecule::nuclear_repulsion_energy(), madness::Molecule::nuclear_repulsion_second_derivative(), MolecularGuessDensityFunctor::operator()(), AtomicBasisFunctor< Q >::operator()(), NuclearDensityFunctor::operator()(), madness::WSTAtomicBasisFunctor::operator()(), Gaussian< T, NDIM >::operator()(), HeElectronicChargeDensityIGuess< T, NDIM >::operator()(), HeNuclearChargeDensityIGuess< T, NDIM >::operator()(), madness::ComplexExp< NDIM >::operator()(), DerivativeGaussian< T, NDIM >::operator()(), GaussianPotential::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local< R >::operator()(), BoysLocalization::operator()(), plot_line(), Calculation::plot_p(), madness::PNO::print_ranks(), madness::CCPairFunction< T, NDIM >::project_out_op_decomposed(), madness::FunctionImpl< T, NDIM >::real_size(), Adder::run(), madness::SDFEllipsoid::sdf(), madness::FunctionImpl< T, NDIM >::size(), madness::ConcurrentHashMap< keyT, valueT, hashfunT >::size(), Test7(), test_add(), test_xc2(), testf(), MolecularEntity::total_nuclear_charge(), madness::Molecule::total_nuclear_charge(), madness::FunctionImpl< T, NDIM >::trace_local(), madness::FunctionImpl< T, NDIM >::tree_size(), and V().
void madness::svd | ( | char | jobu, |
char | jobvt, | ||
integer | m, | ||
integer | n, | ||
complex_real4 * | A, | ||
integer | lda, | ||
real4 * | S, | ||
complex_real4 * | U, | ||
integer | ldu, | ||
complex_real4 * | VT, | ||
integer | ldvt | ||
) |
References cgesvd_(), LINALG_ASSERT, m, and madness::cblas::to_cptr().
void madness::svd | ( | char | jobu, |
char | jobvt, | ||
integer | m, | ||
integer | n, | ||
complex_real8 * | A, | ||
integer | lda, | ||
real8 * | S, | ||
complex_real8 * | U, | ||
integer | ldu, | ||
complex_real8 * | VT, | ||
integer | ldvt | ||
) |
References LINALG_ASSERT, m, madness::cblas::to_zptr(), and zgesvd_().
void madness::svd | ( | char | jobu, |
char | jobvt, | ||
integer | m, | ||
integer | n, | ||
real4 * | A, | ||
integer | lda, | ||
real4 * | S, | ||
real4 * | U, | ||
integer | ldu, | ||
real4 * | VT, | ||
integer | ldvt | ||
) |
References LINALG_ASSERT, m, and sgesvd_().
void madness::svd | ( | char | jobu, |
char | jobvt, | ||
integer | m, | ||
integer | n, | ||
real8 * | A, | ||
integer | lda, | ||
real8 * | S, | ||
real8 * | U, | ||
integer | ldu, | ||
real8 * | VT, | ||
integer | ldvt | ||
) |
References dgesvd_(), LINALG_ASSERT, and m.
void madness::svd | ( | char | jobu, |
char | jobvt, | ||
integer | m, | ||
integer | n, | ||
T * | A, | ||
integer | lda, | ||
typename detail::real_type< T >::type * | S, | ||
T * | U, | ||
integer | ldu, | ||
T * | VT, | ||
integer | ldvt | ||
) |
Compute the SVD via LAPACK.
template void madness::svd | ( | const Tensor< double > & | a, |
Tensor< double > & | U, | ||
Tensor< Tensor< double >::scalar_type > & | s, | ||
Tensor< double > & | VT | ||
) |
template void madness::svd | ( | const Tensor< double_complex > & | a, |
Tensor< double_complex > & | U, | ||
Tensor< Tensor< double_complex >::scalar_type > & | s, | ||
Tensor< double_complex > & | VT | ||
) |
template void madness::svd | ( | const Tensor< float > & | a, |
Tensor< float > & | U, | ||
Tensor< Tensor< float >::scalar_type > & | s, | ||
Tensor< float > & | VT | ||
) |
template void madness::svd | ( | const Tensor< float_complex > & | a, |
Tensor< float_complex > & | U, | ||
Tensor< Tensor< float_complex >::scalar_type > & | s, | ||
Tensor< float_complex > & | VT | ||
) |
void madness::svd | ( | const Tensor< T > & | a, |
Tensor< T > & | U, | ||
Tensor< typename Tensor< T >::scalar_type > & | s, | ||
Tensor< T > & | VT | ||
) |
Compute the singluar value decomposition of an n-by-m matrix using *gesvd.
Computes singular value decomposition of matrix.
Returns via arguments U, s, VT where
A = U * diag(s) * VT for A real A = U * diag(s) * VH for A complex
or
UT * A * V = diag(s) for A real UH * A * V = diag(s) for A complex
If A is [m,n] and r=min(m,n) then we have U[m,r], s[r], and VT[r,n]
On failure, throws TensorException with value set to Lapack's info.
References A(), a, copy(), gesvd_(), m, mask_info(), max, madness::Tensor< T >::ptr(), and TENSOR_ASSERT.
Referenced by madness::SVDTensor< T >::compute_svd(), madness::SVDTensor< T >::compute_svd_from_range(), DF::diagonalize(), madness::SCF::initial_guess(), madness::ConvolutionData1D< Q >::make_approx(), madness::RandomizedMatrixDecomposition< T >::make_SVD_decaying_matrix(), ortho3(), ortho5(), madness::SVDTensor< T >::recompute_from_range(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::TensorTrain< T >::splitdim(), svd(), test_constructor(), test_stuff(), test_svd(), and madness::Localizer::undo_rotation().
template void madness::svd_result | ( | Tensor< double > & | a, |
Tensor< double > & | U, | ||
Tensor< Tensor< double >::scalar_type > & | s, | ||
Tensor< double > & | VT, | ||
Tensor< double > & | work | ||
) |
template void madness::svd_result | ( | Tensor< double_complex > & | a, |
Tensor< double_complex > & | U, | ||
Tensor< Tensor< double_complex >::scalar_type > & | s, | ||
Tensor< double_complex > & | VT, | ||
Tensor< double_complex > & | work | ||
) |
template void madness::svd_result | ( | Tensor< float > & | a, |
Tensor< float > & | U, | ||
Tensor< Tensor< float >::scalar_type > & | s, | ||
Tensor< float > & | VT, | ||
Tensor< float > & | work | ||
) |
template void madness::svd_result | ( | Tensor< float_complex > & | a, |
Tensor< float_complex > & | U, | ||
Tensor< Tensor< float_complex >::scalar_type > & | s, | ||
Tensor< float_complex > & | VT, | ||
Tensor< float_complex > & | work | ||
) |
void madness::svd_result | ( | Tensor< T > & | a, |
Tensor< T > & | U, | ||
Tensor< typename Tensor< T >::scalar_type > & | s, | ||
Tensor< T > & | VT, | ||
Tensor< T > & | work | ||
) |
same as svd, but it optimizes away the tensor construction: a = U * diag(s) * VT
note that S and VT are swapped in the calling list for c/fortran consistency!
[in,out] | a | a (m,n) matrix to be svd'ed; upon return will hold VT the first min(m,n) rows of VT, stored rowwise |
[in,out] | U | left singular vectors, stored columnwise |
[in,out] | s | the singular values |
[in,out] | VT | not referenced |
[in,out] | work | work array; optimial length lwork: lwork = max<integer>(3*min(m,n)+max(m,n),5*min(m,n)-4)*32; |
References a, gesvd_(), m, mask_info(), madness::Tensor< T >::ptr(), madness::BaseTensor::size(), and TENSOR_ASSERT.
Referenced by madness::TensorTrain< T >::decompose(), rank_revealing_decompose(), and madness::TensorTrain< T >::truncate().
void madness::swap | ( | RemoteReference< T > & | l, |
RemoteReference< U > & | r | ||
) |
Swap the two remote references.
l | The left reference to be swapped with r |
r | The right reference to be swapped with l |
References madness::RemoteReference< T >::swap().
Referenced by madness::RemoteReference< T >::swap().
Swap the contents of two Vector
s.
References madness::Vector< T, N >::swap().
Referenced by madness::Fock< T, NDIM >::Fock(), madness::TensorIterator< T, Q, R >::TensorIterator(), madness::SRConf< T >::add_SVD(), madness::SRConf< T >::append(), madness::CCPairFunction< T, NDIM >::apply(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation2(), DF::diagonalize(), fast_transform(), PNOTensors::Tensor_IJ_IK< T >::get(), PNOTensors::Tensor_IJ_KJ< T >::get(), madness::CC2::initialize_pairs(), inner(), madness::SRConf< T >::inplace_add(), jacobi(), madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()(), slymer::PolynomialCoeffs::operator+=(), madness::cartesian_grid< NDIM >::operator=(), madness::LowRankFunction< T, NDIM, LDIM >::operator=(), madness::SVDTensor< T >::orthonormalize(), madness::LBNodeDeux< NDIM >::partition(), random_perm(), slymer::read_endian(), slymer::NWChem_Interface::read_movecs(), PNOTensors::Tensor_IJ_IK< T >::set(), PNOTensors::Tensor_IJ_KJ< T >::set(), madness::WorldGopInterface::set_max_reducebcast_msg_size(), madness::TDHF::solve_cis(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::swap_particles_inplace(), madness::Molecule::swapaxes(), test_lowrank_function(), madness::Localizer::undo_reordering(), madness::Zcis::value(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().
std::enable_if_t<NDIM%2==0, Function<T,NDIM> > madness::swap_particles | ( | const Function< T, NDIM > & | f | ) |
swap particles 1 and 2
param[in] f a function of 2 particles f(1,2) return the input function with particles swapped g(1,2) = f(2,1)
References d(), f, mapdim(), and NDIM.
Referenced by madness::MP2::asymmetry(), madness::CC2::compute_local_coupling(), and madness::TwoBodyFunctionPureComponent< T, NDIM >::swap_particles_inplace().
template void madness::syev | ( | const Tensor< double > & | A, |
Tensor< double > & | V, | ||
Tensor< Tensor< double >::scalar_type > & | e | ||
) |
template void madness::syev | ( | const Tensor< double_complex > & | A, |
Tensor< double_complex > & | V, | ||
Tensor< Tensor< double_complex >::scalar_type > & | e | ||
) |
void madness::syev | ( | const Tensor< T > & | A, |
Tensor< T > & | V, | ||
Tensor< typename Tensor< T >::scalar_type > & | e | ||
) |
Real-symmetric or complex-Hermitian eigenproblem.
Solves symmetric or Hermitian eigenvalue problem.
A is a real symmetric or complex Hermitian matrix. Return V and e where V is a matrix whose columns are the eigenvectors and e is a vector containing the corresponding eigenvalues. If the LAPACK routine fails, it raises a TensorException with value=infor. The input matrix is unchanged. The eigenvalues are sorted into ascending order. s/dsyev are used for real symmetric matrices; c/zheev are used for complex Hermitian.
The results will satisfy A*V(_,i) = V(_,i)*e(i).
References e(), mask_info(), max, madness::Tensor< T >::ptr(), syev_(), TENSOR_ASSERT, transpose(), and V().
Referenced by madness::projector_irrep::apply_symmetry_operators(), madness::PNO::canonicalize(), madness::OEP::compute_and_print_final_energies(), compute_frequencies(), madness::OEP::compute_ocep_correction(), madness::Solver< T, NDIM >::csqrt(), madness::Localizer::determine_frozen_orbitals(), fixphases(), madness::Solver< T, NDIM >::initial_guess(), madness::Zcis::make_guess(), madness::TDHF::make_guess_from_initial_diagonalization(), QuasiNewton::new_search_direction(), madness::QuasiNewton::new_search_direction(), madness::MolecularOptimizer::new_search_direction2(), madness::MolecularOptimizer::optimize_quasi_newton(), madness::Molecule::orient(), orth(), ortho3(), ortho5(), orthonormalize_canonical(), orthonormalize_symmetric(), madness::PNO::pno_compress(), madness::Solver< T, NDIM >::print_fock_matrix_eigs(), projector_external_dof(), madness::MolecularOptimizer::projector_external_dof(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::Solver< T, NDIM >::solve(), madness::OEP::solve(), syev(), and test_syev().
template void madness::sygv | ( | const Tensor< double > & | A, |
const Tensor< double > & | B, | ||
int | itype, | ||
Tensor< double > & | V, | ||
Tensor< Tensor< double >::scalar_type > & | e | ||
) |
template void madness::sygv | ( | const Tensor< double_complex > & | A, |
const Tensor< double_complex > & | B, | ||
int | itype, | ||
Tensor< double_complex > & | V, | ||
Tensor< Tensor< double_complex >::scalar_type > & | e | ||
) |
void madness::sygv | ( | const Tensor< T > & | A, |
const Tensor< T > & | B, | ||
int | itype, | ||
Tensor< T > & | V, | ||
Tensor< typename Tensor< T >::scalar_type > & | e | ||
) |
Generalized real-symmetric or complex-Hermitian eigenproblem.
Solves symmetric or Hermitian generalized eigenvalue problem.
This from the LAPACK documentation
S/DSYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be symmetric and B is also positive definite. C/ZHEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite. ITYPE (input) INTEGER Specifies the problem type to be solved: = 1: A*x = (lambda)*B*x = 2: A*B*x = (lambda)*x = 3: B*A*x = (lambda)*x
References b, e(), mask_info(), max, madness::Tensor< T >::ptr(), sygv_(), TENSOR_ASSERT, transpose(), and V().
Referenced by madness::Znemo::canonicalize(), diag_and_transform(), DF::diagonalize(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), MiniDFT::doit(), doit(), madness::Solver< T, NDIM >::initial_guess(), initial_guess(), main(), madness::Zcis::orthonormalize(), madness::Solver< T, NDIM >::print_fock_matrix_eigs(), madness::Solver< T, NDIM >::print_potential_matrix_eigs(), sygvp(), and test_sygv().
void madness::sygvp | ( | World & | world, |
const Tensor< T > & | a, | ||
const Tensor< T > & | B, | ||
int | itype, | ||
Tensor< T > & | V, | ||
Tensor< typename Tensor< T >::scalar_type > & | e | ||
) |
References a, madness::WorldGopInterface::broadcast_serializable(), e(), madness::World::gop, sygv(), and V().
Referenced by madness::Zcis::canonicalize(), get_fock_transformation(), madness::SCF::get_fock_transformation(), madness::Znemo::hcore_guess(), madness::SCF::initial_guess(), and madness::SCF::solve().
unsigned int madness::symbol_to_atomic_number | ( | const std::string & | symbol | ) |
References atomic_data, lowercase(), NUMBER_OF_ATOMS_IN_TABLE, and madness::AtomicData::symbol_lowercase.
Referenced by Calculation::Calculation(), get_charge_from_file(), madness::SCF::initial_guess(), madness::GTHPseudopotential< Q >::load_pseudo_from_file(), madness::Molecule::read(), MolecularEntity::read_file(), madness::AtomicBasisSet::read_file(), madness::CorePotentialManager::read_file(), madness::AtomicBasisSet::read_nw_file(), madness::Molecule::read_xyz(), and madness::InitParameters::readnw().
Function<T,NDIM> madness::symmetrize | ( | const Function< T, NDIM > & | f, |
const std::string | symmetry, | ||
bool | fence = true |
||
) |
symmetrize a function
[in] | symmetry | possibilities are: (anti-) symmetric particle permutation ("sy_particle", "antisy_particle") symmetric mirror plane ("xy", "xz", "yz") |
References f, madness::Function< T, NDIM >::get_impl(), MADNESS_ASSERT, MADNESS_EXCEPTION, madness::Function< T, NDIM >::mapdim(), NDIM, and print().
Referenced by test_adaptive_tree().
References abs(), BINARY_OPTIMIZED_ITERATOR, c, and Q().
Tensor< std::complex<Q> > madness::tensor_real2complex | ( | const Tensor< Q > & | r | ) |
References BINARY_OPTIMIZED_ITERATOR, c, madness::BaseTensor::dims(), madness::BaseTensor::ndim(), and Q().
Computes the scalar/inner product between two functions.
In Maple this would be int
(conjugate(f(x))*g(x),x=-infinity..infinity)
inner function with right signature for the nonlinear solver this is needed for the KAIN solvers and other functions
References f, g, inner(), and MADNESS_ASSERT.
Referenced by add(), madness::SeparatedConvolution< Q, NDIM >::apply(), apply(), madness::SeparatedConvolution< Q, NDIM >::apply2(), madness::SeparatedConvolution< Q, NDIM >::apply2_lowdim(), apply_1d_realspace_push(), apply_only(), binary_op(), cross(), fast_transform(), gaxpy(), gaxpy_oop(), general_transform(), inner(), inner_result(), innerXX(), matrix_inner(), matrix_inner_old(), mul(), mul_sparse(), operator*(), outer(), sub(), test_cross(), test_inner(), madness::SRConf< T >::trace(), madness::TensorTrain< T >::trace(), transform(), transform_dir(), transform_reconstructed(), and vmulXX().
madness::TENSOR_RESULT_TYPE | ( | T | , |
typename opT::value_type | |||
) | const |
Computes the scalar/inner product between an MRA function and an external functor.
Currently this defaults to inner_adaptive, which might be more expensive than inner_ext since it loops over all leaf nodes. If you feel inner_ext is more efficient you need to call it directly
[in] | f | MRA function |
[in] | g | functor |
References PROFILE_FUNC.
madness::TENSOR_RESULT_TYPE | ( | T | , |
typename opT::value_type | |||
) | const & |
Computes the scalar/inner product between an MRA function and an external functor.
Currently this defaults to inner_adaptive, which might be more expensive than inner_ext since it loops over all leaf nodes. If you feel inner_ext is more efficient you need to call it directly
[in] | g | functor |
[in] | f | MRA function |
References BINARY_OPTIMIZED_ITERATOR, c, imag(), and Q().
References BINARY_OPTIMIZED_ITERATOR, c, Q(), and real().
|
static |
Referenced by madness::smooth< T, NDIM >::test_1d().
bool madness::test_autoc | ( | ) |
References autocorr_filename, and checksum_file().
Referenced by read_data().
double madness::test_cholesky | ( | int | n | ) |
References a, aa, cholesky(), copy(), inner(), and my_conj_transpose().
int madness::test_exchange | ( | World & | world | ) |
References alpha, conj(), exchange_anchor_test(), madness::Tensor< T >::fill(), madness::FunctionFactory< T, NDIM >::functor(), madness::FunctionDefaults< NDIM >::get_thresh(), K(), name(), print(), madness::World::rank(), madness::FunctionDefaults< NDIM >::set_cubic_cell(), madness::FunctionDefaults< NDIM >::set_thresh(), smalltest, T(), thresh, madness::FunctionFactory< T, NDIM >::thresh(), and madness::FunctionFactory< T, NDIM >::truncate_on_project().
Referenced by main().
double madness::test_gelss | ( | int | n, |
int | nrhs | ||
) |
double madness::test_gesv | ( | int | n, |
int | nrhs | ||
) |
double madness::test_inverse | ( | int | n | ) |
Example and test code for interface to LAPACK SVD interfae.
References A(), inner(), inverse(), madness::Tensor< T >::normf(), and madness::BaseTensor::size().
double madness::test_qr | ( | ) |
References copy(), error(), madness::Tensor< T >::fillrandom(), inner(), lq(), m, qr(), R, and RandomValue< long >().
bool madness::test_rnlp | ( | ) |
double madness::test_rr_cholesky | ( | int | n | ) |
References a, aa, copy(), inner(), my_conj_transpose(), P, rr_cholesky(), and transpose().
double madness::test_svd | ( | int | n, |
int | m | ||
) |
double madness::test_syev | ( | int | n | ) |
double madness::test_sygv | ( | int | n | ) |
bool madness::test_tensor_lapack | ( | ) |
bool madness::test_two_scale_coefficients | ( | ) |
|
static |
|
static |
References c, cpu_time(), e(), fast_transform(), madness::World::gop, madness::WorldGopInterface::max(), madness::WorldGopInterface::min(), N, and w().
Referenced by startup().
auto madness::to_conjugate_response_matrix | ( | const X_space & | x | ) | -> response_matrix |
References b.
auto madness::to_conjugate_X_space | ( | const response_matrix & | x | ) | -> X_space |
response_matrix [x,y] -> Xspace X.x=y X.y=conjugate(x)
x |
References b, madness::World::size(), transform(), and xi.
auto madness::to_flattened_vector | ( | const X_space & | x | ) | -> vector_real_function_3d |
Flattens all response functions into a single vector of functions.
x |
References b, copy(), and to_response_matrix().
Referenced by madness::X_space::component_norm2s().
void madness::to_json | ( | nlohmann::json & | j | ) |
auto madness::to_response_matrix | ( | const X_space & | x | ) | -> response_matrix |
@ Converts Xspace object to response_matrix object
x |
References b.
Referenced by ground_exchange(), madness::X_space::norm2s(), to_flattened_vector(), and madness::X_space::truncate().
auto madness::to_response_vector | ( | const vector_real_function_3d & | vec | ) | -> vector_real_function_3d |
auto madness::to_X_space | ( | const response_matrix & | x | ) | -> X_space |
References b, copy(), and madness::World::size().
Referenced by molresponseExchange().
SVDTensor<TENSOR_RESULT_TYPE(R,Q)> madness::transform | ( | const SVDTensor< R > & | t, |
const Tensor< Q > & | c | ||
) |
TensorTrain<TENSOR_RESULT_TYPE(T,Q)> madness::transform | ( | const TensorTrain< T > & | t, |
const Tensor< Q > & | c | ||
) |
transform each dimension with the same operator matrix
result(i,j,k...) <– sum(i',j', k',...) t(i',j',k',...) c(i',i) c(j',j) c(k',k) ... TODO: merge this with general_transform
References c, copy(), madness::TensorTrain< T >::core, d(), madness::BaseTensor::dims(), inner(), inner_result(), max, madness::BaseTensor::ndim(), Q(), r2(), T(), TENSOR_RESULT_TYPE(), and madness::TensorTrain< T >::zero_rank.
std::vector< Function<TENSOR_RESULT_TYPE(L,R),NDIM> > madness::transform | ( | World & | world, |
const std::vector< Function< L, NDIM > > & | v, | ||
const Tensor< R > & | c, | ||
const double | tol, | ||
const unsigned int | blki = 1 , |
||
const bool | fence | ||
) |
References c, compress(), madness::WorldGopInterface::fence(), madness::World::gop, L, m, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, TENSOR_RESULT_TYPE(), and v.
std::vector< Function<TENSOR_RESULT_TYPE(L,R),NDIM> > madness::transform | ( | World & | world, |
const std::vector< Function< L, NDIM > > & | v, | ||
const Tensor< R > & | c, | ||
double | tol, | ||
bool | fence | ||
) |
this version of transform uses Function::vtransform and screens using both elements of c
and v
References c, compress(), L, MADNESS_ASSERT, NDIM, PROFILE_BLOCK, R, TENSOR_RESULT_TYPE(), and v.
std::vector< Function<TENSOR_RESULT_TYPE(T,R),NDIM> > madness::transform | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const DistributedMatrix< R > & | c, | ||
bool | fence = true |
||
) |
References c, compress(), madness::WorldGopInterface::fence(), madness::World::gop, m, MADNESS_ASSERT, PROFILE_FUNC, R, T(), TENSOR_RESULT_TYPE(), transpose(), and v.
std::vector< Function<TENSOR_RESULT_TYPE(T,R),NDIM> > madness::transform | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const Tensor< R > & | c, | ||
bool | fence = true |
||
) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
Uses sparsity in the transformation matrix — set small elements to zero to take advantage of this.
References c, compress(), madness::WorldGopInterface::fence(), madness::World::gop, m, MADNESS_ASSERT, PROFILE_BLOCK, R, T(), TENSOR_RESULT_TYPE(), and v.
Referenced by madness::BSHApply< T, NDIM >::add_coupling_and_levelshift(), madness::GTHPseudopotential< Q >::apply_potential(), madness::projector_irrep::apply_symmetry_operators(), madness::Zcis::canonicalize(), madness::TDHF::canonicalize(), madness::Znemo::canonicalize(), madness::FunctionCommonFunctionality< T, NDIM >::coeffs2values(), madness::FunctionImpl< T, NDIM >::coeffs2values(), madness::Nemo::compute_cphf_parallel_term(), madness::OEP::compute_energy_weighted_density_local(), madness::CC2::compute_local_coupling(), madness::SCF::compute_residual(), diag_and_transform(), madness::SCF::diag_fock_matrix(), madness::FunctionImpl< T, NDIM >::do_binary_op(), madness::FunctionImpl< T, NDIM >::do_mul(), madness::Solver< T, NDIM >::do_rhs(), madness::Solver< T, NDIM >::do_rhs_simple(), MiniDFT::doit(), doit(), madness::FunctionImpl< T, NDIM >::filter(), fixphases(), madness::Convolution1D< Q >::get_rnlp(), madness::TDHF::get_tda_potential(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), madness::Znemo::hcore_guess(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), initial_guess(), inner(), madness::OEP::iterate(), Calculation::load_mos(), madness::Localizer::localize(), madness::Nemo::localize(), main(), mix(), madness::Convolution1D< Q >::mod_nonstandard(), madness::FunctionImpl< T, NDIM >::mul(), madness::Convolution1D< Q >::nonstandard(), madness::FunctionImpl< T, NDIM >::NScoeffs2values(), madness::Projector< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_unary_op_value_inplace< opT >::operator()(), orth(), orthonormalize(), madness::NemoBase::orthonormalize(), orthonormalize(), madness::Solver< T, NDIM >::orthonormalize(), madness::SCF::orthonormalize(), orthonormalize_canonical(), orthonormalize_cd(), orthonormalize_fock(), orthonormalize_rrcd(), orthonormalize_symmetric(), madness::FunctionImpl< T, NDIM >::parent_to_child(), madness::MolecularOrbitals< T, NDIM >::project_ao(), madness::InitParameters::readnw(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::SCF::restart_aos(), madness::Znemo::rotate_subspace(), madness::Nemo::rotate_subspace(), madness::SCF::rotate_subspace(), madness::Localizer::separate_core_valence(), madness::Nemo::solve(), madness::SCF::solve(), madness::Nemo::solve_cphf(), Test7(), test_transform(), madness::PNO::transform_pairs(), madness::FunctionImpl< T, NDIM >::unfilter(), madness::FunctionCommonFunctionality< T, NDIM >::values2coeffs(), madness::FunctionImpl< T, NDIM >::values2coeffs(), and madness::FunctionImpl< T, NDIM >::values2NScoeffs().
std::vector< Function<TENSOR_RESULT_TYPE(T,R),NDIM> > madness::transform | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const Tensor< R > & | c, | ||
unsigned int | blki = 1 , |
||
unsigned int | blkj = 1 , |
||
const bool | fence = true |
||
) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
Uses sparsity in the transformation matrix — set small elements to zero to take advantage of this.
References c, compress(), madness::WorldGopInterface::fence(), gaxpy(), madness::World::gop, m, MADNESS_ASSERT, PROFILE_BLOCK, R, T(), TENSOR_RESULT_TYPE(), and v.
GenTensor<TENSOR_RESULT_TYPE(R,Q)> madness::transform_dir | ( | const GenTensor< R > & | t, |
const Tensor< Q > & | c, | ||
const int | axis | ||
) |
[in] | t | Tensor to transform (size of dim to be transformed must match size of first dim of c ) |
[in] | c | Matrix used for the transformation |
[in] | axis | Dimension (or axis) to be transformed |
Referenced by madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push_op(), madness::Derivative< T, NDIM >::do_diff2b(), madness::Derivative< T, NDIM >::do_diff2i(), and madness::SRConf< T >::transform_dir().
SVDTensor<TENSOR_RESULT_TYPE(R,Q)> madness::transform_dir | ( | const SVDTensor< R > & | t, |
const Tensor< Q > & | c, | ||
const int | axis | ||
) |
std::vector< Function<TENSOR_RESULT_TYPE(T,R),NDIM> > madness::transform_reconstructed | ( | World & | world, |
const std::vector< Function< T, NDIM > > & | v, | ||
const Tensor< R > & | c, | ||
bool | fence = true |
||
) |
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
all trees are in reconstructed state, final trees have to be summed down if no fence is present
References c, change_tree_state(), madness::WorldGopInterface::fence(), get_impl(), madness::World::gop, m, MADNESS_CHECK, MADNESS_CHECK_THROW, PROFILE_BLOCK, R, reconstructed, redundant_after_merge, T(), TENSOR_RESULT_TYPE(), and v.
Referenced by madness::CCPairFunction< T, NDIM >::collect_same_types(), and test_transform().
response_space madness::transpose | ( | response_space & | f | ) |
References f, g, m, and MADNESS_ASSERT.
Referenced by madness::Convolution1D< Q >::Convolution1D(), madness::FunctionCommonData< T, NDIM >::_init_quadrature(), madness::FunctionCommonData< T, NDIM >::_init_twoscale(), madness::SCF::analyze_vectors(), madness::PNO::compute_cispd_correction_es(), madness::PNO::compute_cispd_correction_gs(), madness::PNO::compute_cispd_fluctuation_matrix(), madness::Localizer::compute_core_valence_separation_transformation_matrix(), madness::F12Potentials::compute_f12_correction(), madness::PNO::compute_fluctuation_matrix(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), madness::PNO::compute_projected_mp2_energies(), madness::F12Potentials::compute_regularized_fluctuation_matrix(), madness::SVDTensor< T >::compute_svd(), madness::GenTensor< T >::convert_inplace(), DF::diagonalize(), MiniDFT::doit(), gelss(), geqp3(), gesv(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), ggev(), madness::Nemo::hessian(), madness::Derivative< T, NDIM >::initCoefficients(), madness::SCF::initial_guess(), initial_guess(), madness::Localizer::localize(), madness::Nemo::localize(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), madness::TDHF::make_cis_matrix(), madness::SCF::make_fock_matrix(), madness::AtomicBasisSet::modify_dmat_psp(), my_conj_transpose(), madness::TwoBodyFunctionPureComponent< T, NDIM >::name(), madness::TwoBodyFunctionSeparatedComponent< T, NDIM >::name(), madness::CCPairFunction< T, NDIM >::name(), BoysLocalization::operator()(), orgqr(), ortho5(), orthonormalize_cd(), madness::PNO::orthonormalize_cholesky(), orthonormalize_rrcd(), orthonormalize_symmetric(), projector_external_dof(), madness::MolecularOptimizer::projector_external_dof(), qr(), madness::Derivative< T, NDIM >::read_from_file(), madness::Convolution1D< Q >::rnlij(), madness::SCF::solve(), syev(), sygv(), test_lowrank_function(), test_rr_cholesky(), test_syev(), transform(), and madness::Localizer::undo_rotation().
auto madness::transposeResponseMatrix | ( | const response_matrix & | x | ) | -> response_matrix |
std::vector< Function<T,NDIM> > madness::truncate | ( | std::vector< Function< T, NDIM > > | v, |
double | tol = 0.0 , |
||
bool | fence = true |
||
) |
Truncates a vector of functions.
References truncate(), and v.
void madness::truncate | ( | World & | world, |
response_space & | v, | ||
double | tol, | ||
bool | fence | ||
) |
References MADNESS_ASSERT, and v.
Referenced by madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::ExchangeImpl(), madness::F12Potentials::F12Potentials(), SVPESolver::SVPESolver(), madness::CCPairFunction< T, NDIM >::apply(), KPeriodicBSHOperator::apply(), apply_bsh(), apply_potential(), madness::Diamagnetic_potential_factor::apply_potential(), madness::GTHPseudopotential< Q >::apply_potential(), madness::SCF::apply_potential(), madness::F12Potentials::apply_regularized_potential(), madness::projector_irrep::apply_symmetry_operators(), madness::NuclearCorrelationFactor::apply_U(), apply_U_ncf(), Calculation::calc_optimal_coeffs(), madness::Nemo::compute_all_cphf(), madness::PNO::compute_CIS_potentials(), madness::OEP::compute_coulomb_potential(), madness::Nemo::compute_cphf_parallel_term(), madness::Znemo::compute_current_density(), compute_energy(), madness::Nemo::compute_energy_regularized(), madness::OEP::compute_exchange_potential(), madness::Nemo::compute_fock_matrix(), madness::F12Potentials::compute_fQg_integrals(), madness::F12Potentials::compute_fQU_integrals(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::compute_K_tile(), madness::Diamagnetic_potential_factor::compute_nabla_R_div_R(), madness::Nemo::compute_nemo_potentials(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::MacroTaskExchangeSimple::compute_offdiagonal_batch_in_symmetric_matrix(), madness::Coulomb< T, NDIM >::compute_potential(), madness::Znemo::compute_potentials(), madness::Zcis::compute_potentials(), madness::SCF::compute_residual(), madness::Znemo::compute_residuals(), madness::Zcis::compute_residuals(), Calculation::compute_residuals(), madness::PNO::compute_V_aj_i(), madness::Znemo::compute_vmat(), madness::PNO::compute_Vreg_aj_i(), madness::F12Potentials::compute_xyab_integrals(), madness::F12Potentials::convolve_with_fg(), madness::F12Potentials::convolve_with_fU(), madness::F12Potentials::convolve_with_local_U(), madness::F12Potentials::convolve_with_nonlocal_U(), madness::F12Potentials::convolve_with_U(), madness::SCF::diag_fock_matrix(), MiniDFT::doit(), doit(), madness::HartreeFock< T, NDIM >::get_coulomb_potential(), madness::TDHF::get_tda_potential(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::Znemo::hcore_guess(), madness::Nemo::hessian(), madness::Solver< T, NDIM >::initial_guess(), madness::SCF::initial_guess(), madness::PNO::initialize_pairs(), madness::CCPairFunction< T, NDIM >::inner_internal(), madness::Znemo::iterate(), madness::OEP::iterate(), iterate(), madness::Zcis::iterate(), madness::CC2::iterate_singles(), madness::TDHF::iterate_vectors(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_large_memory(), madness::Exchange< T, NDIM >::ExchangeImpl< T, NDIM >::K_small_memory(), Calculation::load_mos(), madness::Localizer::localize(), madness::Nemo::localize(), main(), madness::Znemo::make_bra(), madness::Nemo::make_cphf_constant_term(), madness::Zcis::make_guess(), madness::TDHF::make_guess_from_initial_diagonalization(), madness::Nemo::make_laplacian_density(), madness::TDHF::make_mo_bra(), madness::TDHF::make_mo_ket(), Calculation::make_reference(), GygiPot::make_surfcharge(), madness::MP2::make_Uphi0(), Calculation::make_Upsi(), AnsatzBase::make_vbra(), MiniDFT::makeao(), makeao_slow(), madness::EigSolver< T, NDIM >::multi_solve(), madness::CCConvolutionOperator< T, NDIM >::operator()(), madness::Coulomb< T, NDIM >::MacroTaskCoulomb::operator()(), madness::Nuclear< T, NDIM >::operator()(), madness::LocalPotentialOperator< T, NDIM >::operator()(), madness::BSHApply< T, NDIM >::operator()(), madness::DNuclear< T, NDIM >::operator()(), madness::Projector< T, NDIM >::operator()(), madness::QProjector< T, NDIM >::operator()(), madness::LowRankFunction< T, NDIM, LDIM >::optimize(), madness::LowRankFunction< T, NDIM, LDIM >::orthonormalize(), orthonormalize(), madness::NemoBase::orthonormalize(), orthonormalize(), madness::SCF::orthonormalize(), SurfaceMoleculeInteraction::perturbed_molecular_pot(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), madness::SCF::project(), madness::MolecularOrbitals< T, NDIM >::project_ao(), madness::SCF::project_ao_basis_only(), madness::projector_irrep::project_on_irreps(), GroundStateCalculation::read(), madness::Znemo::read_real_guess(), madness::OEP::recompute_HF(), madness::LowRankFunction< T, NDIM, LDIM >::reorthonormalize(), madness::Solver< T, NDIM >::reproject(), madness::SCF::restart_aos(), schrodinger2dirac(), SVPESolver::solve(), madness::Nemo::solve(), madness::SCF::solve(), madness::MP2::solve_coupled_equations(), madness::Nemo::solve_cphf(), madness::MP2::solve_residual_equations(), test(), madness::PNO::transform_pairs(), madness::X_space::truncate(), truncate(), madness::PNO::truncate_pairs(), madness::SCF::twoint(), update(), MiniDFT::update(), madness::PNO::update_pno(), and madness::Nemo::value().
void madness::truncate | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
double | tol = 0.0 , |
||
bool | fence = true |
||
) |
Truncates a vector of functions.
References compress(), madness::WorldGopInterface::fence(), madness::World::gop, NDIM, PROFILE_BLOCK, and v.
void madness::truncate | ( | World & | world, |
std::vector< Function< T, NDIM > > & | v, | ||
double | tol = 0.0 , |
||
unsigned int | blk = 1 , |
||
bool | fence = true |
||
) |
Truncates a vector of functions.
References compress(), madness::WorldGopInterface::fence(), madness::World::gop, PROFILE_BLOCK, and v.
Attempt to acquire two locks without blocking holding either one.
The code will first attempt to acquire mutex m1 and if successful will then attempt to acquire mutex m2.
References madness::Mutex::try_lock(), and madness::Mutex::unlock().
TensorTrain<T> madness::tt_identity | ( | const long | ndim, |
const long | k | ||
) |
compute the n-D identity operator with k elements per dimension
References madness::TensorTrain< T >::get_core(), and k.
bool madness::two_scale_coefficients | ( | int | k, |
Tensor< double > * | h0, | ||
Tensor< double > * | h1, | ||
Tensor< double > * | g0, | ||
Tensor< double > * | g1 | ||
) |
Return the two scale coefficients in the Legendre basis.
Returns true on success, false on failure (and prints error message)
References cache, copy(), k, kmax, loaded, and read_twoscale().
Referenced by two_scale_hg().
bool madness::two_scale_hg | ( | int | k, |
Tensor< double > * | hg | ||
) |
References k, and two_scale_coefficients().
Referenced by madness::Convolution1D< Q >::Convolution1D(), madness::FunctionCommonData< T, NDIM >::_init_twoscale(), and test_two_scale_coefficients().
|
inline |
|
inline |
|
inline |
Referenced by slymer::GaussianFunction::GaussianFunction(), madness::GFit< T, NDIM >::GFit(), slymer::PrimitiveGaussian::PrimitiveGaussian(), madness::TDHF::apply_G(), madness::SeparatedConvolution< Q, NDIM >::can_combine(), CCConvolutionOperatorPtr(), madness::CCConvolutionOperator< T, NDIM >::clear_intermediates(), madness::detail::compare_fn_addresses(), get_index_of_first_vector_argument(), madness::BasisFunctions::guess_contracted_virtuals_from_file(), madness::BasisFunctions::guess_with_exop(), madness::CCConvolutionOperator< T, NDIM >::init_op(), madness::CC2::initialize_singles(), madness::CCIntermediatePotentials::insert(), madness::CCPairFunction< T, NDIM >::is_convertible_to_pure_no_op(), madness::TDHF::iterate_vectors(), madness::archive::ArchiveLoadImpl< ParallelInputArchive< archiveT >, CCPairFunction< T, NDIM > >::load(), madness::Cloud::load_tuple(), madness::SeparatedConvolution< Q, NDIM >::make_coeff_for_operator(), name(), madness::CCIntermediatePotentials::operator()(), operator<<(), madness::BasisFunctions::print_contracted_basis(), madness::F12Potentials::print_pair_energies(), slymer::NWChem_Interface::read_basis_set(), AtomicBasisSet::read_file(), madness::AtomicBasisSet::read_file(), read_orbital(), madness::CC2::solve_mp2_coupled(), test_combined_operators(), and madness::CCConvolutionOperator< T, NDIM >::update_elements().
madness::TYPEINFO | ( | 0 | , |
int | , | ||
false | , | ||
true | , | ||
int | , | ||
double | |||
) |
madness::TYPEINFO | ( | 1 | , |
long | , | ||
false | , | ||
true | , | ||
long | , | ||
double | |||
) |
madness::TYPEINFO | ( | 2 | , |
float | , | ||
false | , | ||
true | , | ||
float | , | ||
float | |||
) |
madness::TYPEINFO | ( | 3 | , |
double | , | ||
false | , | ||
true | , | ||
double | , | ||
double | |||
) |
madness::TYPEINFO | ( | 4 | , |
float_complex | , | ||
true | , | ||
true | , | ||
float | , | ||
float | |||
) |
madness::TYPEINFO | ( | 5 | , |
double_complex | , | ||
true | , | ||
true | , | ||
double | , | ||
double | |||
) |
Function<typename opT::resultT, NDIM> madness::unary_op | ( | const Function< Q, NDIM > & | func, |
const opT & | op, | ||
bool | fence = true |
||
) |
Out of place application of unary operation to function values with optional fence.
References func(), madness::Function< T, NDIM >::get_impl(), op(), madness::Function< T, NDIM >::set_impl(), and VERIFY_TREE.
Referenced by abs(), abs_square(), abssq(), madness::XCOperator< T, NDIM >::prep_xc_args(), test_hf_he(), and test_math().
Function<typename opT::resultT, NDIM> madness::unary_op_coeffs | ( | const Function< Q, NDIM > & | func, |
const opT & | op, | ||
bool | fence = true |
||
) |
Out of place application of unary operation to scaling function coefficients with optional fence.
References func(), op(), and madness::Function< T, NDIM >::unary_op_coeffs().
Referenced by abs(), function_real2complex(), function_real2complex(), imag(), and real().
std::string madness::unique_fileid | ( | ) |
creates a unique filename, using PBS ID if available
References RandomValue< int >().
Referenced by test_Kcommutator(), and test_lowrank_function().
|
static |
Referenced by madness::smooth< T, NDIM >::make_inv_mask().
Vector<T,N> madness::unitvec | ( | const Vector< T, N > & | r, |
const double | eps = 1.e-6 |
||
) |
Construct a unit-Vector
that has the same direction as r
.
[in] | r | The Vector . |
[in] | eps | A precision. If the norm of r is less than eps , the zero vector is returned. |
References madness::detail::norm(), and madness::Vector< T, N >::normf().
Referenced by madness::NuclearCorrelationFactor::U1_dot_U1_functor::operator()().
|
inlinestatic |
Convert user coords (cell[][]) to simulation coords ([0,1]^ndim)
References madness::FunctionDefaults< NDIM >::get_rcell_width(), and NDIM.
Referenced by madness::Specialbox_op< T, NDIM >::check_special_points(), madness::Function< T, NDIM >::eval(), madness::Function< T, NDIM >::eval_cube(), madness::Function< T, NDIM >::eval_local_only(), madness::Function< T, NDIM >::evaldepthpt(), madness::Function< T, NDIM >::evalR(), mask3(), mask3(), mask3d(), madness::NuclearCuspyBox_op< T, NDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::project_refine_op().
|
inline |
Factory function for creating a madness::Vector
.
Variadic templates are used to create factories that mimic
This function counts the number of arguments passed in through the argument pack, creates a std::array
of the appropriate size, forwards the arguments to the std::array
's constructor, and passes the std::array
to madness::Vector
.
use
or
T
. It is assumed that all arguments are of type T
or are convertible to type T
.T | The data type for the array. |
Ts | The argument pack; that is, the list of arguments. The size of the resulting Vector is directly determined from the size of the argument pack. |
[in] | t | The first argument. |
[in] | ts | The rest of the arguments. |
Vector
with the arguments put into it. References T().
Referenced by A(), A2(), KPeriodicBSHOperator::apply(), apply_periodic_bsh(), madness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T >::check_dependency(), ConstantSphere::check_pts(), InhomoConstantSphere::check_pts(), CosineSphere::check_pts(), Y20Sphere::check_pts(), madness::Localizer::determine_frozen_orbitals(), Ebar(), main(), madness::FunctionSpace< T, NDIM >::norm(), madness::VectorOfFunctionsSpace< T, VDIM, FDIM >::norm(), madness::VectorSpace< T, NDIM >::norm(), madness::SRConf< T >::normf(), Pbar(), PbarA(), madness::FunctionSpace< T, NDIM >::scale(), madness::VectorOfFunctionsSpace< T, VDIM, FDIM >::scale(), madness::VectorSpace< T, NDIM >::scale(), madness::CC_vecfunction::serialize(), Tbar(), madness::FunctionImpl< T, NDIM >::tnorm(), and to_response_vector().
Returns a std::vector<T> initialized from the arguments.
References v.
Referenced by madness::guessfactory::PolynomialFunctor::read_string().
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
inline |
Returns a std::vector<T> initialized from the arguments.
References v.
|
static |
References v.
Referenced by refine_to_common_level().
std::vector< Function<TENSOR_RESULT_TYPE(L,R),D> > madness::vmulXX | ( | const Function< L, D > & | left, |
const std::vector< Function< R, D > > & | vright, | ||
double | tol, | ||
bool | fence = true |
||
) |
Use the vmra/mul(...) interface instead.
This so that we don't have to have friend functions in a different header.
If using sparsity (tol != 0) you must have created the tree of norms already for both left and right.
References L, R, and TENSOR_RESULT_TYPE().
Referenced by matrix_mul_sparse(), mul(), and mul_sparse().
double madness::wall_time | ( | ) |
Returns the wall time in seconds relative to an arbitrary origin.
As accurate and lightweight as we can get it, but may not be any better than the gettime of day system call.
References e(), first_call, and initialized().
Referenced by madness::Znemo::timer::timer(), madness::Cloud::cloudtimer::~cloudtimer(), madness::SRConf< T >::add_SVD(), apply(), chin_chen(), madness::WorldProfile::clear(), madness::Nemo::compute_all_cphf(), compute_energy(), madness::SVDTensor< T >::compute_randomized_svd(), converge(), converge2s(), cpu_frequency(), cycle_count(), doit(), doplot(), doplotptk(), madness::Znemo::timer::end(), molresponse::end_timer(), DF::end_timer(), END_TIMER(), madness::Solver< T, NDIM >::END_TIMER(), END_TIMER(), madness::MP2::END_TIMER(), GygiPot::ESP(), madness::FunctionImpl< T, NDIM >::finalize_apply(), DF::get_times(), madness::Nemo::hessian(), madness::MP2::increment(), madness::SCFProtocol::initialize(), madness::timer::interrupt(), madness::Znemo::iterate(), madness::OEP::iterate(), iterate(), madness::Zcis::iterate(), madness::CC2::iterate_lrcc2_pairs(), madness::PNO::iterate_pairs_internal(), main(), madness::Solver< T, NDIM >::make_nuclear_charge_density_impl(), MPI_Wtime(), ortho3(), ortho5(), madness::WorldProfile::print(), madness::FunctionImpl< T, NDIM >::print_size(), madness::CCPairFunction< T, NDIM >::print_size(), print_stats(), print_stats(), propagate(), madness::timer::resume(), madness::MacroTask< taskT >::MacroTaskInternal::run(), madness::MacroTaskQ::run_all(), madness::CC2::solve(), SVPESolver::solve(), madness::Nemo::solve(), madness::SCF::solve(), solve(), madness::CC2::solve_cc2(), madness::MP2::solve_coupled_equations(), madness::CC2::solve_mp2_coupled(), madness::MP2::solve_residual_equations(), madness::CCTimer::start(), madness::MyTimer::start(), madness::profiling::TaskEvent::start(), molresponse::start_timer(), DF::start_timer(), START_TIMER(), madness::Solver< T, NDIM >::START_TIMER(), START_TIMER(), madness::MP2::START_TIMER(), madness::CCTimer::stop(), madness::MyTimer::stop(), madness::profiling::TaskEvent::stop(), madness::archive::ArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > >::store(), madness::PoolTaskInterface::submit(), madness::Znemo::timer::tag(), test(), madness::TDHF::test(), test2(), test_adaptive_tree(), test_florian(), test_modified(), test_stuff(), madness::PNO::update_pno(), and madness::CCTimer::update_time().
WorldMemInfo* madness::world_mem_info | ( | ) |
void madness::write_molecules_to_file | ( | const Molecule & | molecule, |
const std::string & | geo_file | ||
) |
References atomic_number_to_symbol(), f, madness::Molecule::get_all_coords_vec(), madness::Molecule::get_atomic_number(), molecule, and madness::Molecule::natom().
Referenced by do_response_orbital_vtk_plots().
int madness::x_rks_s__ | ( | const double * | r__, |
double * | f, | ||
double * | dfdra | ||
) |
References c_b2, f, and pow().
Referenced by da_ldaop(), madness::XCfunctional::exc(), madness::xc_lda_potential::operator()(), test_xc1(), and madness::XCfunctional::vxc().
int madness::x_uks_s__ | ( | double * | ra, |
double * | rb, | ||
double * | f, | ||
double * | dfdra, | ||
double * | dfdrb | ||
) |
References c_b2, f, and pow().
Referenced by madness::XCfunctional::exc(), and madness::XCfunctional::vxc().
|
static |
Referenced by madness::XCfunctional::exc(), and madness::XCfunctional::vxc().
void madness::xterm_debug | ( | const char * | path, |
const char * | display | ||
) |
path | Description. |
display | Description. |
Referenced by madness::World::args(), and startup().
void madness::xterm_debug_breakpoint | ( | ) |
std::vector< Function<T,NDIM> > madness::zero_functions | ( | World & | world, |
int | n | ||
) |
Generates a vector of zero functions.
References PROFILE_BLOCK.
std::vector< Function<T,NDIM> > madness::zero_functions | ( | World & | world, |
int | n, | ||
bool | fence = true |
||
) |
Generates a vector of zero functions (reconstructed)
References madness::WorldGopInterface::fence(), madness::World::gop, and PROFILE_BLOCK.
Referenced by ground_exchange(), ground_exchange_multiworld(), molresponseExchange(), and response_exchange_multiworld().
std::vector< Function<T,NDIM> > madness::zero_functions_compressed | ( | World & | world, |
int | n, | ||
bool | fence = true |
||
) |
Generates a vector of zero functions (compressed)
References compressed, madness::WorldGopInterface::fence(), madness::World::gop, and PROFILE_BLOCK.
Entire dimension.
Referenced by madness::FunctionImpl< T, NDIM >::binaryXXa(), concatenate_columns(), concatenate_rows(), madness::DistributedMatrix< T >::copy_from_replicated(), madness::DistributedMatrix< T >::copy_to_replicated(), dft_xc_lda_ene(), dft_xc_lda_V(), madness::DistributedMatrix< T >::extract_columns(), fcube(), laplacian(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::FunctionImpl< T, NDIM >::do_mirror::operator()(), and madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()().
|
static |
Referenced by autoc(), load_coeffs(), and read_data().
const double madness::acut1e_6 = 0.25 |
Referenced by PeriodicCoulombOp(), and PeriodicCoulombOpPtr().
|
static |
Atomic weights are taken from IUPAC 2005 (M. E. Wieser, “Atomic weights of the elements 2005 (IUPAC Technical Report),” Pure and Applied Chemistry, vol. 78, no. 11.) Negative masses refer to the longest-living isotope. Note that the masses refer to isotopic averaging, not to the specified isotope!
Referenced by atomic_number_to_symbol(), get_atomic_data(), get_atomic_data(), MolecularEntity::print(), symbol_to_atomic_number(), and symbol_to_atomic_number().
|
static |
Referenced by load_coeffs(), read_data(), and test_autoc().
ThreadBinder madness::binder |
const double madness::c_b14 = 1.333333333333333333333333333333 |
Referenced by c_uks_vwn5__().
const double madness::c_b2 = 0.333333333333333333333333333333333 |
Referenced by x_rks_s__(), and x_uks_s__().
const double madness::c_b7 = 0.333333333333333333333333333333 |
Referenced by c_rks_vwn5__(), and c_uks_vwn5__().
|
static |
|
static |
|
static |
Referenced by load_quadrature(), and read_data().
|
static |
Referenced by madness::TensorIterator< T, Q, R >::TensorIterator().
Random madness::default_random_generator |
The default random number stream.
Referenced by madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), RandomValue< double >(), RandomValue< float >(), RandomVector< double >(), RandomVector< double_complex >(), RandomVector< float >(), RandomVector< float_complex >(), test(), test_Kcommutator(), test_lowrank_function(), and test_math().
|
static |
Referenced by madness::CubicInterpolationTable< T >::CubicInterpolationTable(), YetAnotherWrapperClass::YetAnotherWrapperClass(), abs(), abs_square(), DirichletCondIntOp::action(), madness::FutureImpl< T >::add_to_assignments(), madness::LoadBalanceDeux< NDIM >::add_tree(), madness::WorldObject< Derived >::am_arg(), madness::WorldTaskQueue::am_arg(), LProjector::analyze(), ExactSpinor::angular(), madness::FunctionImpl< T, NDIM >::apply(), apply(), apply_1d_realspace_push(), madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push(), madness::Solver< T, NDIM >::apply_hf_exchange(), apply_mask(), apply_only(), apply_periodic_bsh(), madness::guessfactory::apply_polynomial_exop(), madness::FunctionImpl< T, NDIM >::apply_source_driven(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation2(), madness::SeparatedConvolution< Q, NDIM >::apply_transformation3(), madness::guessfactory::apply_trigonometric_exop(), madness::MP2::asymmetry(), c_rks_vwn5__(), c_uks_vwn5__(), change_tree_state(), madness::Specialbox_op< T, NDIM >::check_special_points(), madness::guessfactory::compute_centroid(), madness::Localizer::compute_core_valence_separation_transformation_matrix(), compute_energy(), madness::max_of_x_1_smooth::compute_factor(), compute_fock_matrix(), madness::MP2::compute_gQf(), madness::MP2::compute_gQf_cc2interface(), conj(), convert(), copy(), cross(), madness::CubicInterpolationTable< T >::cubic_fit(), madness::smooth< T, NDIM >::cut_oscillations(), madness::MP2::debug_cc2(), madness::FunctionSpace< T, NDIM >::destroy(), madness::VectorOfFunctionsSpace< T, VDIM, FDIM >::destroy(), madness::FunctionImpl< T, NDIM >::diff(), diff(), madness::Function< T, NDIM >::dirac_convolution(), madness::CCPairFunction< T, NDIM >::dirac_convolution_decomposed(), madness::FunctionImpl< T, NDIM >::dirac_convolution_op(), madness::FunctionImpl< T, NDIM >::do_diff1(), madness::DerivativeBase< T, NDIM >::do_diff1(), madness::FunctionImpl< T, NDIM >::do_dirac_convolution(), do_response_orbital_vtk_plots(), Plotter::dolineplot(), Plotter::doplot1(), Plotter::dovolumeplot(), dxprintvalue(), madness::CubicInterpolationTable< T >::err(), errsq(), madness::XCfunctional::exc(), expL(), fcube(), madness::FunctionImpl< T, NDIM >::fcube(), madness::DistributedMatrix< T >::fill(), madness::WorldContainerImpl< keyT, valueT, hashfunT >::find_failure_handler(), madness::DerivativeBase< T, NDIM >::find_neighbor(), madness::WorldContainerImpl< keyT, valueT, hashfunT >::find_success_handler(), madness::FunctionImpl< T, NDIM >::forward_do_diff1(), madness::DerivativeBase< T, NDIM >::forward_do_diff1(), madness::smooth< T, NDIM >::gaussian_smoothing(), madness::Function< T, NDIM >::gaxpy_ext(), madness::FunctionImpl< T, NDIM >::gaxpy_ext(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_node(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::gaxpy_oop_reconstructed(), madness::TaskFn< fnT, arg1T, arg2T, arg3T, arg4T, arg5T, arg6T, arg7T, arg8T, arg9T >::get_func(), get_impl(), madness::MP2::get_residue(), get_size(), madness::Projector< T, NDIM >::get_vectors_for_outer_product(), madness::StrongOrthogonalityProjector< T, NDIM >::get_vectors_for_outer_product(), grad(), grad_ble_one(), grad_ble_two(), grad_bpsline_two(), grad_bspline_one(), grad_bspline_three(), madness::Solver< T, NDIM >::gram_schmidt(), madness::PNO::guess_virtuals(), madness::BasisFunctions::guess_with_exop(), madness::CC_vecfunction::hash(), madness::Znemo::hcore_guess(), inner(), madness::Function< T, NDIM >::inner_adaptive(), madness::FunctionImpl< T, NDIM >::inner_adaptive_local(), madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), madness::Function< T, NDIM >::inner_ext(), madness::FunctionImpl< T, NDIM >::inner_ext_local(), madness::Function< T, NDIM >::inner_ext_local(), madness::FunctionImpl< T, NDIM >::inner_ext_node(), madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), innerXX(), madness::CC_vecfunction::insert(), madness::CCIntermediatePotentials::insert(), madness::MP2::iterate(), madness::Zcis::iterate(), iterate(), laplacian(), line_plot(), madness::archive::ArchiveLoadImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > >::load(), madness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< const FunctionImpl< T, NDIM > > >::load(), madness::archive::ArchiveLoadImpl< Archive, std::shared_ptr< FunctionImpl< T, NDIM > > >::load(), madness::archive::ArchiveLoadImpl< ParallelInputArchive< archiveT >, CCPairFunction< T, NDIM > >::load(), madness::archive::ArchiveLoadImpl< ParallelInputArchive< archiveT >, Function< T, NDIM > >::load(), load(), load(), load_balance(), madness::LoadBalanceDeux< NDIM >::load_balance(), EmbeddedDirichlet::load_balance(), madness::MP2::load_function(), madness::Nemo::load_function(), load_function(), main(), madness::smooth< T, NDIM >::make_explog(), madness::smooth< T, NDIM >::make_plots(), madness::Nemo::make_plots(), madness::Function< T, NDIM >::map_and_mirror(), map_and_mirror(), madness::FunctionImpl< T, NDIM >::map_and_mirror(), map_tensor(), madness::Function< T, NDIM >::mapdim(), mapdim(), madness::FunctionImpl< T, NDIM >::mapdim(), matrix_inner(), matrix_inner_old(), matrix_mul_sparse(), madness::smooth< T, NDIM >::merge_functions(), madness::Function< T, NDIM >::mirror(), mirror(), madness::FunctionImpl< T, NDIM >::mirror(), mul(), madness::Function< T, NDIM >::mul_on_demand(), multiply(), madness::FunctionImpl< T, NDIM >::multiply(), madness::SeparatedConvolution< Q, NDIM >::muopxv_fast(), madness::SeparatedConvolution< Q, NDIM >::muopxv_fast2(), N(), madness::ContractedGaussianShell::normalize(), op(), madness::CCIntermediatePotentials::operator()(), LProjector::operator()(), F::operator()(), FunctorInterfaceWrapper::operator()(), madness::StrongOrthogonalityProjector< T, NDIM >::operator()(), madness::QProjector< T, NDIM >::operator()(), madness::SeparatedConvolution< Q, NDIM >::operator()(), madness::CCConvolutionOperator< T, NDIM >::operator()(), madness::pg_operator::operator()(), madness::DerivativeBase< T, NDIM >::operator()(), madness::munging_operator::operator()(), madness::xc_lda_potential::operator()(), YetAnotherWrapperClass::operator()(), madness::ElectronCuspyBox_op< T, NDIM >::operator()(), madness::NuclearCuspyBox_op< T, NDIM >::operator()(), madness::merging_operator::operator()(), madness::Projector< T, NDIM >::operator()(), madness::GenericConvolution1D< Q, opT >::Shmoo::operator()(), Fred::operator*(), madness::response_space::operator*(), operator*(), operator+(), Fred::operator+=(), operator-(), operator<<(), F::operator=(), Fred::operator=(), madness::Function< T, NDIM >::operator=(), madness::LowRankFunction< T, NDIM, LDIM >::operator=(), MySteepestDescent::optimize(), SteepestDescent::optimize(), QuasiNewton::optimize(), optimize_coeffs(), madness::TDHF::oscillator_strength_length(), madness::TDHF::oscillator_strength_velocity(), madness::FunctionImpl< T, NDIM >::parent_to_child_NS(), partial_mul(), madness::XCfunctional::plot(), plot(), madness::CC2::plot(), plot_along(), plot_cubefile(), plot_line(), plot_line_print_value(), Calculation::plot_p(), plot_plane(), plot_symmetry_operators(), Calculation::plot_z(), plotdx(), plotpovray(), plotter1(), plotter2(), plotter3(), plotvtk_begin(), plotvtk_data(), plotvtk_end(), madness::DQueue< T >::pop_front(), position_stream(), madness::Molecule::position_stream_in_library(), position_stream_to_word(), madness::trajectory< NDIM >::print_psdot(), print_tree_jsonfile(), madness::TDHF::print_xfunctions(), printfunc(), madness::CCPairFunction< T, NDIM >::project_out(), madness::FunctionImpl< T, NDIM >::project_out2(), madness::CCPairFunction< T, NDIM >::project_out_decomposed(), madness::CCPairFunction< T, NDIM >::project_out_op_decomposed(), ExactSpinor::psivalue(), madness::response_space::push_back(), madness::DQueue< T >::push_front_with_lock(), InputParameters::read(), madness::DFParameters::read(), madness::Molecule::read(), madness::BasisFunctions::read_basis_from_file(), madness::BasisFunctions::read_contracted_basis_from_file(), read_data(), madness::DFParameters::read_file(), madness::ElectronicStructureParams::read_file(), madness::Molecule::read_file(), MolecularEntity::read_file(), CalculationParameters::read_file(), madness::Derivative< T, NDIM >::read_from_file(), madness::QCCalculationParametersBase::read_input(), madness::QCCalculationParametersBase::read_internal(), madness::Molecule::read_structure_from_library(), madness::Molecule::read_xyz(), refine(), residual(), save(), save(), madness::MP2::save_function(), save_function(), madness::Nemo::save_function(), madness::FunctionImpl< T, NDIM >::scale_oop(), madness::DQueue< T >::scan(), madness::detail::DistCache< keyT >::set_cache_value(), madness::Molecule::GeometryParameters::set_derived_values(), madness::Function< T, NDIM >::set_impl(), Calculation::set_protocol(), madness::SCF::set_protocol(), madness::ConditionVariable::signal(), madness::Nemo::smoothen(), madness::SCF::solve(), square(), madness::archive::ArchiveStoreImpl< Archive, Future< T >, std::enable_if_t<!std::is_void_v< T > > >::store(), madness::archive::ArchiveStoreImpl< ParallelOutputArchive< archiveT >, CCPairFunction< T, NDIM > >::store(), madness::archive::ArchiveStoreImpl< ParallelOutputArchive< archiveT >, Function< T, NDIM > >::store(), sum(), swap_particles(), symmetrize(), madness::TDHF::symmetrize(), tabulate(), TENSOR_RESULT_TYPE(), madness::Random::test(), test(), Test5(), Test6(), test6(), Test6a(), madness::smooth< T, NDIM >::test_1d(), test_add(), test_apply(), test_apply_push_1d(), test_basic(), test_bsh(), test_constructor(), test_conv(), test_conversion(), test_coulomb(), test_cross(), test_diff(), test_exchange(), test_fock(), test_gconv(), test_inner(), test_integration(), test_io(), test_kinetic(), madness::Znemo::test_landau_wave_function(), test_math(), test_matrix_mul_sparse(), test_multi_to_multi_op(), test_multiply(), test_op(), test_opdir(), test_orthogonalization(), test_partial_inner_3d(), test_partial_inner_6d(), test_per(), test_periodic(), test_periodic1(), test_periodic2(), test_periodic_bsh(), madness::Solver< T, NDIM >::test_periodicity(), test_plot(), test_proj(), test_projector(), test_Q12_projector(), test_qm(), test_rot(), test_scalar_multiplication(), test_swap_particles(), test_transform(), test_unaryop(), test_xc2(), test_xcfunctional(), testNavierStokes(), transpose(), madness::Function< T, NDIM >::unaryop(), madness::MutexFair::unlock(), MySteepestDescent::value(), SteepestDescent::value(), QuasiNewton::value(), Fred::value_and_gradient(), madness::XCfunctional::vxc(), write_molecules_to_file(), x_rks_s__(), and x_uks_s__().
|
static |
Referenced by AtomicBasisSet::AtomicBasisSet(), madness::AtomicBasisSet::AtomicBasisSet(), madness::archive::BinaryFstreamInputArchive::BinaryFstreamInputArchive(), madness::archive::BinaryFstreamOutputArchive::BinaryFstreamOutputArchive(), madness::CorePotentialManager::CorePotentialManager(), inputfile::inputfile(), madness::MacroTask< taskT >::io_redirect::io_redirect(), MolecularEntity::MolecularEntity(), madness::archive::ParallelInputArchive< localarchiveT >::ParallelInputArchive(), madness::archive::ParallelOutputArchive< localarchiveT >::ParallelOutputArchive(), madness::Solver< T, NDIM >::Solver(), madness::archive::TextFstreamInputArchive::TextFstreamInputArchive(), madness::archive::TextFstreamOutputArchive::TextFstreamOutputArchive(), checksum_file(), cubefile_header(), madness::FunctionImpl< T, NDIM >::do_print_grid(), madness::FunctionImpl< T, NDIM >::do_print_plane(), do_response_density_vtk_plots(), do_response_orbital_vtk_plots(), do_vtk_plots(), draw_circle(), draw_line(), madness::archive::BaseParallelArchive< Archive >::exists(), madness::QCCalculationParametersBase::file_exists(), get_charge_from_file(), madness::Solver< T, NDIM >::init(), OutputWriter::init_debug(), OutputWriter::init_eigv(), OutputWriter::init_log(), load(), Calculation::load_mos(), madness::GTHPseudopotential< Q >::load_pseudo_from_file(), load_quadrature(), madness::CC_vecfunction::load_restartdata(), main(), DF::make_density_lineplots(), madness::archive::BinaryFstreamInputArchive::open(), madness::archive::BinaryFstreamOutputArchive::open(), madness::archive::TextFstreamInputArchive::open(), madness::archive::TextFstreamOutputArchive::open(), madness::archive::BaseParallelArchive< Archive >::open(), plot(), Spinor::plot(), plot_along(), plot_cubefile(), plot_line(), Calculation::plot_p(), plot_plane(), Calculation::plot_z(), plotdx(), plotpovray(), plotvtk(), plotvtk_begin(), plotvtk_data(), plotvtk_end(), madness::MolecularOrbitals< T, NDIM >::print_cubefiles(), madness::FunctionImpl< T, NDIM >::print_grid(), print_meminfo(), print_meminfo_ostream(), madness::FunctionImpl< T, NDIM >::print_plane(), print_tree_jsonfile(), InputParameters::read(), madness::InitParameters::read(), madness::BasisFunctions::read_basis_from_file(), madness::F12Potentials::read_cabs_from_file(), madness::BasisFunctions::read_contracted_basis_from_file(), madness::Molecule::read_core_file(), read_data(), madness::Znemo::read_explicit_guess_functions(), madness::DFParameters::read_file(), madness::ElectronicStructureParams::read_file(), madness::Molecule::read_file(), MolecularEntity::read_file(), CalculationParameters::read_file(), AtomicBasisSet::read_file(), madness::AtomicBasisSet::read_file(), madness::CorePotentialManager::read_file(), madness::Derivative< T, NDIM >::read_from_file(), madness::QCCalculationParametersBase::read_input(), madness::AtomicBasisSet::read_nw_file(), madness::MolecularOrbitals< T, NDIM >::read_restartdata(), madness::Molecule::read_xyz(), madness::InitParameters::readnw(), redirectio(), madness::archive::BaseParallelArchive< Archive >::remove(), madness::commandlineparser::remove_extension(), save(), madness::MolecularOrbitals< T, NDIM >::save_restartdata(), madness::CC_vecfunction::save_restartdata(), madness::Derivative< T, NDIM >::set_ble1(), madness::Derivative< T, NDIM >::set_ble2(), madness::Derivative< T, NDIM >::set_bspline1(), madness::Derivative< T, NDIM >::set_bspline2(), madness::Derivative< T, NDIM >::set_bspline3(), solve(), madness::TDHF::solve_cis(), test_adaptive_tree(), TEST_CASE(), test_smooth_maxout(), testNavierStokes(), madness::gridbase::visualize(), and write_test_input().
NDIM const opT & madness::g |
Referenced by ExactSpinor::angular(), apply_bsh(), apply_periodic_bsh(), compute_energy(), madness::MP2::compute_gQf(), madness::MP3::compute_mp3_ghij(), madness::MP3::compute_mp3_ghij_fast(), cross(), madness::Znemo::custom_guess(), madness::FunctionImpl< T, NDIM >::dirac_convolution_op(), Plotter::dolineplot(), Plotter::dovolumeplot(), madness::TwoElectronFactory< T, NDIM >::gamma(), madness::FunctionImpl< T, NDIM >::gaxpy_inplace_reconstructed(), madness::FunctionImpl< T, NDIM >::gaxpy_oop_reconstructed(), madness::SDFCircle::grad_sdf(), madness::SDFSphere::grad_sdf(), Fred::gradient(), Test2::gradient(), CoreFittingTarget::gradient(), data< T, NDIM >::initialize(), inner(), innerXX(), madness::Localizer::localize_boys(), madness::Localizer::localize_new(), main(), Fred::make_g(), matrix_inner(), matrix_inner_old(), matrix_mul_sparse(), multiply(), madness::FunctionImpl< T, NDIM >::multiply(), QuasiNewton::new_search_direction(), madness::QuasiNewton::new_search_direction(), madness::MolecularOptimizer::new_search_direction2(), BoysLocalization::operator()(), madness::response_space::operator+=(), MySteepestDescent::optimize(), SteepestDescent::optimize(), QuasiNewton::optimize(), madness::SteepestDescent::optimize(), madness::QuasiNewton::optimize(), madness::FunctionImpl< T, NDIM >::partial_inner(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), partial_mul(), plot_line(), madness::LowRankFunctionFactory< T, NDIM, LDIM >::project(), madness::FunctionImpl< T, NDIM >::project_out2(), ExactSpinor::psivalue(), madness::AtomicBasisSet::read_file(), madness::Zcis::read_guess(), madness::AtomicBasisSet::read_nw_file(), madness::Zcis::save_guess(), madness::GaussSlater::Spp_div_S(), madness::GradientalGaussSlater::Spp_div_S(), madness::GradientalGaussSlater::Sr_div_S(), madness::GradientalGaussSlater::Srr_div_S(), madness::GradientalGaussSlater::Srrr_div_S(), TENSOR_RESULT_TYPE(), madness::Gnuplot::test(), test(), Test6(), test_coulomb(), test_gconv(), test_io(), test_rnlp(), test_U_el(), test_unaryop(), testgradG(), transpose(), and Fred::value_and_gradient().
|
inlineconstexpr |
true if this is well-formed:
Referenced by madness::archive::ArchiveLoadImpl< Archive, T, Enabler >::load(), and madness::archive::ArchiveStoreImpl< Archive, T, Enabler >::store().
|
inlineconstexpr |
true if this is well-formed:
Referenced by madness::archive::ArchiveImpl< Archive, archive_array< T > >::wrap_load(), and madness::archive::ArchiveImpl< Archive, archive_array< T > >::wrap_store().
|
inlineconstexpr |
true if this is well-formed:
Referenced by madness::archive::ArchiveLoadImpl< Archive, T, Enabler >::load(), and madness::archive::ArchiveStoreImpl< Archive, T, Enabler >::store().
|
inlineconstexpr |
true if this is well-formed:
Referenced by madness::archive::ArchiveImpl< Archive, archive_array< T > >::wrap_load(), and madness::archive::ArchiveImpl< Archive, archive_array< T > >::wrap_store().
|
inlineconstexpr |
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
|
inlineconstexpr |
true if this is well-formed:
|
inlineconstexpr |
true if this is well-formed:
|
constexpr |
|
constexpr |
|
inlineconstexpr |
|
inlineconstexpr |
Referenced by test_in().
|
inlineconstexpr |
|
constexpr |
|
inlineconstexpr |
|
constexpr |
providing automatic support for serializing to/from std streams requires bidirectional streammability
|
constexpr |
Shortcut for is_istreammable<T>::value
.
Referenced by test_in().
|
constexpr |
Shortcut for is_ostreammable<T>::value
.
Referenced by test_in().
|
inlineconstexpr |
|
inlineconstexpr |
Evaluates to true if can serialize an object of type T
to an object of type Archive
, using either user-provided methods or, if T
is default-serializable to Archive
, using default method for this Archive
Archive | |
T |
|
inlineconstexpr |
|
constexpr |
is_text_archive_v
is a shorthand for is_text_archive<A>::value
Archive | an archive type |
|
inlineconstexpr |
|
inlineconstexpr |
Evaluates to true if can serialize an object of type T
to an object of type Archive
using user-provided methods
Archive | |
T |
|
inlineconstexpr |
|
static |
Referenced by autoc().
|
static |
Referenced by madness::BandlimitedPropagator::BandlimitedPropagator(), load_coeffs(), wstFunctor< Q >::operator()(), madness::FunctionImpl< T, NDIM >::do_mirror::operator()(), madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()(), read_twoscale(), test_bsh(), test_conv(), test_two_scale_coefficients(), madness::TensorTrain< T >::truncate(), and two_scale_coefficients().
|
static |
Referenced by load_coeffs().
|
static |
Referenced by autoc(), load_coeffs(), and read_data().
|
static |
Referenced by load_coeffs(), read_twoscale(), and two_scale_coefficients().
|
static |
|
static |
Referenced by gauss_legendre(), load_quadrature(), and read_data().
|
static |
The maximum wavelet order presently supported.
Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionCommonData< T, NDIM >::get(), madness::FunctionNode< T, NDIM >::set_coeff(), and madness::FunctionDefaults< NDIM >::set_k().
|
static |
The maximum depth of refinement possible.
Referenced by madness::FunctionDefaults< NDIM >::set_initial_level(), madness::FunctionDefaults< NDIM >::set_max_refine_level(), and madness::FunctionDefaults< NDIM >::set_special_level().
|
static |
Referenced by initialize_legendre_stuff(), and legendre_polynomials().
|
static |
Referenced by get_atomic_data(), get_atomic_data(), symbol_to_atomic_number(), and symbol_to_atomic_number().
const int madness::NUMEVENTS = 0 |
Referenced by print_stats().
|
static |
Referenced by initialize_legendre_stuff(), and legendre_scaling_functions().
|
static |
|
static |
|
static |
Referenced by madness::RMI::begin(), and madness::RMI::RmiTask::set_rmi_task_is_running().
|
static |
Referenced by DF::end_timer(), END_TIMER(), END_TIMER(), DF::get_times(), DF::start_timer(), START_TIMER(), and START_TIMER().
|
extern |
|
static |
Referenced by madness::WorldProfileObj::WorldProfileObj().
|
static |
|
static |
Referenced by load_coeffs(), and read_twoscale().