FunctionImpl holds all Function state to facilitate shallow copy semantics. More...

#include <funcimpl.h>

Inheritance diagram for madness::FunctionImpl< T, NDIM >:

[legend]

Collaboration diagram for madness::FunctionImpl< T, NDIM >:

[legend]

Classes
struct	add_op
	add two functions f and g: result=alpha * f + beta * g More...

struct	coeff_value_adaptor

struct	do_accumulate_trees
	merge the coefficent boxes of this into result's tree More...

struct	do_average
	"put" this on g More...

struct	do_change_tensor_type
	change representation of nodes' coeffs to low rank, optional fence More...

struct	do_check_symmetry_local
	check symmetry wrt particle exchange More...

struct	do_compute_snorm_and_dnorm
	compute the norm of the wavelet coefficients More...

struct	do_consolidate_buffer

struct	do_convert_to_color

class	do_err_box

struct	do_gaxpy_inplace
	functor for the gaxpy_inplace method More...

struct	do_inner_ext_local_ffi

struct	do_inner_local
	compute the inner product of this range with other More...

struct	do_inner_local_on_demand
	compute the inner product of this range with other More...

struct	do_keep_sum_coeffs
	keep only the sum coefficients in each node More...

struct	do_map_and_mirror
	mirror dimensions of this, write result on f More...

struct	do_mapdim
	map this on f More...

struct	do_merge_trees
	merge the coefficent boxes of this into other's tree More...

struct	do_mirror
	mirror dimensions of this, write result on f More...

struct	do_norm2sq_local

struct	do_op_args
	laziness More...

struct	do_reduce_rank
	reduce the rank of the nodes, optional fence More...

struct	do_standard
	Changes non-standard compressed form to standard compressed form. More...

struct	do_truncate_NS_leafs
	given an NS tree resulting from a convolution, truncate leafs if appropriate More...

struct	do_unary_op_value_inplace

struct	hartree_op
	Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function. More...

struct	multiply_op
	perform this multiplication: h(1,2) = f(1,2) * g(1) More...

struct	pointwise_multiplier

struct	project_out_op
	project the low-dim function g on the hi-dim function f: result(x) = <f(x,y) \| g(y)> More...

struct	recursive_apply_op
	recursive part of recursive_apply More...

struct	recursive_apply_op2
	recursive part of recursive_apply More...

struct	remove_internal_coeffs
	remove all coefficients of internal nodes More...

struct	remove_leaf_coeffs
	remove all coefficients of leaf nodes More...

struct	true_refine_test

struct	Vphi_op_NS
	given a ket and the 1- and 2-electron potentials, construct the function V phi More...

Public Types
typedef GenTensor< T >	coeffT
	Type of tensor used to hold coeffs.

typedef Vector< double, NDIM >	coordT
	Type of vector holding coordinates.

typedef std::pair< const keyT, nodeT >	datumT
	Type of entry in container.

typedef WorldContainer< keyT, nodeT >	dcT
	Type of container holding the coefficients.

typedef FunctionImpl< T, NDIM >	implT
	Type of this class (implementation)

typedef Key< NDIM >	keyT
	Type of key.

typedef ConcurrentHashMap< keyT, mapvecT >	mapT
	Type of the map returned by make_key_vec_map.

typedef std::vector< std::pair< int, const coeffT * > >	mapvecT
	Type of the entry in the map returned by make_key_vec_map.

typedef FunctionNode< T, NDIM >	nodeT
	Type of node.

typedef std::shared_ptr< FunctionImpl< T, NDIM > >	pimplT
	pointer to this class

typedef Range< typename dcT::const_iterator >	rangeT

typedef Range< typename dcT::const_iterator >	rangeT

typedef Tensor< T >	tensorT
	Type of tensor for anything but to hold coeffs.

typedef Vector< Translation, NDIM >	tranT
	Type of array holding translation.

typedef T	typeT

Public Types inherited from madness::WorldObject< FunctionImpl< T, NDIM > >
typedef WorldObject< FunctionImpl< T, NDIM > >	objT

Public Member Functions
	FunctionImpl (const FunctionFactory< T, NDIM > &factory)
	Initialize function impl from data in factory.

template<typename Q >
	FunctionImpl (const FunctionImpl< Q, NDIM > &other, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool dozero)
	Copy constructor.

virtual	~FunctionImpl ()

void	abs_inplace (bool fence)

void	abs_square_inplace (bool fence)

void	accumulate_timer (const double time) const

template<typename Q , typename R >
void	accumulate_trees (FunctionImpl< Q, NDIM > &result, const R alpha, const bool fence=true) const
	merge the trees of this and other, while multiplying them with the alpha or beta, resp

void	add_keys_to_map (mapT *map, int index) const
	Adds keys to union of local keys with specified index.

void	add_scalar_inplace (T t, bool fence)
	Adds a constant to the function. Local operation, optional fence.

template<typename opT , typename R >
void	apply (opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
	apply an operator on f to return this

template<typename opT , typename R >
void	apply_1d_realspace_push (const opT &op, const FunctionImpl< R, NDIM > *f, int axis, bool fence)

template<typename opT , typename R >
void	apply_1d_realspace_push_op (const archive::archive_ptr< const opT > &pop, int axis, const keyT &key, const Tensor< R > &c)

template<typename opT , typename R >
void	apply_source_driven (opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
	similar to apply, but for low rank coeffs

coeffT	assemble_coefficients (const keyT &key, const coeffT &coeff_ket, const coeffT &vpotential1, const coeffT &vpotential2, const tensorT &veri) const
	given several coefficient tensors, assemble a result tensor

bool	autorefine_square_test (const keyT &key, const nodeT &t) const
	Returns true if this block of coeffs needs autorefining.

void	average (const implT &rhs)
	take the average of two functions, similar to: this=0.5*(this+rhs)

template<typename L , typename R , typename opT >
void	binaryXX (const FunctionImpl< L, NDIM > left, const FunctionImpl< R, NDIM > right, const opT &op, bool fence)

template<typename L , typename R , typename opT >
void	binaryXXa (const keyT &key, const FunctionImpl< L, NDIM > left, const Tensor< L > &lcin, const FunctionImpl< R, NDIM > right, const Tensor< R > &rcin, const opT &op)

void	broaden (std::vector< bool > is_periodic, bool fence)

void	broaden_op (const keyT &key, const std::vector< Future< bool > > &v)

void	change_tensor_type1 (const TensorArgs &targs, bool fence)
	change the tensor type of the coefficients in the FunctionNode

void	change_tree_state (const TreeState finalstate, bool fence=true)
	change the tree state of this function, might or might not respect fence!

double	check_symmetry_local () const
	Returns some asymmetry measure ... no comms.

std::vector< Slice >	child_patch (const keyT &child) const
	Returns patch referring to coeffs of child in parent box.

void	chop_at_level (const int n, const bool fence=true)
	remove all nodes with level higher than n

template<typename Q >
GenTensor< Q >	coeffs2values (const keyT &key, const GenTensor< Q > &coeff) const

template<typename Q >
Tensor< Q >	coeffs2values (const keyT &key, const Tensor< Q > &coeff) const

void	compress (const TreeState newstate, bool fence)
	compress the wave function

std::pair< coeffT, double >	compress_op (const keyT &key, const std::vector< Future< std::pair< coeffT, double > > > &v, bool nonstandard)
	calculate the wavelet coefficients using the sum coefficients of all child nodes

Future< std::pair< coeffT, double > >	compress_spawn (const keyT &key, bool nonstandard, bool keepleaves, bool redundant1)
	Invoked on node where key is local.

void	compute_snorm_and_dnorm (bool fence=true)
	compute norm of s and d coefficients for all nodes

template<typename Q >
void	copy_coeffs (const FunctionImpl< Q, NDIM > &other, bool fence)
	Copy coeffs from other into self.

void	diff (const DerivativeBase< T, NDIM > D, const implT f, bool fence)

template<std::size_t LDIM>
void	dirac_convolution_op (const keyT &key, const nodeT &node, FunctionImpl< T, LDIM > *f) const
	The operator.

void	distribute (std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > newmap) const

template<typename opT , typename R >
void	do_apply (const opT *op, const keyT &key, const Tensor< R > &c)
	apply an operator on the coeffs c (at node key)

template<typename opT , typename R >
double	do_apply_directed_screening (const opT *op, const keyT &key, const coeffT &coeff, const bool &do_kernel)
	apply an operator on the coeffs c (at node key)

template<typename opT , typename R , size_t OPDIM>
void	do_apply_kernel (const opT *op, const Tensor< R > &c, const do_op_args< OPDIM > &args)
	for fine-grain parallelism: call the apply method of an operator in a separate task

template<typename opT , typename R , size_t OPDIM>
double	do_apply_kernel2 (const opT *op, const Tensor< R > &c, const do_op_args< OPDIM > &args, const TensorArgs &apply_targs)
	same as do_apply_kernel, but use full rank tensors as input and low rank tensors as output

template<typename opT , typename R , size_t OPDIM>
double	do_apply_kernel3 (const opT *op, const GenTensor< R > &coeff, const do_op_args< OPDIM > &args, const TensorArgs &apply_targs)
	same as do_apply_kernel2, but use low rank tensors as input and low rank tensors as output

template<typename L , typename R , typename opT >
void	do_binary_op (const keyT &key, const Tensor< L > &left, const std::pair< keyT, Tensor< R > > &arg, const opT &op)
	Functor for the binary_op method.

void	do_diff1 (const DerivativeBase< T, NDIM > D, const implT f, const keyT &key, const std::pair< keyT, coeffT > &left, const std::pair< keyT, coeffT > &center, const std::pair< keyT, coeffT > &right)

template<std::size_t LDIM>
void	do_dirac_convolution (FunctionImpl< T, LDIM > *f, bool fence) const

template<typename L , typename R >
void	do_mul (const keyT &key, const Tensor< L > &left, const std::pair< keyT, Tensor< R > > &arg)
	Functor for the mul method.

void	do_print_grid (const std::string filename, const std::vector< keyT > &keys) const
	print the grid in xyz format

void	do_print_plane (const std::string filename, std::vector< Tensor< double > > plotinfo, const int xaxis, const int yaxis, const coordT el2)
	print the MRA structure

void	do_print_tree (const keyT &key, std::ostream &os, Level maxlevel) const
	Functor for the do_print_tree method.

void	do_print_tree_graphviz (const keyT &key, std::ostream &os, Level maxlevel) const
	Functor for the do_print_tree method (using GraphViz)

void	do_print_tree_json (const keyT &key, std::multimap< Level, std::tuple< tranT, std::string > > &data, Level maxlevel) const
	Functor for the do_print_tree_json method.

template<size_t LDIM>
void	do_project_out (const coeffT &fcoeff, const std::pair< keyT, coeffT > gpair, const keyT &gkey, const Key< NDIM > &dest, const int dim) const
	compute the inner product of two nodes of only some dimensions and accumulate on result

void	do_square_inplace (const keyT &key)

void	do_square_inplace2 (const keyT &parent, const keyT &child, const tensorT &parent_coeff)

tensorT	downsample (const keyT &key, const std::vector< Future< coeffT > > &v) const
	downsample the sum coefficients of level n+1 to sum coeffs on level n

void	erase (const Level &max_level)
	truncate tree at a certain level

template<typename opT >
double	err_box (const keyT &key, const nodeT &node, const opT &func, int npt, const Tensor< double > &qx, const Tensor< double > &quad_phit, const Tensor< double > &quad_phiw) const
	Returns the square of the error norm in the box labeled by key.

template<typename opT >
double	errsq_local (const opT &func) const
	Returns the sum of squares of errors from local info ... no comms.

void	eval (const Vector< double, NDIM > &xin, const keyT &keyin, const typename Future< T >::remote_refT &ref)
	Evaluate the function at a point in simulation coordinates.

T	eval_cube (Level n, coordT &x, const tensorT &c) const

std::pair< bool, T >	eval_local_only (const Vector< double, NDIM > &xin, Level maxlevel)
	Evaluate function only if point is local returning (true,value); otherwise return (false,0.0)

Tensor< T >	eval_plot_cube (const coordT &plotlo, const coordT &plothi, const std::vector< long > &npt, const bool eval_refine=false) const

void	evaldepthpt (const Vector< double, NDIM > &xin, const keyT &keyin, const typename Future< Level >::remote_refT &ref)
	Get the depth of the tree at a point in simulation coordinates.

void	evalR (const Vector< double, NDIM > &xin, const keyT &keyin, const typename Future< long >::remote_refT &ref)
	Get the rank of leaf box of the tree at a point in simulation coordinates.

bool	exists_and_has_children (const keyT &key) const

bool	exists_and_is_leaf (const keyT &key) const

void	fcube (const keyT &key, const FunctionFunctorInterface< T, NDIM > &f, const Tensor< double > &qx, tensorT &fval) const
	Evaluate function at quadrature points in the specified box.

void	fcube (const keyT &key, T(*f)(const coordT &), const Tensor< double > &qx, tensorT &fval) const
	Evaluate function at quadrature points in the specified box.

template<typename Q >
GenTensor< Q >	fcube_for_mul (const keyT &child, const keyT &parent, const GenTensor< Q > &coeff) const
	Compute the function values for multiplication.

template<typename Q >
Tensor< Q >	fcube_for_mul (const keyT &child, const keyT &parent, const Tensor< Q > &coeff) const
	Compute the function values for multiplication.

coeffT	filter (const coeffT &s) const

tensorT	filter (const tensorT &s) const
	Transform sum coefficients at level n to sums+differences at level n-1.

double	finalize_apply ()
	after apply we need to do some cleanup;

void	finalize_sum ()
	after summing up we need to do some cleanup;

std::pair< Key< NDIM >, ShallowNode< T, NDIM > >	find_datum (keyT key) const
	return the a std::pair<key, node>, which MUST exist

Future< std::pair< keyT, coeffT > >	find_me (const keyT &key) const
	find_me. Called by diff_bdry to get coefficients of boundary function

template<typename opT >
void	flo_unary_op_node_inplace (const opT &op, bool fence)

template<typename opT >
void	flo_unary_op_node_inplace (const opT &op, bool fence) const

void	forward_do_diff1 (const DerivativeBase< T, NDIM > D, const implT f, const keyT &key, const std::pair< keyT, coeffT > &left, const std::pair< keyT, coeffT > &center, const std::pair< keyT, coeffT > &right)

template<typename coeff_opT , typename apply_opT >
void	forward_traverse (const coeff_opT &coeff_op, const apply_opT &apply_op, const keyT &key) const
	traverse a non-existing tree

template<typename L , typename R >
void	gaxpy (T alpha, const FunctionImpl< L, NDIM > &left, T beta, const FunctionImpl< R, NDIM > &right, bool fence)
	Invoked by result to perform result += alphaleft+betaright in wavelet basis.

template<typename L >
void	gaxpy_ext (const FunctionImpl< L, NDIM > left, T(f)(const coordT &), T alpha, T beta, double tol, bool fence)

template<typename L >
tensorT	gaxpy_ext_node (keyT key, Tensor< L > lc, T(*f)(const coordT &), T alpha, T beta) const

template<typename L >
void	gaxpy_ext_recursive (const keyT &key, const FunctionImpl< L, NDIM > left, Tensor< L > lcin, tensorT c, T(f)(const coordT &), T alpha, T beta, double tol, bool below_leaf)

template<typename Q , typename R >
void	gaxpy_inplace (const T &alpha, const FunctionImpl< Q, NDIM > &other, const R &beta, bool fence)

template<typename Q , typename R >
void	gaxpy_inplace_reconstructed (const T &alpha, const FunctionImpl< Q, NDIM > &g, const R &beta, const bool fence)

void	gaxpy_oop_reconstructed (const double alpha, const implT &f, const double beta, const implT &g, const bool fence)
	perform: this= alphaf + betag, invoked by result

bool	get_autorefine () const

const FunctionCommonData< T, NDIM > &	get_cdata () const

dcT &	get_coeffs ()

const dcT &	get_coeffs () const

template<std::size_t CDIM>
std::tuple< std::set< Key< NDIM > >, std::map< Key< CDIM >, double > >	get_contraction_node_lists (const std::size_t n, const std::array< int, CDIM > &v) const
	for contraction two functions f(x,z) = \int g(x,y) h(y,z) dy

std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	get_functor ()

std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	get_functor () const

int	get_initial_level () const
	getter

int	get_k () const

Future< double >	get_norm_tree_recursive (const keyT &key) const

const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &	get_pmap () const

int	get_special_level () const

const std::vector< Vector< double, NDIM > > &	get_special_points () const

TensorArgs	get_tensor_args () const

TensorType	get_tensor_type () const

double	get_thresh () const

TreeState	get_tree_state () const

template<std::size_t LDIM, typename leaf_opT >
void	hartree_product (const std::vector< std::shared_ptr< FunctionImpl< T, LDIM > > > p1, const std::vector< std::shared_ptr< FunctionImpl< T, LDIM > > > p2, const leaf_opT &leaf_op, bool fence)
	given two functions of LDIM, perform the Hartree/Kronecker/outer product

bool	has_leaves () const

T	inner_adaptive_local (const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const

T	inner_adaptive_recursive (keyT key, const tensorT &c, const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine, T old_inner=T(0)) const

T	inner_ext_local (const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const

T	inner_ext_node (keyT key, tensorT c, const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f) const
	Return the inner product with an external function on a specified function node.

T	inner_ext_recursive (keyT key, tensorT c, const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine, T old_inner=T(0)) const

void	insert_zero_down_to_initial_level (const keyT &key)
	Initialize nodes to zero function at initial_level of refinement.

bool	is_compressed () const
	Returns true if the function is compressed.

bool	is_nonstandard () const

bool	is_nonstandard_with_leaves () const

bool	is_on_demand () const

bool	is_reconstructed () const
	Returns true if the function is compressed.

bool	is_redundant () const
	Returns true if the function is redundant.

const keyT &	key0 () const
	Returns cdata.key0.

template<typename Archive >
void	load (Archive &ar)

std::vector< keyT >	local_leaf_keys () const
	return the keys of the local leaf boxes

	MADNESS_ASSERT (this->is_redundant()==g.is_redundant())

	MADNESS_CHECK (this->is_reconstructed())

std::pair< coeffT, double >	make_redundant_op (const keyT &key, const std::vector< Future< std::pair< coeffT, double > > > &v)
	similar to compress_op, but insert only the sum coefficients in the tree

template<typename opT >
void	make_Vphi (const opT &leaf_op, const bool fence=true)
	assemble the function V*phi using V and phi given from the functor

template<typename opT , std::size_t LDIM>
void	make_Vphi_only (const opT &leaf_op, FunctionImpl< T, NDIM > ket, FunctionImpl< T, LDIM > v1, FunctionImpl< T, LDIM > v2, FunctionImpl< T, LDIM > p1, FunctionImpl< T, LDIM > p2, FunctionImpl< T, NDIM > eri, const bool fence=true)
	assemble the function V*phi using V and phi given from the functor

void	map_and_mirror (const implT &f, const std::vector< long > &map, const std::vector< long > &mirror, bool fence)
	map and mirror the translation index and the coefficients, result on this

void	mapdim (const implT &f, const std::vector< long > &map, bool fence)
	Permute the dimensions of f according to map, result on this.

std::size_t	max_depth () const
	Returns the maximum depth of the tree ... collective ... global sum/broadcast.

std::size_t	max_local_depth () const
	Returns the maximum local depth of the tree ... no communications.

std::size_t	max_nodes () const
	Returns the max number of nodes on a processor.

template<typename Q , typename R >
void	merge_trees (const T alpha, const FunctionImpl< Q, NDIM > &other, const R beta, const bool fence=true)
	merge the trees of this and other, while multiplying them with the alpha or beta, resp

std::size_t	min_nodes () const
	Returns the min number of nodes on a processor.

void	mirror (const implT &f, const std::vector< long > &mirror, bool fence)
	mirror the dimensions of f according to map, result on this

template<typename R >
Tensor< TENSOR_RESULT_TYPE(T, R)>	mul (const Tensor< T > &c1, const Tensor< R > &c2, const int npt, const keyT &key) const
	multiply the values of two coefficient tensors using a custom number of grid points

template<typename opT >
void	multi_to_multi_op_values (const opT &op, const std::vector< implT * > &vin, std::vector< implT * > &vout, const bool fence=true)
	Inplace operate on many functions (impl's) with an operator within a certain box.

template<typename opT >
void	multi_to_multi_op_values_doit (const keyT &key, const opT &op, const std::vector< implT * > &vin, std::vector< implT * > &vout)
	Inplace operate on many functions (impl's) with an operator within a certain box.

template<typename opT >
void	multiop_values (const opT &op, const std::vector< implT * > &v)

template<typename opT >
void	multiop_values_doit (const keyT &key, const opT &op, const std::vector< implT * > &v)

coeffT	multiply (const coeffT &val_ket, const coeffT &val_pot, int particle) const
	multiply the ket with a one-electron potential rr(1,2)= f(1,2)*g(1)

template<size_t LDIM>
void	multiply (const implT f, const FunctionImpl< T, LDIM > g, const int particle)
	multiply f (a pair function of NDIM) with an orbital g (LDIM=NDIM/2)

template<typename L , typename R >
void	mulXX (const FunctionImpl< L, NDIM > left, const FunctionImpl< R, NDIM > right, double tol, bool fence)

template<typename L , typename R >
void	mulXXa (const keyT &key, const FunctionImpl< L, NDIM > left, const Tensor< L > &lcin, const FunctionImpl< R, NDIM > right, const Tensor< R > &rcin, double tol)

template<typename L , typename R >
void	mulXXvec (const FunctionImpl< L, NDIM > left, const std::vector< const FunctionImpl< R, NDIM > > &vright, const std::vector< FunctionImpl< T, NDIM > * > &vresult, double tol, bool fence)

template<typename L , typename R >
void	mulXXveca (const keyT &key, const FunctionImpl< L, NDIM > left, const Tensor< L > &lcin, const std::vector< const FunctionImpl< R, NDIM > > vrightin, const std::vector< Tensor< R > > &vrcin, const std::vector< FunctionImpl< T, NDIM > * > vresultin, double tol)

std::size_t	nCoeff () const
	Returns the number of coefficients in the function ... collective global sum.

keyT	neighbor (const keyT &key, const keyT &disp, const std::vector< bool > &is_periodic) const
	Returns key of general neighbor enforcing BC.

bool	noautorefine (const keyT &key, const tensorT &t) const
	Always returns false (for when autorefine is not wanted)

double	norm2sq_local () const
	Returns the square of the local norm ... no comms.

void	norm_tree (bool fence)
	compute for each FunctionNode the norm of the function inside that node

double	norm_tree_op (const keyT &key, const std::vector< Future< double > > &v)

Future< double >	norm_tree_spawn (const keyT &key)

template<typename Q >
GenTensor< Q >	NS_fcube_for_mul (const keyT &child, const keyT &parent, const GenTensor< Q > &coeff, const bool s_only) const
	Compute the function values for multiplication.

template<typename Q >
GenTensor< Q >	NScoeffs2values (const keyT &key, const GenTensor< Q > &coeff, const bool s_only) const
	convert S or NS coeffs to values on a 2k grid of the children

const coeffT	parent_to_child (const coeffT &s, const keyT &parent, const keyT &child) const
	Directly project parent coeffs to child coeffs.

coeffT	parent_to_child_NS (const keyT &child, const keyT &parent, const coeffT &coeff) const
	Directly project parent NS coeffs to child NS coeffs.

template<typename Q , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2>
void	partial_inner (const FunctionImpl< Q, LDIM > &g, const FunctionImpl< R, KDIM > &h, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2)
	invoked by result

template<typename Q , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2>
void	partial_inner_contract (const FunctionImpl< Q, LDIM > g, const FunctionImpl< R, KDIM > h, const std::array< int, CDIM > v1, const std::array< int, CDIM > v2, const Key< NDIM > &key, const std::list< Key< CDIM > > &j_key_list)
	tensor contraction part of partial_inner

void	phi_for_mul (Level np, Translation lp, Level nc, Translation lc, Tensor< double > &phi) const
	Compute the Legendre scaling functions for multiplication.

void	plot_cube_kernel (archive::archive_ptr< Tensor< T > > ptr, const keyT &key, const coordT &plotlo, const coordT &plothi, const std::vector< long > &npt, bool eval_refine) const

void	print_grid (const std::string filename) const

void	print_info () const
	Prints summary of data distribution.

void	print_plane (const std::string filename, const int xaxis, const int yaxis, const coordT &el2)
	Print a plane ("xy", "xz", or "yz") containing the point x to file.

Tensor< double >	print_plane_local (const int xaxis, const int yaxis, const coordT &el2)
	collect the data for a plot of the MRA structure locally on each node

void	print_size (const std::string name) const
	print tree size and size

void	print_stats () const
	print the number of configurations per node

void	print_timer () const

void	print_tree (std::ostream &os=std::cout, Level maxlevel=10000) const

void	print_tree_graphviz (std::ostream &os=std::cout, Level maxlevel=10000) const

void	print_tree_json (std::ostream &os=std::cout, Level maxlevel=10000) const

template<typename R >
void	print_type_in_compilation_error (R &&)

void	project (const implT &old, bool fence)
	Projects old function into new basis (only in reconstructed form)

tensorT	project (const keyT &key) const

template<size_t LDIM>
void	project_out (FunctionImpl< T, NDIM-LDIM > result, const FunctionImpl< T, LDIM > gimpl, const int dim, const bool fence)
	project the low-dim function g on the hi-dim function f: result(x) = <this(x,y) \| g(y)>

template<size_t LDIM>
void	project_out2 (const FunctionImpl< T, LDIM+NDIM > f, const FunctionImpl< T, LDIM > g, const int dim)
	project the low-dim function g on the hi-dim function f: this(x) = <f(x,y) \| g(y)>

void	project_refine_op (const keyT &key, bool do_refine, const std::vector< Vector< double, NDIM > > &specialpts)

void	put_in_box (ProcessID from, long nl, long ni) const

rangeT	range (coeffs.begin(), coeffs.end())

template<size_t FDIM>
std::enable_if< NDIM==FDIM >::type	read_grid (const std::string keyfile, const std::string gridfile, std::shared_ptr< FunctionFunctorInterface< double, NDIM > > vnuc_functor)
	read data from a grid

template<size_t FDIM>
std::enable_if< NDIM==FDIM >::type	read_grid2 (const std::string gridfile, std::shared_ptr< FunctionFunctorInterface< double, NDIM > > vnuc_functor)
	read data from a grid

std::size_t	real_size () const
	Returns the number of coefficients in the function ... collective global sum.

void	reconstruct (bool fence)
	reconstruct this tree – respects fence

void	reconstruct_op (const keyT &key, const coeffT &s, const bool accumulate_NS=true)

template<std::size_t CDIM, std::size_t ODIM, std::size_t FDIM = NDIM+ODIM-2*CDIM>
std::multimap< Key< FDIM >, std::list< Key< CDIM > > >	recur_down_for_contraction_map (const keyT &key, const nodeT &node, const std::array< int, CDIM > &v_this, const std::array< int, CDIM > &v_other, const std::set< Key< ODIM > > &ij_other_list, const std::map< Key< CDIM >, double > &j_other_list, bool this_first, const double thresh)
	make a map of all nodes that will contribute to a partial inner product

template<typename opT , std::size_t LDIM>
void	recursive_apply (opT &apply_op, const FunctionImpl< T, LDIM > fimpl, const FunctionImpl< T, LDIM > gimpl, const bool fence)
	traverse a non-existing tree, make its coeffs and apply an operator

template<typename opT >
void	recursive_apply (opT &apply_op, const implT fimpl, implT rimpl, const bool fence)
	traverse an existing tree and apply an operator

return world taskq	reduce (range, do_inner_local_on_demand< R >(this, &gimpl))

return world taskq	reduce (rangeT(coeffs.begin(), coeffs.end()), do_inner_local< R >(&g, leaves_only))

void	reduce_rank (const double thresh, bool fence)
	reduce the rank of the coefficients tensors

template<typename opT >
void	refine (const opT &op, bool fence)

template<typename opT >
void	refine_op (const opT &op, const keyT &key)

template<typename opT >
void	refine_spawn (const opT &op, const keyT &key)

void	refine_to_common_level (const std::vector< FunctionImpl< T, NDIM > * > &v, const std::vector< tensorT > &c, const keyT key)
	Refine multiple functions down to the same finest level.

void	remove_internal_coefficients (const bool fence)

void	remove_leaf_coefficients (const bool fence)

void	replicate (bool fence=true)

void	reset_timer ()

void	scale_inplace (const T q, bool fence)
	In-place scale by a constant.

template<typename Q , typename F >
void	scale_oop (const Q q, const FunctionImpl< F, NDIM > &f, bool fence)
	Out-of-place scale by a constant.

void	set_autorefine (bool value)

void	set_functor (const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor1)

void	set_tensor_args (const TensorArgs &t)

void	set_thresh (double value)

void	set_tree_state (const TreeState &state)

std::size_t	size () const
	Returns the number of coefficients in the function ... collective global sum.

void	sock_it_to_me (const keyT &key, const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &ref) const
	Walk up the tree returning pair(key,node) for first node with coefficients.

void	sock_it_to_me_too (const keyT &key, const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &ref) const

void	square_inplace (bool fence)
	Pointwise squaring of function with optional global fence.

void	standard (bool fence)
	Changes non-standard compressed form to standard compressed form.

template<typename Archive >
void	store (Archive &ar)

void	sum_down (bool fence)
	After 1d push operator must sum coeffs down the tree to restore correct scaling function coefficients.

void	sum_down_spawn (const keyT &key, const coeffT &s)
	is this the same as trickle_down() ?

template<typename R >
	TENSOR_RESULT_TYPE (T, R) inner_local(const FunctionImpl< R
	Returns the inner product ASSUMING same distribution.

template<typename R >
	TENSOR_RESULT_TYPE (T, R) inner_local_on_demand(const FunctionImpl< R
	Returns the inner product of this with function g constructed on-the-fly.

typedef	TENSOR_RESULT_TYPE (T, R) resultT

T	trace_local () const
	Returns `int(f(x),x)` in local volume.

template<typename coeff_opT , typename apply_opT >
void	traverse_tree (const coeff_opT &coeff_op, const apply_opT &apply_op, const keyT &key) const
	traverse a non-existing tree

std::size_t	tree_size () const
	Returns the size of the tree structure of the function ... collective global sum.

void	trickle_down (bool fence)
	sum all the contributions from all scales after applying an operator in mod-NS form

void	trickle_down_op (const keyT &key, const coeffT &s)
	sum all the contributions from all scales after applying an operator in mod-NS form

void	truncate (double tol, bool fence)
	Truncate according to the threshold with optional global fence.

bool	truncate_op (const keyT &key, double tol, const std::vector< Future< bool > > &v)

coeffT	truncate_reconstructed_op (const keyT &key, const std::vector< Future< coeffT > > &v, const double tol)
	given the sum coefficients of all children, truncate or not

Future< coeffT >	truncate_reconstructed_spawn (const keyT &key, const double tol)
	truncate using a tree in reconstructed form

Future< bool >	truncate_spawn (const keyT &key, double tol)
	Returns true if after truncation this node has coefficients.

double	truncate_tol (double tol, const keyT &key) const
	Returns the truncation threshold according to truncate_method.

template<typename opT >
void	unary_op_coeff_inplace (const opT &op, bool fence)

template<typename opT >
void	unary_op_node_inplace (const opT &op, bool fence)

template<typename opT >
void	unary_op_value_inplace (const opT &op, bool fence)

template<typename Q , typename opT >
void	unaryXX (const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)

template<typename Q , typename opT >
void	unaryXXa (const keyT &key, const FunctionImpl< Q, NDIM > *func, const opT &op)

template<typename Q , typename opT >
void	unaryXXvalues (const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)

void	undo_redundant (const bool fence)
	convert this from redundant to standard reconstructed form

coeffT	unfilter (const coeffT &s) const

tensorT	unfilter (const tensorT &s) const
	Transform sums+differences at level n to sum coefficients at level n+1.

void	unset_functor ()

coeffT	upsample (const keyT &key, const coeffT &coeff) const
	upsample the sum coefficients of level 1 to sum coeffs on level n+1

template<typename Q >
GenTensor< Q >	values2coeffs (const keyT &key, const GenTensor< Q > &values) const

template<typename Q >
Tensor< Q >	values2coeffs (const keyT &key, const Tensor< Q > &values) const

template<typename Q >
GenTensor< Q >	values2NScoeffs (const keyT &key, const GenTensor< Q > &values) const
	convert function values of the a child generation directly to NS coeffs

void	verify_tree () const
	Verify tree is properly constructed ... global synchronization involved.

double	vol_nsphere (int n, double R)

template<typename Q , typename R >
void	vtransform (const std::vector< std::shared_ptr< FunctionImpl< R, NDIM > > > &vright, const Tensor< Q > &c, const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > &vleft, double tol, bool fence)

template<typename Q , typename R >
void	vtransform_doit (const std::shared_ptr< FunctionImpl< R, NDIM > > &right, const Tensor< Q > &c, const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > &vleft, double tol)

void	zero_norm_tree ()

Public Member Functions inherited from madness::WorldObject< FunctionImpl< T, NDIM > >
	WorldObject (const WorldObject &other)

	WorldObject (World &world)
	Constructor that associates an object (via the derived class) with a globally unique ID.

virtual	~WorldObject ()

World &	get_world () const
	Returns a reference to the `world`.

const uniqueidT &	id () const
	Returns the globally unique object ID.

WorldObject &	operator= (const WorldObject &)=delete

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8) const

detail::task_result_type< memfnT >::futureT	send (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8, const a9T &a9) const

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8, const a9T &a9, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4,a5,a6,a7,a8,a9)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const a8T &a8, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4,a5,a6,a7,a8)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const a7T &a7, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4,a5,a6,a7)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const a6T &a6, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4,a5,a6)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const a5T &a5, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4,a5)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const a4T &a4, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3,a4)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const a3T &a3, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2,a3)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const a2T &a2, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1,a2)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const a1T &a1, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)(a1)`.

detail::task_result_type< memfnT >::futureT	task (ProcessID dest, memfnT memfn, const TaskAttributes &attr=TaskAttributes()) const
	Sends task to derived class method `returnT (this->*memfn)()`.

Public Member Functions inherited from madness::WorldObjectBase
virtual	~WorldObjectBase ()=default

Static Public Member Functions
static std::complex< double >	conj (const std::complex< double > x)

static double	conj (float x)

template<typename R >
static void	do_dot_localX (const typename mapT::iterator lstart, const typename mapT::iterator lend, typename FunctionImpl< R, NDIM >::mapT rmap_ptr, const bool sym, Tensor< TENSOR_RESULT_TYPE(T, R)> result_ptr, Mutex *mutex)

template<typename R >
static void	do_inner_localX (const typename mapT::iterator lstart, const typename mapT::iterator lend, typename FunctionImpl< R, NDIM >::mapT rmap_ptr, const bool sym, Tensor< TENSOR_RESULT_TYPE(T, R) > result_ptr, Mutex *mutex)

template<typename R >
static Tensor< TENSOR_RESULT_TYPE(T, R)>	dot_local (const std::vector< const FunctionImpl< T, NDIM > * > &left, const std::vector< const FunctionImpl< R, NDIM > * > &right, bool sym)

template<typename R >
static Tensor< TENSOR_RESULT_TYPE(T, R) >	inner_local (const std::vector< const FunctionImpl< T, NDIM > * > &left, const std::vector< const FunctionImpl< R, NDIM > * > &right, bool sym)

static mapT	make_key_vec_map (const std::vector< const FunctionImpl< T, NDIM > * > &v)
	Returns map of union of local keys to vector of indexes of functions containing that key.

static void	tnorm (const GenTensor< T > &t, double lo, double hi)

static void	tnorm (const SVDTensor< T > &t, double lo, double hi, const int particle)

static void	tnorm (const tensorT &t, double lo, double hi)
	Computes norm of low/high-order polyn. coeffs for autorefinement test.

Public Attributes
long	box_interior [1000]

long	box_leaf [1000]

NDIM &g	const

NDIM &gimpl	const

AtomicInt	large

bool	leaves_only =(this->is_redundant())

AtomicInt	small

Timer	timer_accumulate

Timer	timer_change_tensor_type

Timer	timer_compress_svd

Timer	timer_filter

Timer	timer_lr_result

Timer	timer_target_driven

World &	world

Private Types
typedef WorldObject< FunctionImpl< T, NDIM > >	woT
	Base class world object type.

Private Member Functions
	FunctionImpl (const FunctionImpl< T, NDIM > &p)

void	make_redundant (const bool fence)
	convert this to redundant, i.e. have sum coefficients on all levels

Private Attributes
bool	autorefine
	If true, autorefine where appropriate.

const FunctionCommonData< T, NDIM > &	cdata

dcT	coeffs
	The coefficients.

std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	functor

int	initial_level
	Initial level for refinement.

int	k
	Wavelet order.

int	max_refine_level
	Do not refine below this level.

int	special_level
	Minimium level for refinement on special points.

std::vector< Vector< double, NDIM > >	special_points
	special points for further refinement (needed for composite functions or multiplication)

TensorArgs	targs
	type of tensor to be used in the FunctionNodes

double	thresh
	Screening threshold.

TreeState	tree_state

int	truncate_mode
	0=default=(\|d\|<thresh), 1=(\|d\|<thresh/2^n), 1=(\|d\|<thresh/4^n);

bool	truncate_on_project
	If true projection inserts at level n-1 not n.

Friends
template<typename Q , std::size_t D>
class	FunctionImpl

hashT	hash_value (const FunctionImpl< T, NDIM > *pimpl)
	Hash a pointer to `FunctionImpl`.

hashT	hash_value (const std::shared_ptr< FunctionImpl< T, NDIM > > impl)
	Hash a shared_ptr to `FunctionImpl`.

Additional Inherited Members
Protected Member Functions inherited from madness::WorldObject< FunctionImpl< T, NDIM > >
void	process_pending ()
	To be called from derived constructor to process pending messages.

Detailed Description

template<typename T, std::size_t NDIM>
class madness::FunctionImpl< T, NDIM >

FunctionImpl holds all Function state to facilitate shallow copy semantics.

Since Function assignment and copy constructors are shallow it greatly simplifies maintaining consistent state to have all (permanent) state encapsulated in a single class. The state is shared between instances using a shared_ptr<FunctionImpl>.

The FunctionImpl inherits all of the functionality of WorldContainer (to store the coefficients) and WorldObject<WorldContainer> (used for RMI and for its unqiue id).

The class methods are public to avoid painful multiple friend template declarations for Function and FunctionImpl ... but this trust should not be abused ... NOTHING except FunctionImpl methods should mess with FunctionImplData. The LB stuff might have to be an exception.

Member Typedef Documentation

◆ coeffT

template<typename T , std::size_t NDIM>

typedef GenTensor<T> madness::FunctionImpl< T, NDIM >::coeffT

Type of tensor used to hold coeffs.

◆ coordT

template<typename T , std::size_t NDIM>

typedef Vector<double,NDIM> madness::FunctionImpl< T, NDIM >::coordT

Type of vector holding coordinates.

◆ datumT

template<typename T , std::size_t NDIM>

typedef std::pair<const keyT,nodeT> madness::FunctionImpl< T, NDIM >::datumT

Type of entry in container.

◆ dcT

template<typename T , std::size_t NDIM>

typedef WorldContainer<keyT,nodeT> madness::FunctionImpl< T, NDIM >::dcT

Type of container holding the coefficients.

◆ implT

template<typename T , std::size_t NDIM>

typedef FunctionImpl<T,NDIM> madness::FunctionImpl< T, NDIM >::implT

Type of this class (implementation)

◆ keyT

template<typename T , std::size_t NDIM>

typedef Key<NDIM> madness::FunctionImpl< T, NDIM >::keyT

Type of key.

◆ mapT

template<typename T , std::size_t NDIM>

typedef ConcurrentHashMap< keyT, mapvecT > madness::FunctionImpl< T, NDIM >::mapT

Type of the map returned by make_key_vec_map.

◆ mapvecT

template<typename T , std::size_t NDIM>

typedef std::vector< std::pair<int,const coeffT*> > madness::FunctionImpl< T, NDIM >::mapvecT

Type of the entry in the map returned by make_key_vec_map.

◆ nodeT

template<typename T , std::size_t NDIM>

typedef FunctionNode<T,NDIM> madness::FunctionImpl< T, NDIM >::nodeT

Type of node.

◆ pimplT

template<typename T , std::size_t NDIM>

typedef std::shared_ptr< FunctionImpl<T,NDIM> > madness::FunctionImpl< T, NDIM >::pimplT

pointer to this class

◆ rangeT [1/2]

template<typename T , std::size_t NDIM>

typedef Range<typename dcT::const_iterator> madness::FunctionImpl< T, NDIM >::rangeT

◆ rangeT [2/2]

template<typename T , std::size_t NDIM>

typedef Range<typename dcT::const_iterator> madness::FunctionImpl< T, NDIM >::rangeT

◆ tensorT

template<typename T , std::size_t NDIM>

typedef Tensor<T> madness::FunctionImpl< T, NDIM >::tensorT

Type of tensor for anything but to hold coeffs.

◆ tranT

template<typename T , std::size_t NDIM>

typedef Vector<Translation,NDIM> madness::FunctionImpl< T, NDIM >::tranT

Type of array holding translation.

◆ typeT

template<typename T , std::size_t NDIM>

typedef T madness::FunctionImpl< T, NDIM >::typeT

◆ woT

template<typename T , std::size_t NDIM>

typedef WorldObject< FunctionImpl<T,NDIM> > madness::FunctionImpl< T, NDIM >::woT

private

Base class world object type.

Constructor & Destructor Documentation

◆ FunctionImpl() [1/3]

template<typename T , std::size_t NDIM>

madness::FunctionImpl< T, NDIM >::FunctionImpl ( const FunctionImpl< T, NDIM > & p )

private

◆ FunctionImpl() [2/3]

template<typename T , std::size_t NDIM>

madness::FunctionImpl< T, NDIM >::FunctionImpl ( const FunctionFactory< T, NDIM > & factory )

inline

Initialize function impl from data in factory.

◆ FunctionImpl() [3/3]

template<typename T , std::size_t NDIM>

template<typename Q >

madness::FunctionImpl< T, NDIM >::FunctionImpl	(	const FunctionImpl< Q, NDIM > &	other,
		const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &	pmap,
		bool	dozero
	)

inline

Copy constructor.

Allocates a new function in preparation for a deep copy

By default takes pmap from other but can also specify a different pmap. Does not copy the coefficients ... creates an empty container.

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::FunctionImpl< T, NDIM >::initial_level, madness::FunctionImpl< T, NDIM >::insert_zero_down_to_initial_level(), madness::WorldObject< FunctionImpl< T, NDIM > >::process_pending(), and madness::WorldContainer< keyT, valueT, hashfunT >::process_pending().

◆ ~FunctionImpl()

template<typename T , std::size_t NDIM>

virtual madness::FunctionImpl< T, NDIM >::~FunctionImpl ( )

inlinevirtual

Member Function Documentation

◆ abs_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::abs_inplace ( bool fence )

◆ abs_square_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::abs_square_inplace ( bool fence )

◆ accumulate_timer()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::accumulate_timer ( const double time ) const

◆ accumulate_trees()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::accumulate_trees	(	FunctionImpl< Q, NDIM > &	result,
		const R	alpha,
		const bool	fence = `true`
	)		const

inline

merge the trees of this and other, while multiplying them with the alpha or beta, resp

result and rhs do not have to have the same distribution or live in the same world result+=alpha* this

Parameters

[in] alpha prefactor for this

References alpha, and madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace().

◆ add_keys_to_map()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::add_keys_to_map	(	mapT *	map,
		int	index
	)		const

inline

Adds keys to union of local keys with specified index.

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), and madness::FunctionNode< T, NDIM >::has_coeff().

◆ add_scalar_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::add_scalar_inplace	(	T	t,
		bool	fence
	)

Adds a constant to the function. Local operation, optional fence.

In scaling function basis must add value to first polyn in each box with appropriate scaling for level. In wavelet basis need only add at level zero.

Parameters

[in] t the scalar to be added

References madness::change_tensor_type(), madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::full_tensor(), madness::FunctionNode< T, NDIM >::has_coeff(), L, MADNESS_ASSERT, NDIM, pow(), madness::TT_FULL, and madness::ttt.

◆ apply()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

void madness::FunctionImpl< T, NDIM >::apply	(	opT &	op,
		const FunctionImpl< R, NDIM > &	f,
		bool	fence
	)

inline

◆ apply_1d_realspace_push()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

void madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push	(	const opT &	op,
		const FunctionImpl< R, NDIM > *	f,
		int	axis,
		bool	fence
	)

inline

References axis, c, madness::f, madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, madness::WorldObject< FunctionImpl< T, NDIM > >::me, op(), madness::World::rank(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ apply_1d_realspace_push_op()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

void madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push_op	(	const archive::archive_ptr< const opT > &	pop,
		int	axis,
		const keyT &	key,
		const Tensor< R > &	c
	)

inline

References madness::FunctionNode< T, NDIM >::accumulate2(), axis, c, madness::FunctionImpl< T, NDIM >::coeffs, madness::TaskAttributes::hipri(), madness::Key< NDIM >::level(), madness::Tensor< T >::normf(), op(), madness::pop(), madness::Tensor< T >::ptr(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::FunctionImpl< T, NDIM >::thresh, madness::transform_dir(), madness::Key< NDIM >::translation(), and madness::FunctionImpl< T, NDIM >::truncate_tol().

◆ apply_source_driven()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

void madness::FunctionImpl< T, NDIM >::apply_source_driven	(	opT &	op,
		const FunctionImpl< R, NDIM > &	f,
		bool	fence
	)

inline

similar to apply, but for low rank coeffs

References madness::FunctionImpl< T, NDIM >::coeffs, madness::f, madness::WorldGopInterface::fence(), madness::FunctionDefaults< NDIM >::get_apply_randomize(), madness::World::gop, madness::GenTensor< T >::has_data(), MADNESS_ASSERT, madness::nonstandard_after_apply, op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), PROFILE_MEMBER_FUNC, madness::World::random_proc(), madness::GenTensor< T >::rank(), madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ assemble_coefficients()

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::assemble_coefficients	(	const keyT &	key,
		const coeffT &	coeff_ket,
		const coeffT &	vpotential1,
		const coeffT &	vpotential2,
		const tensorT &	veri
	)		const

given several coefficient tensors, assemble a result tensor

the result looks like: (v(1,2) + v(1) + v(2)) |ket(1,2)> or (v(1,2) + v(1) + v(2)) |p(1) p(2)> i.e. coefficients for the ket and coefficients for the two particles are mutually exclusive. All potential terms are optional, just pass in empty coeffs.

Parameters

[in]	key	the key of the FunctionNode to which these coeffs belong
[in]	coeff_ket	coefficients of the ket
[in]	vpotential1	function values of the potential for particle 1
[in]	vpotential2	function values of the potential for particle 2
[in]	veri	function values for the 2-particle potential

the result looks like: (v(1,2) + v(1) + v(2)) |ket(1,2)> or (v(1,2) + v(1) + v(2)) |p(1) p(2)> i.e. coefficients for the ket and coefficients for the two particles are mutually exclusive. All potential terms are optional, just pass in empty coeffs.

Parameters

[in]	key	the key of the FunctionNode to which these coeffs belong
[in]	cket	coefficients of the ket
[in]	vpotential1	function values of the potential for particle 1
[in]	vpotential2	function values of the potential for particle 2
[in]	veri	function values for the 2-particle potential

References madness::GenTensor< T >::convert(), madness::GenTensor< T >::dims(), madness::GenTensor< T >::full_tensor_copy(), madness::GenTensor< T >::has_data(), madness::Tensor< T >::has_data(), MADNESS_ASSERT, madness::multiply(), madness::GenTensor< T >::ndim(), madness::GenTensor< T >::reduce_rank(), thresh, and madness::TT_2D.

◆ autorefine_square_test()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::autorefine_square_test	(	const keyT &	key,
		const nodeT &	t
	)		const

Returns true if this block of coeffs needs autorefining.

References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::full_tensor_copy(), lo, test(), and thresh.

◆ average()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::average ( const implT & rhs )

take the average of two functions, similar to: this=0.5*(this+rhs)

works in either basis and also in nonstandard form

References madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace().

◆ binaryXX()

template<typename T , std::size_t NDIM>

template<typename L , typename R , typename opT >

void madness::FunctionImpl< T, NDIM >::binaryXX	(	const FunctionImpl< L, NDIM > *	left,
		const FunctionImpl< R, NDIM > *	right,
		const opT &	op,
		bool	fence
	)

inline

Performs binary operation on two functions (impl's). Delegates to the binaryXXa() method

Parameters

[in]	left	pointer to the left function impl
[in]	right	pointer to the right function impl
[in]	op	the binary operator

References madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), and madness::FunctionImpl< T, NDIM >::world.

◆ binaryXXa()

template<typename T , std::size_t NDIM>

template<typename L , typename R , typename opT >

void madness::FunctionImpl< T, NDIM >::binaryXXa	(	const keyT &	key,
		const FunctionImpl< L, NDIM > *	left,
		const Tensor< L > &	lcin,
		const FunctionImpl< R, NDIM > *	right,
		const Tensor< R > &	rcin,
		const opT &	op
	)

inline

Both left and right functions are in the scaling function basis

Parameters

[in]	key	the key to the current function node (box)
[in]	left	the function impl associated with the left function
[in]	lcin	the scaling function coefficients associated with the current box in the left function
[in]	right	the function impl associated with the right function
[in]	rcin	the scaling function coefficients associated with the current box in the right function
[in]	op	the binary operator

References madness::___, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), MADNESS_ASSERT, op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::BaseTensor::size(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::unfilter().

Referenced by madness::FunctionImpl< T, NDIM >::binaryXX().

◆ broaden()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::broaden	(	std::vector< bool >	is_periodic,
		bool	fence
	)

◆ broaden_op()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::broaden_op	(	const keyT &	key,
		const std::vector< Future< bool > > &	v
	)

◆ change_tensor_type1()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::change_tensor_type1	(	const TensorArgs &	targs,
		bool	fence
	)

change the tensor type of the coefficients in the FunctionNode

Parameters

[in] targs target tensor arguments (threshold and full/low rank)

◆ change_tree_state()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::change_tree_state	(	const TreeState	finalstate,
		bool	fence = `true`
	)

change the tree state of this function, might or might not respect fence!

References madness::compress(), madness::compressed, MADNESS_CHECK, MADNESS_CHECK_THROW, madness::nonstandard, madness::nonstandard_after_apply, madness::nonstandard_with_leaves, madness::reconstruct(), madness::reconstructed, madness::redundant, and madness::standard().

Referenced by madness::partial_mul().

◆ check_symmetry_local()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::check_symmetry_local ( ) const

Returns some asymmetry measure ... no comms.

References PROFILE_MEMBER_FUNC.

◆ child_patch()

template<typename T , std::size_t NDIM>

std::vector< Slice > madness::FunctionImpl< T, NDIM >::child_patch ( const keyT & child ) const

Returns patch referring to coeffs of child in parent box.

Returns patch referring to coeffs of child in parent box

Parameters

[in] child the key to the child function node (box)

References NDIM, and madness::Key< NDIM >::translation().

◆ chop_at_level()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::chop_at_level	(	const int	n,
		const bool	fence = `true`
	)

remove all nodes with level higher than n

reduce the rank of the coefficients tensors

Parameters

[in] targs target tensor arguments (threshold and full/low rank)

◆ coeffs2values() [1/2]

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::coeffs2values	(	const keyT &	key,
		const GenTensor< Q > &	coeff
	)		const

inline

Return the values when given the coeffs in scaling function basis

Parameters

[in]	key	the key of the function node (box)
[in]	coeff	the tensor of scaling function coefficients for function node (box)

Returns: function values for function node (box)

References madness::FunctionImpl< T, NDIM >::cdata, madness::Key< NDIM >::level(), NDIM, pow(), madness::scale(), and madness::transform().

Referenced by madness::FunctionImpl< T, NDIM >::fcube_for_mul(), madness::FunctionImpl< T, NDIM >::fcube_for_mul(), madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values_doit(), madness::FunctionImpl< T, NDIM >::multiop_values_doit(), madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::coeff_value_adaptor< Q, opT >::operator()().

◆ coeffs2values() [2/2]

template<typename T , std::size_t NDIM>

template<typename Q >

Tensor< Q > madness::FunctionImpl< T, NDIM >::coeffs2values	(	const keyT &	key,
		const Tensor< Q > &	coeff
	)		const

inline

Return the scaling function coeffs when given the function values at the quadrature points

Parameters

[in] key the key of the function node (box)

Returns: function values for function node (box)

References madness::FunctionImpl< T, NDIM >::cdata, madness::Key< NDIM >::level(), NDIM, pow(), madness::scale(), and madness::transform().

◆ compress()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::compress	(	const TreeState	newstate,
		bool	fence
	)

compress the wave function

after application there will be sum coefficients at the root level, and difference coefficients at all other levels; furthermore:

Parameters

[in]	nonstandard	keep sum coeffs at all other levels, except leaves
[in]	keepleaves	keep sum coeffs (but no diff coeffs) at leaves
[in]	redundant	keep only sum coeffs at all levels, discard difference coeffs

References MADNESS_CHECK_THROW, madness::nonstandard, madness::nonstandard_with_leaves, and madness::redundant.

◆ compress_op()

template<typename T , std::size_t NDIM>

std::pair< typename FunctionImpl< T, NDIM >::coeffT, double > madness::FunctionImpl< T, NDIM >::compress_op	(	const keyT &	key,
		const std::vector< Future< std::pair< coeffT, double > > > &	v,
		bool	nonstandard1
	)

calculate the wavelet coefficients using the sum coefficients of all child nodes

also compute the norm tree for all nodes

Parameters

[in]	key	this's key
[in]	v	sum coefficients of the child nodes
[in]	nonstandard	keep the sum coefficients with the wavelet coefficients
[in]	redundant	keep only the sum coefficients, discard the wavelet coefficients

Returns: the sum coefficients

Parameters

[in]	key	this's key
[in]	v	sum coefficients of the child nodes
[in]	nonstandard	keep the sum coefficients with the wavelet coefficients
[in]	redundant	keep only the sum coefficients, discard the wavelet coefficients

Returns: the sum coefficients

References madness::cpu_time(), and d.

◆ compress_spawn()

template<typename T , std::size_t NDIM>

Future< std::pair< GenTensor< T >, double > > madness::FunctionImpl< T, NDIM >::compress_spawn	(	const keyT &	key,
		bool	nonstandard1,
		bool	keepleaves,
		bool	redundant1
	)

Invoked on node where key is local.

will insert

Returns: s coefficient and norm_tree for key

References MADNESS_ASSERT, and madness::print().

◆ compute_snorm_and_dnorm()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::compute_snorm_and_dnorm ( bool fence = true )

compute norm of s and d coefficients for all nodes

Parameters

[in] targs target tensor arguments (threshold and full/low rank)

◆ conj() [1/2]

template<typename T , std::size_t NDIM>

static std::complex< double > madness::FunctionImpl< T, NDIM >::conj ( const std::complex< double > x )

inlinestatic

◆ conj() [2/2]

template<typename T , std::size_t NDIM>

static double madness::FunctionImpl< T, NDIM >::conj ( float x )

inlinestatic

Referenced by madness::FunctionImpl< T, NDIM >::dot_local(), and madness::FunctionImpl< T, NDIM >::inner_local().

◆ copy_coeffs()

template<typename T , std::size_t NDIM>

template<typename Q >

void madness::FunctionImpl< T, NDIM >::copy_coeffs	(	const FunctionImpl< Q, NDIM > &	other,
		bool	fence
	)

inline

Copy coeffs from other into self.

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::World::gop, madness::WorldContainer< keyT, valueT, hashfunT >::replace(), and madness::FunctionImpl< T, NDIM >::world.

◆ diff()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::diff	(	const DerivativeBase< T, NDIM > *	D,
		const implT *	f,
		bool	fence
	)

References madness::f, and madness::TaskAttributes::hipri().

◆ dirac_convolution_op()

template<typename T , std::size_t NDIM>

template<std::size_t LDIM>

void madness::FunctionImpl< T, NDIM >::dirac_convolution_op	(	const keyT &	key,
		const nodeT &	node,
		FunctionImpl< T, LDIM > *	f
	)		const

inline

The operator.

Integrate over one particle of a two particle function and get a one particle function bsp \int g(1,2) \delta(2-1) d2 = f(1) The overall dimension of g should be even

References madness::_(), madness::Key< NDIM >::break_apart(), madness::FunctionNode< T, NDIM >::coeff(), madness::copy(), madness::GenTensor< T >::dim(), madness::Tensor< T >::emul(), madness::f, madness::g, madness::GenTensor< T >::get_svdtensor(), madness::FunctionNode< T, NDIM >::has_children(), madness::TaskAttributes::hipri(), MADNESS_ASSERT, and madness::GenTensor< T >::rank().

◆ distribute()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::distribute ( std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > newmap ) const

inline

References madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::get_pmap(), and madness::FunctionImpl< T, NDIM >::world.

◆ do_apply()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

void madness::FunctionImpl< T, NDIM >::do_apply	(	const opT *	op,
		const keyT &	key,
		const Tensor< R > &	c
	)

inline

apply an operator on the coeffs c (at node key)

the result is accumulated inplace to this's tree at various FunctionNodes

Parameters

[in]	op	the operator to act on the source function
[in]	key	key of the source FunctionNode of f which is processed
[in]	c	coeffs of the FunctionNode of f which is processed

References madness::FunctionNode< T, NDIM >::accumulate2(), c, madness::FunctionImpl< T, NDIM >::coeffs, d, madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), madness::Key< NDIM >::is_valid(), madness::FunctionImpl< T, NDIM >::k, madness::Key< NDIM >::level(), NDIM, madness::FunctionImpl< T, NDIM >::neighbor(), madness::Tensor< T >::normf(), op(), PROFILE_MEMBER_FUNC, madness::WorldContainer< keyT, valueT, hashfunT >::send(), source(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::FunctionImpl< T, NDIM >::thresh, madness::FunctionImpl< T, NDIM >::truncate_tol(), and madness::FunctionImpl< T, NDIM >::vol_nsphere().

◆ do_apply_directed_screening()

template<typename T , std::size_t NDIM>

template<typename opT , typename R >

double madness::FunctionImpl< T, NDIM >::do_apply_directed_screening	(	const opT *	op,
		const keyT &	key,
		const coeffT &	coeff,
		const bool &	do_kernel
	)

inline

apply an operator on the coeffs c (at node key)

invoked by result; the result is accumulated inplace to this's tree at various FunctionNodes

Parameters

[in]	op	the operator to act on the source function
[in]	key	key of the source FunctionNode of f which is processed (see "source")
[in]	coeff	coeffs of FunctionNode being processed
[in]	do_kernel	true: do the 0-disp only; false: do everything but the kernel

Returns: max norm, and will modify or include new nodes in this' tree

References madness::GenTensor< T >::convert(), d, madness::FunctionImpl< T, NDIM >::do_apply_kernel2(), madness::FunctionImpl< T, NDIM >::do_apply_kernel3(), madness::GenTensor< T >::full_tensor_copy(), madness::GenTensor< T >::get_svdtensor(), madness::Tensor< T >::has_data(), madness::Key< NDIM >::is_valid(), madness::Key< NDIM >::level(), MADNESS_EXCEPTION, madness::Key< NDIM >::merge_with(), NDIM, madness::FunctionImpl< T, NDIM >::neighbor(), norm(), madness::GenTensor< T >::normf(), op(), PROFILE_MEMBER_FUNC, source(), madness::FunctionImpl< T, NDIM >::targs, madness::FunctionImpl< T, NDIM >::thresh, madness::TensorArgs::thresh, madness::FunctionImpl< T, NDIM >::truncate_tol(), and madness::TT_2D.

Referenced by madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::recursive_apply_op2< opT >::operator()().

◆ do_apply_kernel()

template<typename T , std::size_t NDIM>

template<typename opT , typename R , size_t OPDIM>

void madness::FunctionImpl< T, NDIM >::do_apply_kernel	(	const opT *	op,
		const Tensor< R > &	c,
		const do_op_args< OPDIM > &	args
	)

inline

for fine-grain parallelism: call the apply method of an operator in a separate task

Parameters

[in]	op	the operator working on our function
[in]	c	full rank tensor holding the NS coefficients
[in]	args	laziness holding norm of the coefficients, displacement, destination, ..

◆ do_apply_kernel2()

template<typename T , std::size_t NDIM>

template<typename opT , typename R , size_t OPDIM>

double madness::FunctionImpl< T, NDIM >::do_apply_kernel2	(	const opT *	op,
		const Tensor< R > &	c,
		const do_op_args< OPDIM > &	args,
		const TensorArgs &	apply_targs
	)

inline

same as do_apply_kernel, but use full rank tensors as input and low rank tensors as output

Parameters

[in]	op	the operator working on our function
[in]	c	full rank tensor holding the NS coefficients
[in]	args	laziness holding norm of the coefficients, displacement, destination, ..
[in]	apply_targs	TensorArgs with tightened threshold for accumulation

Returns: nothing, but accumulate the result tensor into the destination node

Referenced by madness::FunctionImpl< T, NDIM >::do_apply_directed_screening().

◆ do_apply_kernel3()

template<typename T , std::size_t NDIM>

template<typename opT , typename R , size_t OPDIM>

double madness::FunctionImpl< T, NDIM >::do_apply_kernel3	(	const opT *	op,
		const GenTensor< R > &	coeff,
		const do_op_args< OPDIM > &	args,
		const TensorArgs &	apply_targs
	)

inline

same as do_apply_kernel2, but use low rank tensors as input and low rank tensors as output

Parameters

[in]	op	the operator working on our function
[in]	coeff	full rank tensor holding the NS coefficients
[in]	args	laziness holding norm of the coefficients, displacement, destination, ..
[in]	apply_targs	TensorArgs with tightened threshold for accumulation

Returns: nothing, but accumulate the result tensor into the destination node

Referenced by madness::FunctionImpl< T, NDIM >::do_apply_directed_screening().

◆ do_binary_op()

template<typename T , std::size_t NDIM>

template<typename L , typename R , typename opT >

void madness::FunctionImpl< T, NDIM >::do_binary_op	(	const keyT &	key,
		const Tensor< L > &	left,
		const std::pair< keyT, Tensor< R > > &	arg,
		const opT &	op
	)

inline

Functor for the binary_op method.

References madness::arg(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::FunctionImpl< T, NDIM >::fcube_for_mul(), madness::Key< NDIM >::level(), NDIM, op(), pow(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::Tensor< T >::scale(), madness::scale(), madness::FunctionImpl< T, NDIM >::targs, and madness::transform().

◆ do_diff1()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_diff1	(	const DerivativeBase< T, NDIM > *	D,
		const implT *	f,
		const keyT &	key,
		const std::pair< keyT, coeffT > &	left,
		const std::pair< keyT, coeffT > &	center,
		const std::pair< keyT, coeffT > &	right
	)

References madness::f.

◆ do_dirac_convolution()

template<typename T , std::size_t NDIM>

template<std::size_t LDIM>

void madness::FunctionImpl< T, NDIM >::do_dirac_convolution	(	FunctionImpl< T, LDIM > *	f,
		bool	fence
	)		const

inline

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::Key< NDIM >::break_apart(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::f, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionNode< T, NDIM >::is_leaf(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ do_dot_localX()

template<typename T , std::size_t NDIM>

template<typename R >

static void madness::FunctionImpl< T, NDIM >::do_dot_localX	(	const typename mapT::iterator	lstart,
		const typename mapT::iterator	lend,
		typename FunctionImpl< R, NDIM >::mapT *	rmap_ptr,
		const bool	sym,
		Tensor< TENSOR_RESULT_TYPE(T, R)> *	result_ptr,
		Mutex *	mutex
	)

inlinestatic

References madness::_(), madness::Mutex::lock(), madness::mxmT(), madness::Tensor< T >::ptr(), R, madness::FunctionImpl< T, NDIM >::size(), T(), TENSOR_RESULT_TYPE, and madness::Mutex::unlock().

◆ do_inner_localX()

template<typename T , std::size_t NDIM>

template<typename R >

static void madness::FunctionImpl< T, NDIM >::do_inner_localX	(	const typename mapT::iterator	lstart,
		const typename mapT::iterator	lend,
		typename FunctionImpl< R, NDIM >::mapT *	rmap_ptr,
		const bool	sym,
		Tensor< TENSOR_RESULT_TYPE(T, R) > *	result_ptr,
		Mutex *	mutex
	)

inlinestatic

References madness::_(), madness::Tensor< T >::conj(), madness::Mutex::lock(), madness::mxmT(), madness::Tensor< T >::ptr(), R, madness::FunctionImpl< T, NDIM >::size(), T(), TENSOR_RESULT_TYPE, and madness::Mutex::unlock().

◆ do_mul()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::do_mul	(	const keyT &	key,
		const Tensor< L > &	left,
		const std::pair< keyT, Tensor< R > > &	arg
	)

inline

Functor for the mul method.

References madness::arg(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::FunctionImpl< T, NDIM >::fcube_for_mul(), L, madness::Key< NDIM >::level(), NDIM, pow(), R, madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::Tensor< T >::scale(), madness::scale(), T(), madness::FunctionImpl< T, NDIM >::targs, TERNARY_OPTIMIZED_ITERATOR, and madness::transform().

◆ do_print_grid()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_print_grid	(	const std::string	filename,
		const std::vector< keyT > &	keys
	)		const

print the grid in xyz format

the quadrature points and the key information will be written to file,

Parameters

[in]	filename	where the quadrature points will be written to
[in]	keys	all leaf keys

References c, d, madness::BaseTensor::dim(), madness::filename, madness::FunctionDefaults< NDIM >::get_cell(), madness::FunctionDefaults< NDIM >::get_cell_width(), h(), k, madness::Key< NDIM >::level(), MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, and madness::Key< NDIM >::translation().

◆ do_print_plane()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_print_plane	(	const std::string	filename,
		std::vector< Tensor< double > >	plotinfo,
		const int	xaxis,
		const int	yaxis,
		const coordT	el2
	)

print the MRA structure

Functor for the print_plane method

Parameters

[in]	filename	the filename for the output
[in]	plotinfo	plotting parameters
[in]	xaxis	the x-axis in the plot (can be any axis of the MRA box)
[in]	yaxis	the y-axis in the plot (can be any axis of the MRA box)

References madness::BaseTensor::dim(), madness::filename, madness::FunctionDefaults< NDIM >::get_cell(), madness::Tensor< T >::has_data(), and MADNESS_ASSERT.

◆ do_print_tree()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_print_tree	(	const keyT &	key,
		std::ostream &	os,
		Level	maxlevel
	)		const

Functor for the do_print_tree method.

References madness::FunctionNode< T, NDIM >::has_children(), and madness::Key< NDIM >::level().

◆ do_print_tree_graphviz()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_print_tree_graphviz	(	const keyT &	key,
		std::ostream &	os,
		Level	maxlevel
	)		const

Functor for the do_print_tree method (using GraphViz)

References madness::FunctionNode< T, NDIM >::has_children(), madness::Key< NDIM >::level(), NDIM, and madness::Key< NDIM >::translation().

◆ do_print_tree_json()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_print_tree_json	(	const keyT &	key,
		std::multimap< Level, std::tuple< tranT, std::string > > &	data,
		Level	maxlevel
	)		const

Functor for the do_print_tree_json method.

References madness::FunctionNode< T, NDIM >::has_children(), madness::Key< NDIM >::level(), MADNESS_EXCEPTION, madness::FunctionNode< T, NDIM >::print_json(), and madness::Key< NDIM >::translation().

◆ do_project_out()

template<typename T , std::size_t NDIM>

template<size_t LDIM>

void madness::FunctionImpl< T, NDIM >::do_project_out	(	const coeffT &	fcoeff,
		const std::pair< keyT, coeffT >	gpair,
		const keyT &	gkey,
		const Key< NDIM > &	dest,
		const int	dim
	)		const

inline

compute the inner product of two nodes of only some dimensions and accumulate on result

invoked by result

Parameters

[in]	fcoeff	coefficients of high dimension LDIM+NDIM
[in]	gpair	key and coeffs of low dimension LDIM (possibly a parent node)
[in]	gkey	key of actual low dim node (possibly the same as gpair.first, iff gnode exists)
[in]	dest	destination node for the result
[in]	dim	which dimensions should be contracted: 0..LDIM-1 or LDIM..NDIM+LDIM-1

References madness::_(), madness::FunctionNode< T, NDIM >::accumulate2(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::GenTensor< T >::config(), madness::GenTensor< T >::dim(), madness::GenTensor< T >::full_tensor(), madness::GenTensor< T >::has_no_data(), madness::TaskAttributes::hipri(), madness::FunctionImpl< T, NDIM >::k, MADNESS_ASSERT, madness::FunctionImpl< T, NDIM >::parent_to_child(), madness::GenTensor< T >::rank(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::GenTensor< T >::tensor_type(), madness::TT_2D, and madness::TT_FULL.

◆ do_square_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_square_inplace ( const keyT & key )

◆ do_square_inplace2()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::do_square_inplace2	(	const keyT &	parent,
		const keyT &	child,
		const tensorT &	parent_coeff
	)

◆ dot_local()

template<typename T , std::size_t NDIM>

template<typename R >

static Tensor< TENSOR_RESULT_TYPE(T, R)> madness::FunctionImpl< T, NDIM >::dot_local	(	const std::vector< const FunctionImpl< T, NDIM > * > &	left,
		const std::vector< const FunctionImpl< R, NDIM > * > &	right,
		bool	sym
	)

inlinestatic

References madness::FunctionImpl< T, NDIM >::conj(), madness::BaseTensor::dim(), madness::FunctionImpl< T, NDIM >::make_key_vec_map(), R, sum, T(), and TENSOR_RESULT_TYPE.

Referenced by madness::matrix_dot().

◆ downsample()

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::tensorT madness::FunctionImpl< T, NDIM >::downsample	(	const keyT &	key,
		const std::vector< Future< coeffT > > &	v
	)		const

downsample the sum coefficients of level n+1 to sum coeffs on level n

specialization of the filter method, will yield only the sum coefficients

Parameters

[in]	key	key of level n
[in]	v	vector of sum coefficients of level n+1

Returns: sum coefficients on level n in full tensor format

specialization of the filter method, will yield only the sum coefficients

Parameters

[in]	key	key of level n
[in]	v	vector of sum coefficients of level n+1
[in]	args	TensorArguments for possible low rank approximations

Returns: sum coefficients on level n in full tensor format

References madness::general_transform(), h(), NDIM, and v.

◆ erase()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::erase ( const Level & max_level )

truncate tree at a certain level

Parameters

[in] max_level truncate tree below this level

References madness::Key< NDIM >::level(), madness::make_redundant(), and madness::FunctionNode< T, NDIM >::set_has_children().

◆ err_box()

template<typename T , std::size_t NDIM>

template<typename opT >

double madness::FunctionImpl< T, NDIM >::err_box	(	const keyT &	key,
		const nodeT &	node,
		const opT &	func,
		int	npt,
		const Tensor< double > &	qx,
		const Tensor< double > &	quad_phit,
		const Tensor< double > &	quad_phiw
	)		const

inline

Returns the square of the error norm in the box labeled by key.

Assumed to be invoked locally but it would be easy to eliminate this assumption

References madness::FunctionNode< T, NDIM >::coeff(), madness::fast_transform(), madness::FunctionImpl< T, NDIM >::fcube(), madness::GenTensor< T >::full_tensor_copy(), madness::func(), IND, ITERATOR, madness::Key< NDIM >::level(), NDIM, pow(), and madness::scale().

Referenced by madness::FunctionImpl< T, NDIM >::do_err_box< opT >::operator()().

◆ errsq_local()

template<typename T , std::size_t NDIM>

template<typename opT >

double madness::FunctionImpl< T, NDIM >::errsq_local ( const opT & func ) const

inline

Returns the sum of squares of errors from local info ... no comms.

References madness::FunctionCommonData< T, NDIM >::_init_quadrature(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::func(), madness::FunctionImpl< T, NDIM >::k, PROFILE_MEMBER_FUNC, madness::FunctionImpl< T, NDIM >::range(), madness::WorldTaskQueue::reduce(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ eval()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::eval	(	const Vector< double, NDIM > &	xin,
		const keyT &	keyin,
		const typename Future< T >::remote_refT &	ref
	)

Evaluate the function at a point in simulation coordinates.

Only the invoking process will get the result via the remote reference to a future. Active messages may be sent to other nodes.

References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::full_tensor_copy(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::TaskAttributes::hipri(), madness::Key< NDIM >::level(), me, NDIM, PROFILE_MEMBER_FUNC, madness::Future< T >::set(), madness::Key< NDIM >::translation(), and xi.

◆ eval_cube()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::eval_cube	(	Level	n,
		coordT &	x,
		const tensorT &	c
	)		const

References c, k, madness::legendre_scaling_functions(), MADNESS_EXCEPTION, NDIM, p(), pow(), PROFILE_MEMBER_FUNC, q(), sum, T(), and u().

◆ eval_local_only()

template<typename T , std::size_t NDIM>

std::pair< bool, T > madness::FunctionImpl< T, NDIM >::eval_local_only	(	const Vector< double, NDIM > &	xin,
		Level	maxlevel
	)

Evaluate function only if point is local returning (true,value); otherwise return (false,0.0)

maxlevel is the maximum depth to search down to — the max local depth can be computed with max_local_depth();

References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::full_tensor_copy(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::Key< NDIM >::level(), me, NDIM, madness::Key< NDIM >::translation(), and xi.

◆ eval_plot_cube()

template<typename T , std::size_t NDIM>

Tensor< T > madness::FunctionImpl< T, NDIM >::eval_plot_cube	(	const coordT &	plotlo,
		const coordT &	plothi,
		const std::vector< long > &	npt,
		const bool	eval_refine = `false`
	)		const

Evaluate a cube/slice of points ... plotlo and plothi are already in simulation coordinates No communications

Parameters

[in]	plotlo	the coordinate of the starting point
[in]	plothi	the coordinate of the ending point
[in]	npt	the number of points in each dimension

Set plot_refine=true to get a plot of the refinment levels of the given function (defaulted to false in prototype).

References madness::FunctionNode< T, NDIM >::has_coeff(), MADNESS_ASSERT, NDIM, PROFILE_MEMBER_FUNC, madness::Tensor< T >::ptr(), and madness::BaseTensor::size().

◆ evaldepthpt()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::evaldepthpt	(	const Vector< double, NDIM > &	xin,
		const keyT &	keyin,
		const typename Future< Level >::remote_refT &	ref
	)

Get the depth of the tree at a point in simulation coordinates.

Only the invoking process will get the result via the remote reference to a future. Active messages may be sent to other nodes.

This function is a minimally-modified version of eval()

References madness::FunctionNode< T, NDIM >::has_coeff(), madness::TaskAttributes::hipri(), madness::Key< NDIM >::level(), me, NDIM, PROFILE_MEMBER_FUNC, madness::Future< T >::set(), madness::Key< NDIM >::translation(), and xi.

◆ evalR()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::evalR	(	const Vector< double, NDIM > &	xin,
		const keyT &	keyin,
		const typename Future< long >::remote_refT &	ref
	)

Get the rank of leaf box of the tree at a point in simulation coordinates.

Only the invoking process will get the result via the remote reference to a future. Active messages may be sent to other nodes.

This function is a minimally-modified version of eval()

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::TaskAttributes::hipri(), madness::Key< NDIM >::level(), me, NDIM, PROFILE_MEMBER_FUNC, madness::GenTensor< T >::rank(), madness::Future< T >::set(), madness::Key< NDIM >::translation(), and xi.

◆ exists_and_has_children()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::exists_and_has_children ( const keyT & key ) const

◆ exists_and_is_leaf()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::exists_and_is_leaf ( const keyT & key ) const

◆ fcube() [1/2]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::fcube	(	const keyT &	key,
		const FunctionFunctorInterface< T, NDIM > &	f,
		const Tensor< double > &	qx,
		tensorT &	fval
	)		const

Evaluate function at quadrature points in the specified box.

Parameters

[in]	key	the key indicating where the quadrature points are located
[in]	f	the interface to the elementary function
[in]	qx	quadrature points on a level=0 box
[out]	fval	values

References madness::f, and madness::fcube().

Referenced by madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::eri_coeffs(), madness::FunctionImpl< T, NDIM >::err_box(), and madness::FunctionImpl< T, NDIM >::inner_ext_node().

◆ fcube() [2/2]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::fcube	(	const keyT &	key,
		T(*)(const coordT &)	f,
		const Tensor< double > &	qx,
		tensorT &	fval
	)		const

Evaluate function at quadrature points in the specified box.

Parameters

[in]	key	the key indicating where the quadrature points are located
[in]	f	the interface to the elementary function
[in]	qx	quadrature points on a level=0 box
[out]	fval	values

References madness::f, and madness::fcube().

◆ fcube_for_mul() [1/2]

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::fcube_for_mul	(	const keyT &	child,
		const keyT &	parent,
		const GenTensor< Q > &	coeff
	)		const

inline

Compute the function values for multiplication.

Given coefficients from a parent cell, compute the value of the functions at the quadrature points of a child

Parameters

[in]	child	the key for the child function node (box)
[in]	parent	the key for the parent function node (box)
[in]	coeff	the coefficients of scaling function basis of the parent box

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs2values(), d, madness::general_transform(), madness::Key< NDIM >::level(), MADNESS_EXCEPTION, NDIM, madness::FunctionImpl< T, NDIM >::phi_for_mul(), and madness::Key< NDIM >::translation().

◆ fcube_for_mul() [2/2]

template<typename T , std::size_t NDIM>

template<typename Q >

Tensor< Q > madness::FunctionImpl< T, NDIM >::fcube_for_mul	(	const keyT &	child,
		const keyT &	parent,
		const Tensor< Q > &	coeff
	)		const

inline

Compute the function values for multiplication.

Given coefficients from a parent cell, compute the value of the functions at the quadrature points of a child

Parameters

[in]	child	the key for the child function node (box)
[in]	parent	the key for the parent function node (box)
[in]	coeff	the coefficients of scaling function basis of the parent box

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs2values(), d, madness::general_transform(), madness::Key< NDIM >::level(), MADNESS_EXCEPTION, NDIM, madness::FunctionImpl< T, NDIM >::phi_for_mul(), and madness::Key< NDIM >::translation().

Referenced by madness::FunctionImpl< T, NDIM >::do_binary_op(), madness::FunctionImpl< T, NDIM >::do_mul(), and madness::FunctionImpl< T, NDIM >::do_unary_op_value_inplace< opT >::operator()().

◆ filter() [1/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::filter ( const coeffT & s ) const

References madness::transform().

◆ filter() [2/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::tensorT madness::FunctionImpl< T, NDIM >::filter ( const tensorT & s ) const

Transform sum coefficients at level n to sums+differences at level n-1.

Given scaling function coefficients s[n][l][i] and s[n][l+1][i] return the scaling function and wavelet coefficients at the coarser level. I.e., decompose Vn using Vn = Vn-1 + Wn-1.

    s_i = sum(j) h0_ij*s0_j + h1_ij*s1_j
    d_i = sum(j) g0_ij*s0_j + g1_ij*s1_j
//  

Returns a new tensor and has no side effects. Works for any number of dimensions.

No communication involved.

References madness::fast_transform(), and w().

Referenced by madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive().

◆ finalize_apply()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::finalize_apply ( )

after apply we need to do some cleanup;

forces fence

References madness::nonstandard_after_apply, madness::print_timings, madness::TensorArgs::thresh, and madness::wall_time().

◆ finalize_sum()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::finalize_sum ( )

after summing up we need to do some cleanup;

forces fence

References madness::reconstructed.

◆ find_datum()

template<typename T , std::size_t NDIM>

std::pair< Key< NDIM >, ShallowNode< T, NDIM > > madness::FunctionImpl< T, NDIM >::find_datum ( keyT key ) const

return the a std::pair<key, node>, which MUST exist

References MADNESS_ASSERT.

Referenced by madness::CoeffTracker< T, NDIM >::activate().

◆ find_me()

template<typename T , std::size_t NDIM>

Future< std::pair< Key< NDIM >, GenTensor< T > > > madness::FunctionImpl< T, NDIM >::find_me ( const keyT & key ) const

find_me. Called by diff_bdry to get coefficients of boundary function

References madness::TaskAttributes::hipri(), and madness::Future< T >::remote_ref().

◆ flo_unary_op_node_inplace() [1/2]

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace	(	const opT &	op,
		bool	fence
	)

inline

Unary operation applied inplace to the coefficients WITHOUT refinement, optional fence

Parameters

[in] op the unary operator for the coefficients

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::WorldTaskQueue::for_each(), madness::World::gop, op(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

Referenced by madness::FunctionImpl< T, NDIM >::accumulate_trees(), madness::FunctionImpl< T, NDIM >::average(), madness::FunctionImpl< T, NDIM >::make_Vphi(), and madness::FunctionImpl< T, NDIM >::merge_trees().

◆ flo_unary_op_node_inplace() [2/2]

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace	(	const opT &	op,
		bool	fence
	)		const

inline

Unary operation applied inplace to the coefficients WITHOUT refinement, optional fence

Parameters

[in] op the unary operator for the coefficients

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::WorldTaskQueue::for_each(), madness::World::gop, op(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ forward_do_diff1()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::forward_do_diff1	(	const DerivativeBase< T, NDIM > *	D,
		const implT *	f,
		const keyT &	key,
		const std::pair< keyT, coeffT > &	left,
		const std::pair< keyT, coeffT > &	center,
		const std::pair< keyT, coeffT > &	right
	)

References madness::f.

◆ forward_traverse()

template<typename T , std::size_t NDIM>

template<typename coeff_opT , typename apply_opT >

void madness::FunctionImpl< T, NDIM >::forward_traverse	(	const coeff_opT &	coeff_op,
		const apply_opT &	apply_op,
		const keyT &	key
	)		const

inline

traverse a non-existing tree

part II: activate coeff_op, i.e. retrieve all the necessary remote boxes (communication)

Parameters

[in]	coeff_op	operator making the coefficients that needs activation
[in]	apply_op	just passing thru
[in]	key	the key we are working on

References madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), MADNESS_ASSERT, madness::World::rank(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ gaxpy()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::gaxpy	(	T	alpha,
		const FunctionImpl< L, NDIM > &	left,
		T	beta,
		const FunctionImpl< R, NDIM > &	right,
		bool	fence
	)

inline

Invoked by result to perform result += alpha*left+beta*right in wavelet basis.

Does not assume that any of result, left, right have the same distribution. For most purposes result will start as an empty so actually are implementing out of place gaxpy. If all functions have the same distribution there is no communication except for the optional fence.

References alpha, madness::WorldContainer< keyT, valueT, hashfunT >::begin(), beta, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::World::gop, madness::WorldContainer< keyT, valueT, hashfunT >::send(), and madness::FunctionImpl< T, NDIM >::world.

◆ gaxpy_ext()

template<typename T , std::size_t NDIM>

template<typename L >

void madness::FunctionImpl< T, NDIM >::gaxpy_ext	(	const FunctionImpl< L, NDIM > *	left,
		T(*)(const coordT &)	f,
		T	alpha,
		T	beta,
		double	tol,
		bool	fence
	)

inline

References alpha, beta, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::f, madness::WorldGopInterface::fence(), madness::World::gop, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), and madness::FunctionImpl< T, NDIM >::world.

◆ gaxpy_ext_node()

template<typename T , std::size_t NDIM>

template<typename L >

tensorT madness::FunctionImpl< T, NDIM >::gaxpy_ext_node	(	keyT	key,
		Tensor< L >	lc,
		T(*)(const coordT &)	f,
		T	alpha,
		T	beta
	)		const

inline

Return the gaxpy product with an external function on a specified function node.

Parameters

[in]	key	Key of the function node on which to compute gaxpy
[in]	lc	Tensor of coefficients for the function at the function node given by key
[in]	f	Pointer to function of type T that takes coordT arguments. This is the externally provided function and the right argument of gaxpy.
[in]	alpha	prefactor of c Tensor for gaxpy
[in]	beta	prefactor of fcoeffs for gaxpy

Returns: Returns coefficient tensor of the gaxpy product at specified key, no guarantee of accuracy.

References alpha, beta, madness::FunctionImpl< T, NDIM >::cdata, madness::copy(), madness::f, madness::fcube(), madness::Tensor< T >::gaxpy(), and madness::FunctionImpl< T, NDIM >::values2coeffs().

Referenced by madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive().

◆ gaxpy_ext_recursive()

template<typename T , std::size_t NDIM>

template<typename L >

void madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive	(	const keyT &	key,
		const FunctionImpl< L, NDIM > *	left,
		Tensor< L >	lcin,
		tensorT	c,
		T(*)(const coordT &)	f,
		T	alpha,
		T	beta,
		double	tol,
		bool	below_leaf
	)

inline

Return out of place gaxpy using recursive descent.

Parameters

[in]	key	Key of the function node on which to compute gaxpy
[in]	left	FunctionImpl, left argument of gaxpy
[in]	lcin	coefficients of left at this node
[in]	c	coefficients of gaxpy product at this node
[in]	f	pointer to function of type T that takes coordT arguments. This is the externally provided function and the right argument of gaxpy.
[in]	alpha	prefactor of left argument for gaxpy
[in]	beta	prefactor of right argument for gaxpy
[in]	tol	convergence tolerance...when the norm of the gaxpy's difference coefficients is less than tol, we are done.

References alpha, beta, c, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), d, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::f, madness::FunctionImpl< T, NDIM >::filter(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_node(), L, MADNESS_ASSERT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::BaseTensor::size(), T(), madness::FunctionImpl< T, NDIM >::targs, madness::WorldObject< FunctionImpl< T, NDIM > >::task(), madness::FunctionImpl< T, NDIM >::truncate_tol(), and madness::FunctionImpl< T, NDIM >::unfilter().

◆ gaxpy_inplace()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::gaxpy_inplace	(	const T &	alpha,
		const FunctionImpl< Q, NDIM > &	other,
		const R &	beta,
		bool	fence
	)

inline

Inplace general bilinear operation

Parameters

[in]	alpha	prefactor for the current function impl
[in]	other	the other function impl
[in]	beta	prefactor for other

References alpha, madness::WorldContainer< keyT, valueT, hashfunT >::begin(), beta, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::scale_inplace(), T(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ gaxpy_inplace_reconstructed()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::gaxpy_inplace_reconstructed	(	const T &	alpha,
		const FunctionImpl< Q, NDIM > &	g,
		const R &	beta,
		const bool	fence
	)

inline

perform inplace gaxpy: this = alpha*this + beta*other

Parameters

[in]	alpha	prefactor for this
[in]	beta	prefactor for other
[in]	g	the other function, reconstructed

References alpha, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::g, madness::World::gop, madness::FunctionImpl< T, NDIM >::merge_trees(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::FunctionImpl< T, NDIM >::sum_down_spawn(), and madness::FunctionImpl< T, NDIM >::world.

◆ gaxpy_oop_reconstructed()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::gaxpy_oop_reconstructed	(	const double	alpha,
		const implT &	f,
		const double	beta,
		const implT &	g,
		const bool	fence
	)

perform: this= alpha*f + beta*g, invoked by result

f and g are reconstructed, so we can save on the compress operation, walk down the joint tree, and add leaf coefficients; effectively refines to common finest level. nothing returned, but leaves this's tree reconstructed and as sum of f and g

Parameters

[in]	alpha	prefactor for f
[in]	f	first addend
[in]	beta	prefactor for g
[in]	g	second addend

f and g are reconstructed, so we can save on the compress operation, walk down the joint tree, and add leaf coefficients; effectively refines to common finest level.

Parameters

[in]	alpha	prefactor for f
[in]	f	first addend
[in]	beta	prefactor for g
[in]	g	second addend

Returns: nothing, but leaves this's tree reconstructed and as sum of f and g

References alpha, beta, madness::f, madness::g, MADNESS_ASSERT, and madness::reconstructed.

◆ get_autorefine()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::get_autorefine ( ) const

◆ get_cdata()

template<typename T , std::size_t NDIM>

const FunctionCommonData< T, NDIM > & madness::FunctionImpl< T, NDIM >::get_cdata ( ) const

Referenced by madness::CoeffTracker< T, NDIM >::CoeffTracker(), madness::FunctionImpl< T, NDIM >::get_contraction_node_lists(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), and madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map().

◆ get_coeffs() [1/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::dcT & madness::FunctionImpl< T, NDIM >::get_coeffs ( )

◆ get_coeffs() [2/2]

template<typename T , std::size_t NDIM>

const FunctionImpl< T, NDIM >::dcT & madness::FunctionImpl< T, NDIM >::get_coeffs ( ) const

◆ get_contraction_node_lists()

template<typename T , std::size_t NDIM>

template<std::size_t CDIM>

std::tuple< std::set< Key< NDIM > >, std::map< Key< CDIM >, double > > madness::FunctionImpl< T, NDIM >::get_contraction_node_lists	(	const std::size_t	n,
		const std::array< int, CDIM > &	v
	)		const

inline

for contraction two functions f(x,z) = \int g(x,y) h(y,z) dy

find all nodes with d coefficients and return a list of complete keys and of keys holding only the y dimension, also the maximum norm of all d for the j dimension

Parameters

[in]	n	the scale
[in]	v	array holding the indices of the integration variable

Returns: ijlist: list of all nodes with d coeffs; jlist: j-part of ij list only

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionNode< T, NDIM >::coeff(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::FunctionImpl< T, NDIM >::get_cdata(), madness::FunctionImpl< T, NDIM >::get_coeffs(), madness::FunctionNode< T, NDIM >::get_dnorm(), madness::Key< NDIM >::level(), madness::Key< NDIM >::parent(), madness::Key< NDIM >::translation(), and v.

Referenced by madness::FunctionImpl< T, NDIM >::partial_inner().

◆ get_functor() [1/2]

template<typename T , std::size_t NDIM>

std::shared_ptr< FunctionFunctorInterface< T, NDIM > > madness::FunctionImpl< T, NDIM >::get_functor ( )

References MADNESS_ASSERT.

Referenced by madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::eri_coeffs(), and madness::FunctionImpl< T, NDIM >::make_Vphi().

◆ get_functor() [2/2]

template<typename T , std::size_t NDIM>

std::shared_ptr< FunctionFunctorInterface< T, NDIM > > madness::FunctionImpl< T, NDIM >::get_functor ( ) const

References MADNESS_ASSERT.

◆ get_initial_level()

template<typename T , std::size_t NDIM>

int madness::FunctionImpl< T, NDIM >::get_initial_level ( ) const

inline

getter

References madness::FunctionImpl< T, NDIM >::initial_level.

Referenced by madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::operator()().

◆ get_k()

template<typename T , std::size_t NDIM>

int madness::FunctionImpl< T, NDIM >::get_k ( ) const

References k.

Referenced by madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::do_standard::operator()().

◆ get_norm_tree_recursive()

template<typename T , std::size_t NDIM>

Future< double > madness::FunctionImpl< T, NDIM >::get_norm_tree_recursive ( const keyT & key ) const

References madness::TaskAttributes::hipri(), madness::Key< NDIM >::level(), MADNESS_ASSERT, and madness::Key< NDIM >::parent().

◆ get_pmap()

template<typename T , std::size_t NDIM>

const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > & madness::FunctionImpl< T, NDIM >::get_pmap ( ) const

Referenced by madness::FunctionImpl< T, NDIM >::merge_trees().

◆ get_special_level()

template<typename T , std::size_t NDIM>

int madness::FunctionImpl< T, NDIM >::get_special_level ( ) const

inline

References madness::FunctionImpl< T, NDIM >::special_level.

Referenced by madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::operator()(), and madness::NuclearCuspyBox_op< T, NDIM >::operator()().

◆ get_special_points()

template<typename T , std::size_t NDIM>

const std::vector< Vector< double, NDIM > > & madness::FunctionImpl< T, NDIM >::get_special_points ( ) const

inline

References madness::FunctionImpl< T, NDIM >::special_points.

◆ get_tensor_args()

template<typename T , std::size_t NDIM>

TensorArgs madness::FunctionImpl< T, NDIM >::get_tensor_args ( ) const

◆ get_tensor_type()

template<typename T , std::size_t NDIM>

TensorType madness::FunctionImpl< T, NDIM >::get_tensor_type ( ) const

Referenced by madness::Derivative< T, NDIM >::do_diff2b(), madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::partial_inner_contract().

◆ get_thresh()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::get_thresh ( ) const

References thresh.

Referenced by madness::Leaf_op< T, NDIM, opT, specialboxT >::compare_to_parent(), madness::Derivative< T, NDIM >::do_diff2b(), madness::Derivative< T, NDIM >::do_diff2i(), madness::FunctionImpl< T, NDIM >::recursive_apply_op< opT, LDIM >::finalize(), madness::FunctionImpl< T, NDIM >::recursive_apply_op2< opT >::finalize(), madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::operator()(), madness::op_leaf_op< T, NDIM, opT >::operator()(), refop::operator()(), refop::operator()(), madness::FunctionImpl< T, NDIM >::do_truncate_NS_leafs::operator()(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), madness::Leaf_op< T, NDIM, opT, specialboxT >::post_screening(), and madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::screen().

◆ get_tree_state()

template<typename T , std::size_t NDIM>

TreeState madness::FunctionImpl< T, NDIM >::get_tree_state ( ) const

inline

References madness::FunctionImpl< T, NDIM >::tree_state.

◆ hartree_product()

template<typename T , std::size_t NDIM>

template<std::size_t LDIM, typename leaf_opT >

void madness::FunctionImpl< T, NDIM >::hartree_product	(	const std::vector< std::shared_ptr< FunctionImpl< T, LDIM > > >	p1,
		const std::vector< std::shared_ptr< FunctionImpl< T, LDIM > > >	p2,
		const leaf_opT &	leaf_op,
		bool	fence
	)

inline

given two functions of LDIM, perform the Hartree/Kronecker/outer product

|Phi(1,2)> = |phi(1)> x |phi(2)>

Parameters

[in]	p1	FunctionImpl of particle 1
[in]	p2	FunctionImpl of particle 2
[in]	leaf_op	operator determining of a given box will be a leaf

References madness::FunctionImpl< T, NDIM >::cdata, madness::WorldGopInterface::fence(), madness::FunctionImpl< T, NDIM >::get_coeffs(), madness::World::gop, madness::FunctionImpl< T, NDIM >::key0(), MADNESS_CHECK, MADNESS_CHECK_THROW, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), madness::World::rank(), madness::redundant_after_merge, madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ has_leaves()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::has_leaves ( ) const

References madness::nonstandard_with_leaves.

◆ inner_adaptive_local()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::inner_adaptive_local	(	const std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	f,
		const bool	leaf_refine
	)		const

inline

Return the local part of inner product with external function ... no communication.

Parameters

[in]	f	Reference to FunctionFunctorInterface. This is the externally provided function
[in]	leaf_refine	boolean switch to turn on/off refinement past leaf nodes

Returns: Returns local part of the inner product, i.e. over the domain of all function nodes on this compute node.

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::f, madness::WorldTaskQueue::reduce(), T(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ inner_adaptive_recursive()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive	(	keyT	key,
		const tensorT &	c,
		const std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	f,
		const bool	leaf_refine,
		T	old_inner = `T(0)`
	)		const

inline

Call inner_ext_node recursively until convergence.

Parameters

[in]	key	Key of the function node on which to compute inner product (the domain of integration)
[in]	c	coeffs for the function at the node given by key
[in]	f	Reference to FunctionFunctorInterface. This is the externally provided function
[in]	leaf_refine	boolean switch to turn on/off refinement past leaf nodes
[in]	old_inner	the inner product on the parent function node

Returns: Returns the inner product over the domain of a single function, checks for convergence.

References std::abs(), c, cc, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::copy(), d, madness::f, madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), madness::FunctionImpl< T, NDIM >::inner_ext_node(), T(), madness::FunctionImpl< T, NDIM >::thresh, madness::FunctionImpl< T, NDIM >::truncate_tol(), and madness::FunctionImpl< T, NDIM >::unfilter().

Referenced by madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), and madness::FunctionImpl< T, NDIM >::do_inner_ext_local_ffi::operator()().

◆ inner_ext_local()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::inner_ext_local	(	const std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	f,
		const bool	leaf_refine
	)		const

inline

Return the local part of inner product with external function ... no communication.

Parameters

[in]	f	Reference to FunctionFunctorInterface. This is the externally provided function
[in]	leaf_refine	boolean switch to turn on/off refinement past leaf nodes

Returns: Returns local part of the inner product, i.e. over the domain of all function nodes on this compute node.

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::f, madness::WorldTaskQueue::reduce(), T(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ inner_ext_node()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::inner_ext_node	(	keyT	key,
		tensorT	c,
		const std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	f
	)		const

inline

Return the inner product with an external function on a specified function node.

Parameters

[in]	key	Key of the function node to compute the inner product on. (the domain of integration)
[in]	c	Tensor of coefficients for the function at the function node given by key
[in]	f	Reference to FunctionFunctorInterface. This is the externally provided function

Returns: Returns the inner product over the domain of a single function node, no guarantee of accuracy.

References c, madness::FunctionImpl< T, NDIM >::cdata, madness::f, madness::FunctionImpl< T, NDIM >::fcube(), madness::FunctionImpl< T, NDIM >::values2coeffs(), and madness::FunctionCommonData< T, NDIM >::vk.

Referenced by madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), and madness::FunctionImpl< T, NDIM >::inner_ext_recursive().

◆ inner_ext_recursive()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::inner_ext_recursive	(	keyT	key,
		tensorT	c,
		const std::shared_ptr< FunctionFunctorInterface< T, NDIM > >	f,
		const bool	leaf_refine,
		T	old_inner = `T(0)`
	)		const

inline

Call inner_ext_node recursively until convergence.

Parameters

[in]	key	Key of the function node on which to compute inner product (the domain of integration)
[in]	c	coeffs for the function at the node given by key
[in]	f	Reference to FunctionFunctorInterface. This is the externally provided function
[in]	leaf_refine	boolean switch to turn on/off refinement past leaf nodes
[in]	old_inner	the inner product on the parent function node

Returns: Returns the inner product over the domain of a single function, checks for convergence.

References std::abs(), c, cc, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), d, madness::f, madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::FunctionImpl< T, NDIM >::inner_ext_node(), madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), NDIM, pow(), madness::Tensor< T >::sum(), T(), madness::FunctionImpl< T, NDIM >::thresh, and madness::FunctionImpl< T, NDIM >::unfilter().

Referenced by madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), and madness::FunctionImpl< T, NDIM >::do_inner_ext_local_ffi::operator()().

◆ inner_local()

template<typename T , std::size_t NDIM>

template<typename R >

static Tensor< TENSOR_RESULT_TYPE(T, R) > madness::FunctionImpl< T, NDIM >::inner_local	(	const std::vector< const FunctionImpl< T, NDIM > * > &	left,
		const std::vector< const FunctionImpl< R, NDIM > * > &	right,
		bool	sym
	)

inlinestatic

References madness::FunctionImpl< T, NDIM >::conj(), madness::BaseTensor::dim(), madness::FunctionImpl< T, NDIM >::make_key_vec_map(), R, sum, T(), and TENSOR_RESULT_TYPE.

Referenced by madness::matrix_inner().

◆ insert_zero_down_to_initial_level()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::insert_zero_down_to_initial_level ( const keyT & key )

Initialize nodes to zero function at initial_level of refinement.

Works for either basis. No communication.

References madness::Key< NDIM >::level(), and PROFILE_MEMBER_FUNC.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), and madness::FunctionImpl< T, NDIM >::FunctionImpl().

◆ is_compressed()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_compressed ( ) const

Returns true if the function is compressed.

References madness::compressed.

Referenced by madness::CoeffTracker< T, NDIM >::coeff().

◆ is_nonstandard()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_nonstandard ( ) const

References madness::nonstandard.

Referenced by madness::CoeffTracker< T, NDIM >::coeff().

◆ is_nonstandard_with_leaves()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_nonstandard_with_leaves ( ) const

References madness::nonstandard_with_leaves.

Referenced by madness::CoeffTracker< T, NDIM >::coeff().

◆ is_on_demand()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_on_demand ( ) const

References madness::on_demand.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::Vphi_op_NS(), madness::CoeffTracker< T, NDIM >::activate(), madness::CoeffTracker< T, NDIM >::make_child(), and madness::Function< T, NDIM >::mul_on_demand().

◆ is_reconstructed()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_reconstructed ( ) const

Returns true if the function is compressed.

Returns true if the function is reconstructed.

References madness::reconstructed.

◆ is_redundant()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::is_redundant ( ) const

Returns true if the function is redundant.

References madness::redundant.

◆ key0()

template<typename T , std::size_t NDIM>

const FunctionImpl< T, NDIM >::keyT & madness::FunctionImpl< T, NDIM >::key0 ( ) const

Returns cdata.key0.

Referenced by madness::FunctionImpl< T, NDIM >::hartree_product(), madness::FunctionImpl< T, NDIM >::multiply(), madness::FunctionImpl< T, NDIM >::partial_inner(), madness::FunctionImpl< T, NDIM >::project_out(), madness::FunctionImpl< T, NDIM >::recursive_apply(), and madness::FunctionImpl< T, NDIM >::recursive_apply().

◆ load()

template<typename T , std::size_t NDIM>

template<typename Archive >

void madness::FunctionImpl< T, NDIM >::load ( Archive & ar )

inline

◆ local_leaf_keys()

template<typename T , std::size_t NDIM>

std::vector< typename FunctionImpl< T, NDIM >::keyT > madness::FunctionImpl< T, NDIM >::local_leaf_keys ( ) const

return the keys of the local leaf boxes

References madness::FunctionNode< T, NDIM >::is_leaf().

◆ MADNESS_ASSERT()

template<typename T , std::size_t NDIM>

madness::FunctionImpl< T, NDIM >::MADNESS_ASSERT ( this-> is_redundant() = =g.is_redundant() )

◆ MADNESS_CHECK()

template<typename T , std::size_t NDIM>

madness::FunctionImpl< T, NDIM >::MADNESS_CHECK ( this-> is_reconstructed() )

◆ make_key_vec_map()

template<typename T , std::size_t NDIM>

static mapT madness::FunctionImpl< T, NDIM >::make_key_vec_map ( const std::vector< const FunctionImpl< T, NDIM > * > & v )

inlinestatic

Returns map of union of local keys to vector of indexes of functions containing that key.

Local concurrency and synchronization only; no communication

References v.

Referenced by madness::FunctionImpl< T, NDIM >::dot_local(), and madness::FunctionImpl< T, NDIM >::inner_local().

◆ make_redundant()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::make_redundant ( const bool fence )

private

convert this to redundant, i.e. have sum coefficients on all levels

References madness::compress(), MADNESS_CHECK_THROW, and madness::redundant.

◆ make_redundant_op()

template<typename T , std::size_t NDIM>

std::pair< typename FunctionImpl< T, NDIM >::coeffT, double > madness::FunctionImpl< T, NDIM >::make_redundant_op	(	const keyT &	key,
		const std::vector< Future< std::pair< coeffT, double > > > &	v
	)

similar to compress_op, but insert only the sum coefficients in the tree

also compute the norm tree for all nodes

Parameters

[in]	key	this's key
[in]	v	sum coefficients of the child nodes

Returns: the sum coefficients

also sets snorm, dnorm and norm_tree for all nodes

Parameters

[in]	key	this's key
[in]	v	sum coefficients of the child nodes

Returns: the sum coefficients

References madness::copy(), d, MADNESS_CHECK, madness::norm_tree(), madness::TensorArgs::thresh, and v.

◆ make_Vphi()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::make_Vphi	(	const opT &	leaf_op,
		const bool	fence = `true`
	)

inline

assemble the function V*phi using V and phi given from the functor

this function must have been constructed using the CompositeFunctorInterface. The interface provides one- and two-electron potentials, and the ket, which are assembled to give V*phi.

Parameters

[in]	leaf_op	operator to decide if a given node is a leaf node
[in]	fence	global fence

◆ make_Vphi_only()

template<typename T , std::size_t NDIM>

template<typename opT , std::size_t LDIM>

void madness::FunctionImpl< T, NDIM >::make_Vphi_only	(	const opT &	leaf_op,
		FunctionImpl< T, NDIM > *	ket,
		FunctionImpl< T, LDIM > *	v1,
		FunctionImpl< T, LDIM > *	v2,
		FunctionImpl< T, LDIM > *	p1,
		FunctionImpl< T, LDIM > *	p2,
		FunctionImpl< T, NDIM > *	eri,
		const bool	fence = `true`
	)

inline

assemble the function V*phi using V and phi given from the functor

this function must have been constructed using the CompositeFunctorInterface. The interface provides one- and two-electron potentials, and the ket, which are assembled to give V*phi.

Parameters

[in]	leaf_op	operator to decide if a given node is a leaf node
[in]	fence	global fence

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::redundant_after_merge, madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

Referenced by madness::FunctionImpl< T, NDIM >::make_Vphi().

◆ map_and_mirror()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::map_and_mirror	(	const implT &	f,
		const std::vector< long > &	map,
		const std::vector< long > &	mirror,
		bool	fence
	)

map and mirror the translation index and the coefficients, result on this

first map the dimensions, the mirror! this = mirror(map(f))

References madness::f, madness::mirror(), and PROFILE_MEMBER_FUNC.

◆ mapdim()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::mapdim	(	const implT &	f,
		const std::vector< long > &	map,
		bool	fence
	)

Permute the dimensions of f according to map, result on this.

References madness::f, and PROFILE_MEMBER_FUNC.

◆ max_depth()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::max_depth ( ) const

Returns the maximum depth of the tree ... collective ... global sum/broadcast.

◆ max_local_depth()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::max_local_depth ( ) const

Returns the maximum local depth of the tree ... no communications.

References N.

◆ max_nodes()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::max_nodes ( ) const

Returns the max number of nodes on a processor.

◆ merge_trees()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::merge_trees	(	const T	alpha,
		const FunctionImpl< Q, NDIM > &	other,
		const R	beta,
		const bool	fence = `true`
	)

inline

merge the trees of this and other, while multiplying them with the alpha or beta, resp

first step in an inplace gaxpy operation for reconstructed functions; assuming the same distribution for this and other on output, this = alpha *this + beta * other

Parameters

[in]	alpha	prefactor for this
[in]	beta	prefactor for other
[in]	other	the other function, reconstructed

References alpha, beta, madness::WorldGopInterface::fence(), madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::get_pmap(), madness::World::gop, MADNESS_ASSERT, and madness::FunctionImpl< T, NDIM >::world.

Referenced by madness::FunctionImpl< T, NDIM >::gaxpy_inplace_reconstructed().

◆ min_nodes()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::min_nodes ( ) const

Returns the min number of nodes on a processor.

◆ mirror()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::mirror	(	const implT &	f,
		const std::vector< long > &	mirror,
		bool	fence
	)

mirror the dimensions of f according to map, result on this

mirror the dimensions of f according to mirror, result on this

References madness::f, and PROFILE_MEMBER_FUNC.

◆ mul()

template<typename T , std::size_t NDIM>

template<typename R >

Tensor< TENSOR_RESULT_TYPE(T, R)> madness::FunctionImpl< T, NDIM >::mul	(	const Tensor< T > &	c1,
		const Tensor< R > &	c2,
		const int	npt,
		const keyT &	key
	)		const

inline

multiply the values of two coefficient tensors using a custom number of grid points

note both coefficient tensors have to refer to the same key!

Parameters

[in]	c1	a tensor holding coefficients
[in]	c2	another tensor holding coeffs
[in]	npt	number of grid points (optional, default is cdata.npt)

Returns: coefficient tensor holding the product of the values of c1 and c2

References madness::copy(), madness::FunctionCommonData< T, NDIM >::get(), madness::Key< NDIM >::level(), NDIM, pow(), madness::FunctionCommonData< T, NDIM >::quad_phit, madness::FunctionCommonData< T, NDIM >::quad_phiw, R, madness::FunctionCommonData< T, NDIM >::s0, madness::Tensor< T >::scale(), madness::scale(), T(), TENSOR_RESULT_TYPE, TERNARY_OPTIMIZED_ITERATOR, madness::transform(), and madness::FunctionCommonData< T, NDIM >::vk.

◆ multi_to_multi_op_values()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values	(	const opT &	op,
		const std::vector< implT * > &	vin,
		std::vector< implT * > &	vout,
		const bool	fence = `true`
	)

inline

Inplace operate on many functions (impl's) with an operator within a certain box.

Assumes all functions have been refined down to the same level

Parameters

[in]	op	the operator
[in]	vin	the vector of function impl's on which to be operated
[out]	vout	the resulting vector of function impl's

References madness::WorldTaskQueue::add(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, op(), madness::WorldContainer< keyT, valueT, hashfunT >::size(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ multi_to_multi_op_values_doit()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values_doit	(	const keyT &	key,
		const opT &	op,
		const std::vector< implT * > &	vin,
		std::vector< implT * > &	vout
	)

inline

Inplace operate on many functions (impl's) with an operator within a certain box.

Parameters

[in]	key	the key of the current function node (box)
[in]	op	the operator
[in]	vin	the vector of function impl's on which to be operated
[out]	vout	the resulting vector of function impl's

References c, cc, madness::FunctionImpl< T, NDIM >::coeffs, madness::FunctionImpl< T, NDIM >::coeffs2values(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), MADNESS_ASSERT, op(), madness::FunctionImpl< T, NDIM >::targs, and madness::FunctionImpl< T, NDIM >::values2coeffs().

◆ multiop_values()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::multiop_values	(	const opT &	op,
		const std::vector< implT * > &	v
	)

inline

Inplace operate on many functions (impl's) with an operator within a certain box Assumes all functions have been refined down to the same level

Parameters

[in]	op	the operator
[in]	v	the vector of function impl's on which to be operated

References madness::WorldTaskQueue::add(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, MADNESS_ASSERT, op(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldContainer< keyT, valueT, hashfunT >::size(), madness::World::taskq, v, and madness::FunctionImpl< T, NDIM >::world.

◆ multiop_values_doit()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::multiop_values_doit	(	const keyT &	key,
		const opT &	op,
		const std::vector< implT * > &	v
	)

inline

Inplace operate on many functions (impl's) with an operator within a certain box

Parameters

[in]	key	the key of the current function node (box)
[in]	op	the operator
[in]	v	the vector of function impl's on which to be operated

References c, cc, madness::FunctionImpl< T, NDIM >::coeffs, madness::FunctionImpl< T, NDIM >::coeffs2values(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), op(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::FunctionImpl< T, NDIM >::targs, v, and madness::FunctionImpl< T, NDIM >::values2coeffs().

◆ multiply() [1/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::multiply	(	const coeffT &	val_ket,
		const coeffT &	val_pot,
		int	particle
	)		const

multiply the ket with a one-electron potential rr(1,2)= f(1,2)*g(1)

Parameters

[in]	val_ket	function values of f(1,2)
[in]	val_pot	function values of g(1)
[in]	particle	if 0 then g(1), if 1 then g(2)

Returns: the resulting function values

References madness::copy(), madness::GenTensor< T >::emul(), madness::GenTensor< T >::full_tensor(), madness::GenTensor< T >::is_full_tensor(), madness::GenTensor< T >::is_svd_tensor(), MADNESS_ASSERT, NDIM, madness::outer(), and madness::GenTensor< T >::tensor_type().

◆ multiply() [2/2]

template<typename T , std::size_t NDIM>

template<size_t LDIM>

void madness::FunctionImpl< T, NDIM >::multiply	(	const implT *	f,
		const FunctionImpl< T, LDIM > *	g,
		const int	particle
	)

inline

multiply f (a pair function of NDIM) with an orbital g (LDIM=NDIM/2)

as in (with h(1,2)=*this) : h(1,2) = g(1) * f(1,2) use tnorm as a measure to determine if f (=*this) must be refined

Parameters

[in]	f	the NDIM function f=f(1,2)
[in]	g	the LDIM function g(1) (or g(2))
[in]	particle	1 or 2, as in g(1) or g(2)

References madness::FunctionImpl< T, NDIM >::coeffs, madness::f, madness::g, madness::FunctionImpl< T, NDIM >::key0(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), madness::World::rank(), madness::reconstructed, madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

Referenced by madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator()(), and madness::partial_mul().

◆ mulXX()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::mulXX	(	const FunctionImpl< L, NDIM > *	left,
		const FunctionImpl< R, NDIM > *	right,
		double	tol,
		bool	fence
	)

inline

Multiplies two functions (impl's) together. Delegates to the mulXXa() method

Parameters

[in]	left	pointer to the left function impl
[in]	right	pointer to the right function impl
[in]	tol	numerical tolerance

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::mulXXa(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), and madness::FunctionImpl< T, NDIM >::world.

◆ mulXXa()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::mulXXa	(	const keyT &	key,
		const FunctionImpl< L, NDIM > *	left,
		const Tensor< L > &	lcin,
		const FunctionImpl< R, NDIM > *	right,
		const Tensor< R > &	rcin,
		double	tol
	)

inline

Multiplication using recursive descent and assuming same distribution Both left and right functions are in the scaling function basis

Parameters

[in]	key	the key to the current function node (box)
[in]	left	the function impl associated with the left function
[in]	lcin	the scaling function coefficients associated with the current box in the left function
[in]	right	the function impl associated with the right function
[in]	rcin	the scaling function coefficients associated with the current box in the right function

References madness::___, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), MADNESS_ASSERT, madness::Tensor< T >::normf(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::BaseTensor::size(), madness::FunctionImpl< T, NDIM >::targs, madness::WorldObject< FunctionImpl< T, NDIM > >::task(), madness::FunctionImpl< T, NDIM >::truncate_tol(), and madness::FunctionImpl< T, NDIM >::unfilter().

Referenced by madness::FunctionImpl< T, NDIM >::mulXX().

◆ mulXXvec()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::mulXXvec	(	const FunctionImpl< L, NDIM > *	left,
		const std::vector< const FunctionImpl< R, NDIM > * > &	vright,
		const std::vector< FunctionImpl< T, NDIM > * > &	vresult,
		double	tol,
		bool	fence
	)

inline

Multiplies a function (impl) with a vector of functions (impl's). Delegates to the mulXXveca() method.

Parameters

[in]	left	pointer to the left function impl
[in]	vright	vector of pointers to the right function impl's
[in]	tol	numerical tolerance
[out]	vresult	vector of pointers to the resulting function impl's

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), and madness::FunctionImpl< T, NDIM >::world.

◆ mulXXveca()

template<typename T , std::size_t NDIM>

template<typename L , typename R >

void madness::FunctionImpl< T, NDIM >::mulXXveca	(	const keyT &	key,
		const FunctionImpl< L, NDIM > *	left,
		const Tensor< L > &	lcin,
		const std::vector< const FunctionImpl< R, NDIM > * >	vrightin,
		const std::vector< Tensor< R > > &	vrcin,
		const std::vector< FunctionImpl< T, NDIM > * >	vresultin,
		double	tol
	)

inline

Both left and right functions are in the scaling function basis

Parameters

[in]	key	the key to the current function node (box)
[in]	left	the function impl associated with the left function
[in]	lcin	the scaling function coefficients associated with the current box in the left function
[in]	vrightin	the vector of function impl's associated with the vector of right functions
[in]	vrcin	the vector scaling function coefficients associated with the current box in the right functions
[out]	vresultin	the vector of resulting functions (impl's)

Referenced by madness::FunctionImpl< T, NDIM >::mulXXvec().

◆ nCoeff()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::nCoeff ( ) const

Returns the number of coefficients in the function ... collective global sum.

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::GenTensor< T >::nCoeff(), and sum.

◆ neighbor()

template<typename T , std::size_t NDIM>

Key< NDIM > madness::FunctionImpl< T, NDIM >::neighbor	(	const keyT &	key,
		const keyT &	disp,
		const std::vector< bool > &	is_periodic
	)		const

Returns key of general neighbor enforcing BC.

Out of volume keys are mapped to enforce the BC as follows.

Periodic BC map back into the volume and return the correct key
Zero BC - returns invalid() to indicate out of volume

References axis, NDIM, and madness::Key< NDIM >::translation().

Referenced by madness::FunctionImpl< T, NDIM >::do_apply(), and madness::FunctionImpl< T, NDIM >::do_apply_directed_screening().

◆ noautorefine()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::noautorefine	(	const keyT &	key,
		const tensorT &	t
	)		const

Always returns false (for when autorefine is not wanted)

◆ norm2sq_local()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::norm2sq_local ( ) const

Returns the square of the local norm ... no comms.

References PROFILE_MEMBER_FUNC.

◆ norm_tree()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::norm_tree ( bool fence )

compute for each FunctionNode the norm of the function inside that node

◆ norm_tree_op()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::norm_tree_op	(	const keyT &	key,
		const std::vector< Future< double > > &	v
	)

References sum, and v.

◆ norm_tree_spawn()

template<typename T , std::size_t NDIM>

Future< double > madness::FunctionImpl< T, NDIM >::norm_tree_spawn ( const keyT & key )

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_children(), NDIM, norm(), madness::GenTensor< T >::normf(), madness::FunctionNode< T, NDIM >::set_norm_tree(), and v.

◆ NS_fcube_for_mul()

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::NS_fcube_for_mul	(	const keyT &	child,
		const keyT &	parent,
		const GenTensor< Q > &	coeff,
		const bool	s_only
	)		const

inline

Compute the function values for multiplication.

Given S or NS coefficients from a parent cell, compute the value of the functions at the quadrature points of a child currently restricted to special cases

Parameters

[in]	child	key of the box in which we compute values
[in]	parent	key of the parent box holding the coeffs
[in]	coeff	coeffs of the parent box
[in]	s_only	sanity check to avoid unintended discard of d coeffs

Returns: function values on the quadrature points of the children of child (!)

References madness::_(), madness::FunctionImpl< T, NDIM >::cdata, d, madness::GenTensor< T >::dim(), madness::general_transform(), madness::FunctionImpl< T, NDIM >::k, madness::Key< NDIM >::level(), MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, madness::FunctionImpl< T, NDIM >::phi_for_mul(), madness::scale(), and madness::Key< NDIM >::translation().

◆ NScoeffs2values()

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::NScoeffs2values	(	const keyT &	key,
		const GenTensor< Q > &	coeff,
		const bool	s_only
	)		const

inline

convert S or NS coeffs to values on a 2k grid of the children

equivalent to unfiltering the NS coeffs and then converting all child S-coeffs to values in their respective boxes. If only S coeffs are provided d coeffs are assumed to be zero. Reverse operation to values2NScoeffs().

Parameters

[in]	key	the key of the current S or NS coeffs, level n
[in]	coeff	coeffs in S or NS form; if S then d coeffs are assumed zero
[in]	s_only	sanity check to avoid unintended discard of d coeffs

Returns: function values on the quadrature points of the children of child (!)

References madness::_(), madness::FunctionImpl< T, NDIM >::cdata, madness::GenTensor< T >::dim(), madness::inner(), madness::FunctionImpl< T, NDIM >::k, madness::Key< NDIM >::level(), MADNESS_ASSERT, NDIM, pow(), madness::scale(), and madness::transform().

◆ parent_to_child()

template<typename T , std::size_t NDIM>

const GenTensor< T > madness::FunctionImpl< T, NDIM >::parent_to_child	(	const coeffT &	s,
		const keyT &	parent,
		const keyT &	child
	)		const

Directly project parent coeffs to child coeffs.

Currently used by diff, but other uses can be anticipated

Todo:: is this documentation correct?

Parameters

[in]	child	the key whose coeffs we are requesting
[in]	parent	the (leaf) key of our function
[in]	s	the (leaf) coeffs belonging to parent

Returns: coeffs

References madness::Key< NDIM >::is_invalid(), madness::Key< NDIM >::level(), NDIM, pow(), madness::GenTensor< T >::scale(), and madness::transform().

Referenced by madness::CoeffTracker< T, NDIM >::coeff(), madness::Derivative< T, NDIM >::do_diff2b(), madness::Derivative< T, NDIM >::do_diff2i(), madness::FunctionImpl< T, NDIM >::do_project_out(), madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::operator()(), and madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()().

◆ parent_to_child_NS()

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::parent_to_child_NS	(	const keyT &	child,
		const keyT &	parent,
		const coeffT &	coeff
	)		const

Directly project parent NS coeffs to child NS coeffs.

return the NS coefficients if parent and child are the same, or construct sum coeffs from the parents and "add" zero wavelet coeffs

Parameters

[in]	child	the key whose coeffs we are requesting
[in]	parent	the (leaf) key of our function
[in]	coeff	the (leaf) coeffs belonging to parent

Returns: coeffs in NS form

References madness::GenTensor< T >::dim(), madness::f, madness::Key< NDIM >::level(), MADNESS_ASSERT, MADNESS_EXCEPTION, and madness::GenTensor< T >::tensor_type().

Referenced by madness::CoeffTracker< T, NDIM >::coeff().

◆ partial_inner()

template<typename T , std::size_t NDIM>

template<typename Q , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2>

void madness::FunctionImpl< T, NDIM >::partial_inner	(	const FunctionImpl< Q, LDIM > &	g,
		const FunctionImpl< R, KDIM > &	h,
		const std::array< int, CDIM >	v1,
		const std::array< int, CDIM >	v2
	)

inline

invoked by result

contract 2 functions f(x,z) = \int g(x,y) * h(y,z) dy

Template Parameters

CDIM	the dimension of the contraction variable (y)
NDIM	the dimension of the result (x,z)
LDIM	the dimension of g(x,y)
KDIM	the dimension of h(y,z)

◆ partial_inner_contract()

template<typename T , std::size_t NDIM>

template<typename Q , std::size_t LDIM, typename R , std::size_t KDIM, std::size_t CDIM = (KDIM + LDIM - NDIM) / 2>

void madness::FunctionImpl< T, NDIM >::partial_inner_contract	(	const FunctionImpl< Q, LDIM > *	g,
		const FunctionImpl< R, KDIM > *	h,
		const std::array< int, CDIM >	v1,
		const std::array< int, CDIM >	v2,
		const Key< NDIM > &	key,
		const std::list< Key< CDIM > > &	j_key_list
	)

inline

tensor contraction part of partial_inner

Parameters

[in]	g	rhs of the inner product
[in]	h	lhs of the inner product
[in]	v1	dimensions of g to be contracted
[in]	v2	dimensions of h to be contracted
[in]	key	key of result's (this) FunctionNode
[in]	j_key_list	list of contraction index-j keys contributing to this' node

References madness::FunctionNode< T, NDIM >::accumulate(), madness::Key< NDIM >::break_apart(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), madness::GenTensor< T >::dim(), madness::BaseTensor::dim(), madness::Tensor< T >::flat(), madness::GenTensor< T >::full_tensor(), madness::Tensor< T >::fusedim(), madness::g, madness::FunctionImpl< T, NDIM >::get_cdata(), madness::GenTensor< T >::get_svdtensor(), madness::FunctionImpl< T, NDIM >::get_tensor_args(), madness::FunctionImpl< T, NDIM >::get_tensor_type(), madness::FunctionImpl< T, NDIM >::get_thresh(), h(), madness::TaskAttributes::hipri(), madness::inner(), madness::GenTensor< T >::is_assigned(), madness::GenTensor< T >::is_full_tensor(), madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), madness::GenTensor< T >::is_svd_tensor(), madness::Key< NDIM >::level(), MADNESS_CHECK, MADNESS_EXCEPTION, madness::BaseTensor::ndim(), offset, madness::GenTensor< T >::reduce_rank(), madness::Tensor< T >::reshape(), s0, madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::BaseTensor::size(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), v, and w().

◆ phi_for_mul()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::phi_for_mul	(	Level	np,
		Translation	lp,
		Level	nc,
		Translation	lc,
		Tensor< double > &	phi
	)		const

Compute the Legendre scaling functions for multiplication.

Evaluate parent polyn at quadrature points of a child. The prefactor of 2^n/2 is included. The tensor must be preallocated as phi(k,npt). Refer to the implementation notes for more info.

Todo:: Robert please verify this comment. I don't understand this method.

Parameters

[in]	np	level of the parent function node (box)
[in]	nc	level of the child function node (box)
[in]	lp	translation of the parent function node (box)
[in]	lc	translation of the child function node (box)
[out]	phi	tensor of the legendre scaling functions

References e(), k, madness::legendre_scaling_functions(), MADNESS_ASSERT, mu, np, p(), pow(), madness::Tensor< T >::scale(), and madness::scale().

Referenced by madness::FunctionImpl< T, NDIM >::fcube_for_mul(), madness::FunctionImpl< T, NDIM >::fcube_for_mul(), and madness::FunctionImpl< T, NDIM >::NS_fcube_for_mul().

◆ plot_cube_kernel()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::plot_cube_kernel	(	archive::archive_ptr< Tensor< T > >	ptr,
		const keyT &	key,
		const coordT &	plotlo,
		const coordT &	plothi,
		const std::vector< long > &	npt,
		bool	eval_refine
	)		const

Todo:: help!

◆ print_grid()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_grid ( const std::string filename ) const

print the grid (the roots of the quadrature of each leaf box) of this function in user xyz coordinates

Parameters

[in] filename the filename for the output

print the grid (the roots of the quadrature of each leaf box) of this function in user xyz coordinates

References madness::filename.

◆ print_info()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_info ( ) const

Prints summary of data distribution.

References madness::FunctionNode< T, NDIM >::is_leaf().

◆ print_plane()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_plane	(	const std::string	filename,
		const int	xaxis,
		const int	yaxis,
		const coordT &	el2
	)

Print a plane ("xy", "xz", or "yz") containing the point x to file.

works for all dimensions; we walk through the tree, and if a leaf node inside the sub-cell touches the plane we print it in pstricks format

References madness::filename.

◆ print_plane_local()

template<typename T , std::size_t NDIM>

Tensor< double > madness::FunctionImpl< T, NDIM >::print_plane_local	(	const int	xaxis,
		const int	yaxis,
		const coordT &	el2
	)

collect the data for a plot of the MRA structure locally on each node

Parameters

[in]	xaxis	the x-axis in the plot (can be any axis of the MRA box)
[in]	yaxis	the y-axis in the plot (can be any axis of the MRA box)
[in]	el2	needs a description

Todo:: Provide a description for el2

Parameters

[in]	xaxis	the x-axis in the plot (can be any axis of the MRA box)
[in]	yaxis	the y-axis in the plot (can be any axis of the MRA box)
[in]	el2

References madness::_(), madness::FunctionCommonData< T, NDIM >::_init_quadrature(), madness::FunctionNode< T, NDIM >::coeff(), madness::error(), madness::FunctionDefaults< NDIM >::get_cell(), madness::FunctionDefaults< NDIM >::get_cell_width(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::FunctionNode< T, NDIM >::is_leaf(), k, madness::Key< NDIM >::level(), op(), madness::GenTensor< T >::rank(), madness::scale(), madness::Key< NDIM >::thisKeyContains(), and madness::Key< NDIM >::translation().

◆ print_size()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_size ( const std::string name ) const

print tree size and size

References bufsize, d, madness::name(), norm(), madness::print(), T(), and madness::wall_time().

◆ print_stats()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_stats ( ) const

print the number of configurations per node

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), k, k0, NDIM, madness::print(), madness::Tensor< T >::ptr(), madness::GenTensor< T >::rank(), madness::BaseTensor::size(), madness::Tensor< T >::sum(), and madness::TT_FULL.

◆ print_timer()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_timer ( ) const

◆ print_tree()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_tree	(	std::ostream &	os = `std::cout`,
		Level	maxlevel = `10000`
	)		const

Prints the coeffs tree of the current function impl

Parameters

[in]	maxlevel	the maximum level of the tree for printing
[out]	os	the ostream to where the output is sent

◆ print_tree_graphviz()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_tree_graphviz	(	std::ostream &	os = `std::cout`,
		Level	maxlevel = `10000`
	)		const

Prints the coeffs tree of the current function impl (using GraphViz)

Parameters

[in]	maxlevel	the maximum level of the tree for printing
[out]	os	the ostream to where the output is sent

◆ print_tree_json()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::print_tree_json	(	std::ostream &	os = `std::cout`,
		Level	maxlevel = `10000`
	)		const

Same as print_tree() but in JSON format

Parameters

[out]	os	the ostream to where the output is sent
[in]	maxlevel	the maximum level of the tree for printing

◆ print_type_in_compilation_error()

template<typename T , std::size_t NDIM>

template<typename R >

void madness::FunctionImpl< T, NDIM >::print_type_in_compilation_error ( R && )

inline

◆ project() [1/2]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::project	(	const implT &	old,
		bool	fence
	)

Projects old function into new basis (only in reconstructed form)

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), c, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::FunctionNode< T, NDIM >::has_coeff(), and NDIM.

◆ project() [2/2]

template<typename T , std::size_t NDIM>

Tensor< T > madness::FunctionImpl< T, NDIM >::project ( const keyT & key ) const

Compute by projection the scaling function coeffs in specified box

Parameters

[in] key the key to the current function node (box)

References madness::fast_transform(), madness::fcube(), madness::Key< NDIM >::level(), MADNESS_ASSERT, MADNESS_EXCEPTION, NDIM, pow(), and madness::Tensor< T >::scale().

◆ project_out()

template<typename T , std::size_t NDIM>

template<size_t LDIM>

void madness::FunctionImpl< T, NDIM >::project_out	(	FunctionImpl< T, NDIM-LDIM > *	result,
		const FunctionImpl< T, LDIM > *	gimpl,
		const int	dim,
		const bool	fence
	)

inline

project the low-dim function g on the hi-dim function f: result(x) = <this(x,y) | g(y)>

invoked by the hi-dim function, a function of NDIM+LDIM Upon return, result matches this, with contributions on all scales

Parameters

[in] result lo-dim function of NDIM-LDIM

Todo:: Should this be param[out]?

Parameters

[in]	gimpl	lo-dim function of LDIM
[in]	dim	over which dimensions to be integrated: 0..LDIM or LDIM..LDIM+NDIM-1

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::key0(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ project_out2()

template<typename T , std::size_t NDIM>

template<size_t LDIM>

void madness::FunctionImpl< T, NDIM >::project_out2	(	const FunctionImpl< T, LDIM+NDIM > *	f,
		const FunctionImpl< T, LDIM > *	g,
		const int	dim
	)

inline

project the low-dim function g on the hi-dim function f: this(x) = <f(x,y) | g(y)>

invoked by result, a function of NDIM

Parameters

[in]	f	hi-dim function of LDIM+NDIM
[in]	g	lo-dim function of LDIM
[in]	dim	over which dimensions to be integrated: 0..LDIM or LDIM..LDIM+NDIM-1

References madness::Key< NDIM >::break_apart(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionImpl< T, NDIM >::coeffs, madness::f, madness::g, madness::GenTensor< T >::has_data(), madness::TaskAttributes::hipri(), madness::FunctionNode< T, NDIM >::is_leaf(), MADNESS_EXCEPTION, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::redundant, madness::Future< T >::remote_ref(), madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::FunctionImpl< T, NDIM >::sock_it_to_me(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ project_refine_op()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::project_refine_op	(	const keyT &	key,
		bool	do_refine,
		const std::vector< Vector< double, NDIM > > &	specialpts
	)

Projection with optional refinement w/ special points

Parameters

[in]	key	the key to the current function node (box)
[in]	do_refine	should we continue refinement?
[in]	specialpts	vector of special points in the function where we need to refine at a much finer level

project the functor into this functionimpl, and "return" a tree in reconstructed, rank-reduced form.

Parameters

[in]	key	current FunctionNode
[in]	do_refine
[in]	specialpts	in case these are very spiky functions – don't undersample

References madness::copy(), d, madness::FunctionDefaults< NDIM >::get_bc(), madness::Key< NDIM >::is_neighbor_of(), madness::BoundaryConditions< NDIM >::is_periodic(), madness::Key< NDIM >::level(), p(), madness::project(), s0, madness::simpt2key(), T(), thresh, and madness::user_to_sim().

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl().

◆ put_in_box()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::put_in_box	(	ProcessID	from,
		long	nl,
		long	ni
	)		const

◆ range()

template<typename T , std::size_t NDIM>

rangeT madness::FunctionImpl< T, NDIM >::range	(	coeffs.	begin(),
		coeffs.	end()
	)

Referenced by madness::FunctionImpl< T, NDIM >::errsq_local().

◆ read_grid()

template<typename T , std::size_t NDIM>

template<size_t FDIM>

std::enable_if< NDIM==FDIM >::type madness::FunctionImpl< T, NDIM >::read_grid	(	const std::string	keyfile,
		const std::string	gridfile,
		std::shared_ptr< FunctionFunctorInterface< double, NDIM > >	vnuc_functor
	)

inline

read data from a grid

Parameters

[in]	keyfile	file with keys and grid points for each key
[in]	gridfile	file with grid points, w/o key, but with same ordering
[in]	vnuc_functor	subtract the values of this functor if regularization is needed

References c, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::BaseTensor::dim(), madness::FunctionDefaults< NDIM >::get_cell(), madness::FunctionDefaults< NDIM >::get_cell_width(), h(), madness::FunctionImpl< T, NDIM >::k, madness::Key< NDIM >::level(), MADNESS_ASSERT, MADNESS_CHECK, MADNESS_EXCEPTION, NDIM, madness::Key< NDIM >::parent(), madness::print(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldObject< FunctionImpl< T, NDIM > >::send(), madness::FunctionImpl< T, NDIM >::targs, madness::Key< NDIM >::translation(), and madness::FunctionImpl< T, NDIM >::values2coeffs().

◆ read_grid2()

template<typename T , std::size_t NDIM>

template<size_t FDIM>

std::enable_if< NDIM==FDIM >::type madness::FunctionImpl< T, NDIM >::read_grid2	(	const std::string	gridfile,
		std::shared_ptr< FunctionFunctorInterface< double, NDIM > >	vnuc_functor
	)

inline

read data from a grid

Parameters

[in]	gridfile	file with keys and grid points and values for each key
[in]	vnuc_functor	subtract the values of this functor if regularization is needed

References c, madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::BaseTensor::dim(), madness::FunctionDefaults< NDIM >::get_cell(), madness::FunctionDefaults< NDIM >::get_cell_width(), h(), madness::FunctionImpl< T, NDIM >::k, madness::Key< NDIM >::level(), MADNESS_CHECK, MADNESS_EXCEPTION, NDIM, madness::Key< NDIM >::parent(), madness::print(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldObject< FunctionImpl< T, NDIM > >::send(), madness::FunctionImpl< T, NDIM >::targs, madness::Key< NDIM >::translation(), and madness::FunctionImpl< T, NDIM >::values2coeffs().

◆ real_size()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::real_size ( ) const

Returns the number of coefficients in the function ... collective global sum.

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::GenTensor< T >::real_size(), and sum.

◆ reconstruct()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::reconstruct ( bool fence )

reconstruct this tree – respects fence

References MADNESS_EXCEPTION, madness::nonstandard_after_apply, and madness::reconstructed.

Referenced by madness::innerXX().

◆ reconstruct_op()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::reconstruct_op	(	const keyT &	key,
		const coeffT &	s,
		const bool	accumulate_NS = `true`
	)

References madness::FunctionNode< T, NDIM >::clear_coeff(), madness::FunctionNode< T, NDIM >::coeff(), madness::copy(), d, madness::FunctionNode< T, NDIM >::has_children(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::FunctionNode< T, NDIM >::is_leaf(), madness::Key< NDIM >::level(), MADNESS_ASSERT, madness::GenTensor< T >::reduce_rank(), madness::FunctionNode< T, NDIM >::set_coeff(), madness::FunctionNode< T, NDIM >::set_has_children(), and thresh.

◆ recur_down_for_contraction_map()

template<typename T , std::size_t NDIM>

template<std::size_t CDIM, std::size_t ODIM, std::size_t FDIM = NDIM+ODIM-2*CDIM>

std::multimap< Key< FDIM >, std::list< Key< CDIM > > > madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map	(	const keyT &	key,
		const nodeT &	node,
		const std::array< int, CDIM > &	v_this,
		const std::array< int, CDIM > &	v_other,
		const std::set< Key< ODIM > > &	ij_other_list,
		const std::map< Key< CDIM >, double > &	j_other_list,
		bool	this_first,
		const double	thresh
	)

inline

make a map of all nodes that will contribute to a partial inner product

given the list of d coefficient-holding nodes of the other function: recur down h if snorm * dnorm > tol and key n−jx ∈ other−ij-list. Make s coefficients if necessary. Make list of nodes n − ijk as map(n-ik, list(j)).

!! WILL ADD NEW S NODES TO THIS TREE THAT MUST BE REMOVED TO AVOID INCONSISTENT TREE STRUCTURE !!

Parameters

[in]	key	for recursion
[in]	node	corresponds to key
[in]	v_this	this' dimension that are contracted
[in]	v_other	other's dimension that are contracted
[in]	ij_other_list	list of nodes of the other function that will be contracted (and their parents)
[in]	j_other_list	list of column nodes of the other function that will be contracted (and their parents)
[in]	max_d_norm	max d coeff norm of the nodes in j_list
[in]	this_first	are the remaining coeffs of this functions first or last in the result function
[in]	thresh	threshold for including nodes in the contraction: snorm*dnorm > thresh

Template Parameters

CDIM	dimension to be contracted
ODIM	dimensions of the other function
FDIM	dimensions of the final function

Referenced by madness::FunctionImpl< T, NDIM >::partial_inner(), and madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map().

◆ recursive_apply() [1/2]

template<typename T , std::size_t NDIM>

template<typename opT , std::size_t LDIM>

void madness::FunctionImpl< T, NDIM >::recursive_apply	(	opT &	apply_op,
		const FunctionImpl< T, LDIM > *	fimpl,
		const FunctionImpl< T, LDIM > *	gimpl,
		const bool	fence
	)

inline

traverse a non-existing tree, make its coeffs and apply an operator

invoked by result here we use the fact that the hi-dim NS coefficients on all scales are exactly the outer product of the underlying low-dim functions (also in NS form), so we don't need to construct the full hi-dim tree and then turn it into NS form.

Parameters

[in]	apply_op	the operator acting on the NS tree
[in]	fimpl	the funcimpl of the function of particle 1
[in]	gimpl	the funcimpl of the function of particle 2

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::key0(), madness::nonstandard_after_apply, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), madness::World::rank(), madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ recursive_apply() [2/2]

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::recursive_apply	(	opT &	apply_op,
		const implT *	fimpl,
		implT *	rimpl,
		const bool	fence
	)

inline

traverse an existing tree and apply an operator

invoked by result

Parameters

[in]	apply_op	the operator acting on the NS tree
[in]	fimpl	the funcimpl of the source function
[in]	rimpl	a dummy function for recursive_op to insert data

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::FunctionImpl< T, NDIM >::key0(), madness::nonstandard_after_apply, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::print(), madness::World::rank(), madness::FunctionImpl< T, NDIM >::set_tree_state(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ reduce() [1/2]

template<typename T , std::size_t NDIM>

return world taskq madness::FunctionImpl< T, NDIM >::reduce	(	range	,
		do_inner_local_on_demand< R >	this, &gimpl
	)

◆ reduce() [2/2]

template<typename T , std::size_t NDIM>

return world taskq madness::FunctionImpl< T, NDIM >::reduce	(	rangeT(coeffs.begin(), coeffs.end())	,
		do_inner_local< R > &,	leaves_only
	)

◆ reduce_rank()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::reduce_rank	(	const double	thresh,
		bool	fence
	)

reduce the rank of the coefficients tensors

Parameters

[in] targs target tensor arguments (threshold and full/low rank)

References thresh.

◆ refine()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::refine	(	const opT &	op,
		bool	fence
	)

inline

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::World::gop, madness::TaskAttributes::hipri(), op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::WorldObject< FunctionImpl< T, NDIM > >::task(), and madness::FunctionImpl< T, NDIM >::world.

◆ refine_op()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::refine_op	(	const opT &	op,
		const keyT &	key
	)

inline

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::child_patch(), madness::FunctionNode< T, NDIM >::clear_coeff(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionImpl< T, NDIM >::coeffs, madness::copy(), d, madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::Key< NDIM >::level(), MADNESS_CHECK, madness::FunctionImpl< T, NDIM >::max_refine_level, op(), madness::GenTensor< T >::reduce_rank(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::FunctionNode< T, NDIM >::set_has_children(), madness::FunctionImpl< T, NDIM >::targs, madness::TensorArgs::thresh, and madness::FunctionImpl< T, NDIM >::unfilter().

◆ refine_spawn()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::refine_spawn	(	const opT &	op,
		const keyT &	key
	)

inline

References madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::FunctionNode< T, NDIM >::has_children(), madness::TaskAttributes::hipri(), op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldObject< FunctionImpl< T, NDIM > >::task().

◆ refine_to_common_level()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::refine_to_common_level	(	const std::vector< FunctionImpl< T, NDIM > * > &	v,
		const std::vector< tensorT > &	c,
		const keyT	key
	)

Refine multiple functions down to the same finest level.

Parameters

v	the vector of functions we are refining.
key	the current node.
c	the vector of coefficients passed from above.
[v]	is the vector of functions we are refining.
[key]	is the current node.
[c]	is the vector of coefficients passed from above.

References c, madness::copy(), d, MADNESS_ASSERT, MADNESS_CHECK, and v.

◆ remove_internal_coefficients()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::remove_internal_coefficients ( const bool fence )

◆ remove_leaf_coefficients()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::remove_leaf_coefficients ( const bool fence )

◆ replicate()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::replicate ( bool fence = true )

inline

References madness::FunctionImpl< T, NDIM >::coeffs, and madness::WorldContainer< keyT, valueT, hashfunT >::replicate().

◆ reset_timer()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::reset_timer ( )

◆ scale_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::scale_inplace	(	const T	q,
		bool	fence
	)

In-place scale by a constant.

References q().

Referenced by madness::FunctionImpl< T, NDIM >::gaxpy_inplace().

◆ scale_oop()

template<typename T , std::size_t NDIM>

template<typename Q , typename F >

void madness::FunctionImpl< T, NDIM >::scale_oop	(	const Q	q,
		const FunctionImpl< F, NDIM > &	f,
		bool	fence
	)

inline

Out-of-place scale by a constant.

References madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::f, madness::WorldGopInterface::fence(), madness::World::gop, q(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), and madness::FunctionImpl< T, NDIM >::world.

◆ set_autorefine()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::set_autorefine ( bool value )

◆ set_functor()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::set_functor ( const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor1 )

References madness::on_demand.

◆ set_tensor_args()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::set_tensor_args ( const TensorArgs & t )

◆ set_thresh()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::set_thresh ( double value )

References thresh.

◆ set_tree_state()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::set_tree_state ( const TreeState & state )

inline

References madness::FunctionImpl< T, NDIM >::tree_state.

Referenced by madness::FunctionImpl< T, NDIM >::apply(), madness::FunctionImpl< T, NDIM >::apply_source_driven(), madness::FunctionImpl< T, NDIM >::hartree_product(), madness::FunctionImpl< T, NDIM >::make_Vphi(), madness::FunctionImpl< T, NDIM >::make_Vphi_only(), madness::FunctionImpl< T, NDIM >::multiply(), madness::FunctionImpl< T, NDIM >::project_out2(), madness::FunctionImpl< T, NDIM >::recursive_apply(), and madness::FunctionImpl< T, NDIM >::recursive_apply().

◆ size()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::size ( ) const

Returns the number of coefficients in the function ... collective global sum.

References madness::FunctionNode< T, NDIM >::has_coeff(), NDIM, madness::FunctionNode< T, NDIM >::size(), and sum.

Referenced by madness::FunctionImpl< T, NDIM >::do_dot_localX(), madness::FunctionImpl< T, NDIM >::do_inner_localX(), madness::FunctionImpl< T, NDIM >::mulXXveca(), and madness::FunctionImpl< T, NDIM >::partial_inner().

◆ sock_it_to_me()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::sock_it_to_me	(	const keyT &	key,
		const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &	ref
	)		const

Walk up the tree returning pair(key,node) for first node with coefficients.

Three possibilities.

1) The coeffs are present and returned with the key of the containing node.

2) The coeffs are further up the tree ... the request is forwarded up.

3) The coeffs are futher down the tree ... an empty tensor is returned.

!! This routine is crying out for an optimization to manage the number of messages being sent ... presently each parent is fetched 2^(n*d) times where n is the no. of levels between the level of evaluation and the parent. Alternatively, reimplement multiply as a downward tree walk and just pass the parent down. Slightly less parallelism but much less communication.

Todo:: Robert .... help!

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::TaskAttributes::hipri(), madness::Key< NDIM >::parent(), and madness::Future< T >::set().

Referenced by madness::DerivativeBase< T, NDIM >::find_neighbor(), and madness::FunctionImpl< T, NDIM >::project_out2().

◆ sock_it_to_me_too()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::sock_it_to_me_too	(	const keyT &	key,
		const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &	ref
	)		const

As above, except 3) The coeffs are constructed from the avg of nodes further down the tree

Todo:: Robert .... help!

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::TaskAttributes::hipri(), madness::Key< NDIM >::parent(), PROFILE_MEMBER_FUNC, madness::project(), and madness::Future< T >::set().

◆ square_inplace()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::square_inplace ( bool fence )

Pointwise squaring of function with optional global fence.

If not autorefining, local computation only if not fencing. If autorefining, may result in asynchronous communication.

◆ standard()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::standard ( bool fence )

Changes non-standard compressed form to standard compressed form.

References madness::compressed.

◆ store()

template<typename T , std::size_t NDIM>

template<typename Archive >

void madness::FunctionImpl< T, NDIM >::store ( Archive & ar )

inline

◆ sum_down()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::sum_down ( bool fence )

After 1d push operator must sum coeffs down the tree to restore correct scaling function coefficients.

Referenced by madness::FunctionImpl< T, NDIM >::make_Vphi().

◆ sum_down_spawn()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::sum_down_spawn	(	const keyT &	key,
		const coeffT &	s
	)

is this the same as trickle_down() ?

References c, madness::FunctionNode< T, NDIM >::clear_coeff(), madness::FunctionNode< T, NDIM >::coeff(), madness::copy(), d, madness::GenTensor< T >::gaxpy(), and madness::FunctionNode< T, NDIM >::has_children().

Referenced by madness::FunctionImpl< T, NDIM >::gaxpy_inplace_reconstructed().

◆ TENSOR_RESULT_TYPE() [1/3]

template<typename T , std::size_t NDIM>

template<typename R >

madness::FunctionImpl< T, NDIM >::TENSOR_RESULT_TYPE	(	T	,
		R
	)		const

Returns the inner product ASSUMING same distribution.

handles compressed and redundant form

◆ TENSOR_RESULT_TYPE() [2/3]

template<typename T , std::size_t NDIM>

template<typename R >

madness::FunctionImpl< T, NDIM >::TENSOR_RESULT_TYPE	(	T	,
		R
	)		const

Returns the inner product of this with function g constructed on-the-fly.

the leaf boxes of this' MRA tree defines the inner product

◆ TENSOR_RESULT_TYPE() [3/3]

template<typename T , std::size_t NDIM>

typedef madness::FunctionImpl< T, NDIM >::TENSOR_RESULT_TYPE	(	T	,
		R
	)

◆ tnorm() [1/3]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::tnorm	(	const GenTensor< T > &	t,
		double *	lo,
		double *	hi
	)

static

References madness::copy(), madness::GenTensor< T >::dim(), madness::FunctionCommonData< T, NDIM >::get(), lo, and madness::GenTensor< T >::normf().

◆ tnorm() [2/3]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::tnorm	(	const SVDTensor< T > &	t,
		double *	lo,
		double *	hi,
		const int	particle
	)

static

References madness::_(), c, madness::BaseTensor::dim(), madness::SRConf< T >::flat_vector(), madness::FunctionCommonData< T, NDIM >::get(), lo, madness::SVDTensor< T >::rank(), madness::Tensor< T >::reshape(), madness::vec(), and madness::SRConf< T >::weights().

◆ tnorm() [3/3]

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::tnorm	(	const tensorT &	t,
		double *	lo,
		double *	hi
	)

static

Computes norm of low/high-order polyn. coeffs for autorefinement test.

t is a k^d tensor. In order to screen the autorefinement during multiplication compute the norms of ... lo ... the block of t for all polynomials of order < k/2 ... hi ... the block of t for all polynomials of order >= k/2

k=5 0,1,2,3,4 --> 0,1,2 ... 3,4 k=6 0,1,2,3,4,5 --> 0,1,2 ... 3,4,5

k=number of wavelets, so k=5 means max order is 4, so max exactly representable squarable polynomial is of order 2.

References madness::copy(), madness::BaseTensor::dim(), madness::Tensor< T >::fill(), madness::FunctionCommonData< T, NDIM >::get(), lo, and madness::Tensor< T >::normf().

Referenced by madness::FunctionImpl< T, NDIM >::pointwise_multiplier< LDIM >::pointwise_multiplier(), madness::FunctionImpl< T, NDIM >::pointwise_multiplier< LDIM >::operator()(), refop::operator()(), refop::operator()(), and madness::FunctionImpl< T, NDIM >::multiply_op< LDIM >::screen().

◆ trace_local()

template<typename T , std::size_t NDIM>

T madness::FunctionImpl< T, NDIM >::trace_local ( ) const

Returns int(f(x),x) in local volume.

References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::full_tensor_copy(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::Key< NDIM >::level(), NDIM, pow(), PROFILE_MEMBER_FUNC, sum, and T().

◆ traverse_tree()

template<typename T , std::size_t NDIM>

template<typename coeff_opT , typename apply_opT >

void madness::FunctionImpl< T, NDIM >::traverse_tree	(	const coeff_opT &	coeff_op,
		const apply_opT &	apply_op,
		const keyT &	key
	)		const

inline

traverse a non-existing tree

part I: make the coefficients, process them and continue the recursion if necessary

Parameters

[in]	coeff_op	operator making the coefficients and determining them being leaves
[in]	apply_op	operator processing the coefficients
[in]	key	the key we are currently working on

References madness::arg(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), MADNESS_ASSERT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), p(), and madness::WorldObject< FunctionImpl< T, NDIM > >::task().

◆ tree_size()

template<typename T , std::size_t NDIM>

std::size_t madness::FunctionImpl< T, NDIM >::tree_size ( ) const

Returns the size of the tree structure of the function ... collective global sum.

References sum.

◆ trickle_down()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::trickle_down ( bool fence )

sum all the contributions from all scales after applying an operator in mod-NS form

References madness::reconstructed.

◆ trickle_down_op()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::trickle_down_op	(	const keyT &	key,
		const coeffT &	s
	)

sum all the contributions from all scales after applying an operator in mod-NS form

cf reconstruct_op

◆ truncate()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::truncate	(	double	tol,
		bool	fence
	)

Truncate according to the threshold with optional global fence.

If thresh<=0 the default value of this->thresh is used

Parameters

[in] tol the truncation tolerance

If thresh<=0 the default value of this->thresh is used

References thresh.

◆ truncate_op()

template<typename T , std::size_t NDIM>

bool madness::FunctionImpl< T, NDIM >::truncate_op	(	const keyT &	key,
		double	tol,
		const std::vector< Future< bool > > &	v
	)

Actually do the truncate operation

Parameters

[in]	key	the key to the current function node being evaluated for truncation
[in]	tol	the tolerance for thresholding
[in]	v	vector of Future<bool>'s that specify whether the current nodes children have coeffs

References madness::FunctionNode< T, NDIM >::clear_coeff(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_children(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::Key< NDIM >::level(), NDIM, madness::GenTensor< T >::normf(), madness::FunctionNode< T, NDIM >::set_coeff(), madness::FunctionNode< T, NDIM >::set_has_children(), and v.

◆ truncate_reconstructed_op()

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::truncate_reconstructed_op	(	const keyT &	key,
		const std::vector< Future< coeffT > > &	v,
		const double	tol
	)

given the sum coefficients of all children, truncate or not

Returns: new sum coefficients (empty if internal, not empty, if new leaf); might delete its children

References madness::Key< NDIM >::level(), MADNESS_ASSERT, and v.

◆ truncate_reconstructed_spawn()

template<typename T , std::size_t NDIM>

Future< typename FunctionImpl< T, NDIM >::coeffT > madness::FunctionImpl< T, NDIM >::truncate_reconstructed_spawn	(	const keyT &	key,
		const double	tol
	)

truncate using a tree in reconstructed form

must be invoked where key is local

References madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionNode< T, NDIM >::has_children(), madness::TaskAttributes::hipri(), MADNESS_ASSERT, NDIM, and v.

◆ truncate_spawn()

template<typename T , std::size_t NDIM>

Future< bool > madness::FunctionImpl< T, NDIM >::truncate_spawn	(	const keyT &	key,
		double	tol
	)

Returns true if after truncation this node has coefficients.

Assumed to be invoked on process owning key. Possible non-blocking communication.

Parameters

[in] key the key of the current function node

References madness::FunctionNode< T, NDIM >::clear_coeff(), madness::FunctionNode< T, NDIM >::coeff(), madness::TaskAttributes::generator(), madness::Future< T >::get(), madness::FunctionNode< T, NDIM >::has_children(), madness::FunctionNode< T, NDIM >::has_coeff(), madness::Key< NDIM >::level(), NDIM, madness::GenTensor< T >::normf(), and v.

◆ truncate_tol()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::truncate_tol	(	double	tol,
		const keyT &	key
	)		const

Returns the truncation threshold according to truncate_method.

here is our handwaving argument: this threshold will give each FunctionNode an error of less than tol. The total error can then be as high as sqrt(#nodes) * tol. Therefore in order to account for higher dimensions: divide tol by about the root of number of siblings (2^NDIM) that have a large error when we refine along a deep branch of the tree.

References madness::FunctionDefaults< NDIM >::get_cell_min_width(), L, madness::Key< NDIM >::level(), MADNESS_EXCEPTION, NDIM, pow(), and truncate_mode.

◆ unary_op_coeff_inplace()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::unary_op_coeff_inplace	(	const opT &	op,
		bool	fence
	)

inline

Unary operation applied inplace to the coefficients WITHOUT refinement, optional fence

Parameters

[in] op the unary operator for the coefficients

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::change_tensor_type(), madness::FunctionNode< T, NDIM >::coeff(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::GenTensor< T >::full_tensor(), madness::World::gop, madness::FunctionNode< T, NDIM >::has_coeff(), op(), madness::FunctionImpl< T, NDIM >::targs, madness::TT_FULL, and madness::FunctionImpl< T, NDIM >::world.

◆ unary_op_node_inplace()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::unary_op_node_inplace	(	const opT &	op,
		bool	fence
	)

inline

Unary operation applied inplace to the coefficients WITHOUT refinement, optional fence

Parameters

[in] op the unary operator for the coefficients

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::World::gop, op(), and madness::FunctionImpl< T, NDIM >::world.

◆ unary_op_value_inplace()

template<typename T , std::size_t NDIM>

template<typename opT >

void madness::FunctionImpl< T, NDIM >::unary_op_value_inplace	(	const opT &	op,
		bool	fence
	)

inline

Unary operation applied inplace to the values with optional refinement and fence

Parameters

[in] op the unary operator for the values

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldGopInterface::fence(), madness::WorldTaskQueue::for_each(), madness::World::gop, op(), madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ unaryXX()

template<typename T , std::size_t NDIM>

template<typename Q , typename opT >

void madness::FunctionImpl< T, NDIM >::unaryXX	(	const FunctionImpl< Q, NDIM > *	func,
		const opT &	op,
		bool	fence
	)

inline

Performs unary operation on function impl. Delegates to the unaryXXa() method

Parameters

[in]	func	function impl of the operand
[in]	op	the unary operator

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::func(), madness::World::gop, op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::FunctionImpl< T, NDIM >::unaryXXa(), and madness::FunctionImpl< T, NDIM >::world.

◆ unaryXXa()

template<typename T , std::size_t NDIM>

template<typename Q , typename opT >

void madness::FunctionImpl< T, NDIM >::unaryXXa	(	const keyT &	key,
		const FunctionImpl< Q, NDIM > *	func,
		const opT &	op
	)

inline

Out of place unary operation on function impl The skeleton algorithm should resemble something like

*this = op(*func)

Parameters

[in]	key	the key of the current function node (box)
[in]	func	the function impl on which to be operated
[in]	op	the unary operator

References madness::FunctionImpl< T, NDIM >::coeffs, madness::func(), op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::BaseTensor::size(), madness::FunctionImpl< T, NDIM >::targs, and madness::WorldObject< FunctionImpl< T, NDIM > >::task().

Referenced by madness::FunctionImpl< T, NDIM >::unaryXX(), and madness::FunctionImpl< T, NDIM >::unaryXXvalues().

◆ unaryXXvalues()

template<typename T , std::size_t NDIM>

template<typename Q , typename opT >

void madness::FunctionImpl< T, NDIM >::unaryXXvalues	(	const FunctionImpl< Q, NDIM > *	func,
		const opT &	op,
		bool	fence
	)

inline

Performs unary operation on function impl. Delegates to the unaryXXa() method

Parameters

[in]	func	function impl of the operand
[in]	op	the unary operator

References madness::FunctionImpl< T, NDIM >::cdata, madness::FunctionImpl< T, NDIM >::coeffs, madness::WorldGopInterface::fence(), madness::func(), madness::World::gop, op(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::World::rank(), madness::FunctionImpl< T, NDIM >::unaryXXa(), and madness::FunctionImpl< T, NDIM >::world.

◆ undo_redundant()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::undo_redundant ( const bool fence )

convert this from redundant to standard reconstructed form

References MADNESS_CHECK_THROW, and madness::reconstructed.

Referenced by madness::partial_mul().

◆ unfilter() [1/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::unfilter ( const coeffT & s ) const

References madness::transform().

◆ unfilter() [2/2]

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::tensorT madness::FunctionImpl< T, NDIM >::unfilter ( const tensorT & s ) const

Transform sums+differences at level n to sum coefficients at level n+1.

Given scaling function and wavelet coefficients (s and d) returns the scaling function coefficients at the next finer level. I.e., reconstruct Vn using Vn = Vn-1 + Wn-1.

s0 = sum(j) h0_ji*s_j + g0_ji*d_j

s1 = sum(j) h1_ji*s_j + g1_ji*d_j

s0

static const double s0

Definition tdse4.cc:83

Returns a new tensor and has no side effects

If (sonly) ... then ss is only the scaling function coeff (and assume the d are zero). Works for any number of dimensions.

No communication involved.

References madness::fast_transform(), and w().

Referenced by madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::inner_adaptive_recursive(), madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map(), and madness::FunctionImpl< T, NDIM >::refine_op().

◆ unset_functor()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::unset_functor ( )

References madness::unknown.

Referenced by madness::FunctionImpl< T, NDIM >::make_Vphi().

◆ upsample()

template<typename T , std::size_t NDIM>

FunctionImpl< T, NDIM >::coeffT madness::FunctionImpl< T, NDIM >::upsample	(	const keyT &	key,
		const coeffT &	coeff
	)		const

upsample the sum coefficients of level 1 to sum coeffs on level n+1

specialization of the unfilter method, will transform only the sum coefficients

Parameters

[in]	key	key of level n+1
[in]	coeff	sum coefficients of level n (does NOT belong to key!!)

Returns: sum coefficients on level n+1

specialization of the unfilter method, will transform only the sum coefficients

Parameters

[in]	key	key of level n+1
[in]	coeff	sum coefficients of level n (does NOT belong to key!!)
[in]	args	TensorArguments for possible low rank approximations

Returns: sum coefficients on level n+1

References madness::general_transform(), h(), NDIM, and madness::Key< NDIM >::translation().

Referenced by madness::Leaf_op< T, NDIM, opT, specialboxT >::compare_to_parent().

◆ values2coeffs() [1/2]

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::values2coeffs	(	const keyT &	key,
		const GenTensor< Q > &	values
	)		const

inline

References madness::FunctionImpl< T, NDIM >::cdata, madness::Key< NDIM >::level(), NDIM, pow(), madness::scale(), and madness::transform().

◆ values2coeffs() [2/2]

template<typename T , std::size_t NDIM>

template<typename Q >

Tensor< Q > madness::FunctionImpl< T, NDIM >::values2coeffs	(	const keyT &	key,
		const Tensor< Q > &	values
	)		const

inline

References madness::FunctionImpl< T, NDIM >::cdata, madness::Key< NDIM >::level(), NDIM, pow(), madness::scale(), and madness::transform().

◆ values2NScoeffs()

template<typename T , std::size_t NDIM>

template<typename Q >

GenTensor< Q > madness::FunctionImpl< T, NDIM >::values2NScoeffs	(	const keyT &	key,
		const GenTensor< Q > &	values
	)		const

inline

convert function values of the a child generation directly to NS coeffs

equivalent to converting the function values to 2^NDIM S coeffs and then filtering them to NS coeffs. Reverse operation to NScoeffs2values().

Parameters

[in]	key	key of the parent of the generation
[in]	values	tensor holding function values of the 2^NDIM children of key

Returns: NS coeffs belonging to key

References madness::FunctionImpl< T, NDIM >::cdata, madness::GenTensor< T >::dim(), madness::inner(), madness::Key< NDIM >::level(), MADNESS_ASSERT, NDIM, pow(), madness::scale(), and madness::transform().

◆ verify_tree()

template<typename T , std::size_t NDIM>

void madness::FunctionImpl< T, NDIM >::verify_tree ( ) const

Verify tree is properly constructed ... global synchronization involved.

If an inconsistency is detected, prints a message describing the error and then throws a madness exception.

This is a reasonably quick and scalable operation that is useful for debugging and paranoia.

References madness::FunctionNode< T, NDIM >::coeff(), madness::GenTensor< T >::dim(), madness::FunctionNode< T, NDIM >::has_children(), madness::GenTensor< T >::has_data(), and PROFILE_MEMBER_FUNC.

◆ vol_nsphere()

template<typename T , std::size_t NDIM>

double madness::FunctionImpl< T, NDIM >::vol_nsphere	(	int	n,
		double	R
	)

inline

References madness::constants::pi, and R.

Referenced by madness::FunctionImpl< T, NDIM >::do_apply().

◆ vtransform()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::vtransform	(	const std::vector< std::shared_ptr< FunctionImpl< R, NDIM > > > &	vright,
		const Tensor< Q > &	c,
		const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > &	vleft,
		double	tol,
		bool	fence
	)

inline

Transforms a vector of functions left[i] = sum[j] right[j]*c[j,i] using sparsity

Parameters

[in]	vright	vector of functions (impl's) on which to be transformed
[in]	c	the tensor (matrix) transformer
[in]	vleft	vector of of the newly transformed functions (impl's)

References madness::_(), madness::WorldTaskQueue::add(), c, madness::copy(), madness::WorldGopInterface::fence(), madness::World::gop, madness::World::taskq, and madness::FunctionImpl< T, NDIM >::world.

◆ vtransform_doit()

template<typename T , std::size_t NDIM>

template<typename Q , typename R >

void madness::FunctionImpl< T, NDIM >::vtransform_doit	(	const std::shared_ptr< FunctionImpl< R, NDIM > > &	right,
		const Tensor< Q > &	c,
		const std::vector< std::shared_ptr< FunctionImpl< T, NDIM > > > &	vleft,
		double	tol
	)