32#ifndef MADNESS_MRA_FUNCIMPL_H__INCLUDED
33#define MADNESS_MRA_FUNCIMPL_H__INCLUDED
55 template <
typename T, std::
size_t NDIM>
58 template<
typename T, std::
size_t NDIM>
61 template<
typename T, std::
size_t NDIM>
64 template<
typename T, std::
size_t NDIM>
67 template<
typename T, std::
size_t NDIM>
68 class FunctionFactory;
70 template<
typename T, std::
size_t NDIM, std::
size_t MDIM>
71 class CompositeFunctorInterface;
82 template<
typename keyT>
96 return key.hash() %
nproc;
101 template <
typename keyT>
112 Level n = key.level();
113 if (n == 0)
return 0;
115 if (n <= 3 || (n&0x1)) hash = key.hash();
116 else hash = key.parent().hash();
123 template<
typename T, std::
size_t NDIM>
174 if (
this != &other) {
285 print(
"set_coeff: may have a problem");
286 print(
"set_coeff: coeff.dim[0] =", coeffs.
dim(0),
", 2* MAXK =", 2*
MAXK);
297 template <
typename Q>
336 }
else if (
coeff().dim(0) == cdata.
vk[0]) {
339 }
else if (
coeff().is_full_tensor()) {
345 }
else if (
coeff().is_svd_tensor()) {
361 template <
typename Q,
typename R>
402 if (
c.is_local(parent))
433 if (
c.is_local(parent))
451 return this->_coeffs.trace_conj((rhs.
_coeffs));
454 template <
typename Archive>
464 s <<
"\"has_coeff\":" << this->
has_coeff()
465 <<
",\"has_children\":" << this->
has_children() <<
",\"norm\":";
472 s <<
norm <<
",\"norm_tree\":" << nt <<
",\"snorm\":"
475 if (this->
coeff().is_assigned())
476 s <<
",\"dim\":" << this->
coeff().
dim(0);
481 template <
typename T, std::
size_t NDIM>
488 if (nt == 1e300) nt = 0.0;
496 template<
typename T,
size_t NDIM>
523 if (key.
level()<2)
return false;
525 std::vector<Slice>
s0(
NDIM/2,s);
527 const double tol=
f->get_thresh();
528 const double thresh=
f->truncate_tol(tol, key)*0.3;
530 const double fnorm=fcoeff.
normf();
531 const double gnorm=gcoeff.
normf();
534 const double norm=fnorm*gnorm;
538 const double sfnorm=fcoeff(
s0).
normf();
539 const double sgnorm=gcoeff(
s0).
normf();
543 const double ferror=sqrt(
std::abs(fnorm*fnorm-sfnorm*sfnorm));
544 const double gerror=sqrt(
std::abs(gnorm*gnorm-sgnorm*sgnorm));
547 const double error=fnorm*gerror + ferror*gnorm + ferror*gerror;
553 template <
typename Archive>
void serialize (Archive& ar) {
560 template<
typename T,
size_t NDIM,
typename opT>
576 if (key.
level()<2)
return false;
577 const double cnorm=coeff.
normf();
583 if (key.
level()<2)
return false;
586 const opkeyT
source=
op->get_source_key(key);
589 const std::vector<opkeyT>& disp =
op->get_disp(key.
level());
590 const opkeyT&
d = *disp.begin();
592 const double norm=opnorm*cnorm;
597 template <
typename Archive>
void serialize (Archive& ar) {
606 template<
typename T,
size_t NDIM,
size_t LDIM,
typename opT>
638 if (key.
level()<2)
return false;
640 const double tol=
f->get_thresh();
641 const double thresh=
f->truncate_tol(tol, key);
643 const double fnorm=fcoeff.
normf();
644 const double gnorm=gcoeff.
normf();
647 const double sfnorm=fcoeff(
g->get_cdata().s0).
normf();
648 const double sgnorm=gcoeff(
g->get_cdata().s0).
normf();
651 const double norm=fnorm*gnorm;
655 const double ferror=sqrt(fnorm*fnorm-sfnorm*sfnorm);
656 const double gerror=sqrt(gnorm*gnorm-sgnorm*sgnorm);
659 const double error=fnorm*gerror + ferror*gnorm + ferror*gerror;
663 const std::vector<Key<NDIM> >& disp =
op->get_disp(key.
level());
665 const double opnorm =
op->norm(key.
level(),
d, key);
666 const double final_norm=opnorm*sfnorm*sgnorm;
667 if (final_norm <
thresh)
return true;
671 template <
typename Archive>
void serialize (Archive& ar) {
676 template<
typename T,
size_t NDIM>
683 template <
typename Archive>
void serialize (Archive& ar) {}
688 template<
typename T, std::
size_t NDIM>
703 template <
typename Archive>
void serialize (Archive& ar) {
712 template<
typename T, std::
size_t NDIM>
723 impl->get_coeffs().task(key, &nodeT::accumulate, coeff,
impl->get_coeffs(), key,
impl->get_tensor_args());
725 template <
typename Archive>
void serialize (Archive& ar) {
738 template<
typename T,
typename R>
740 template <
typename Archive>
void serialize (Archive& ar) {}
745 template<
typename T, std::
size_t NDIM>
754 dnorm(node.get_dnorm()) {}
763 template <
typename Archive>
787 template<
typename T,
size_t NDIM>
912 template <
typename Archive>
void serialize(
const Archive& ar) {
919 template<
typename T, std::
size_t NDIM>
941 template <
typename T, std::
size_t NDIM>
948 typedef std::shared_ptr< FunctionImpl<T,NDIM> >
pimplT;
955 typedef std::pair<const keyT,nodeT>
datumT;
982 std::shared_ptr< FunctionFunctorInterface<T,NDIM> >
functor;
1003 ,
world(factory._world)
1005 ,
thresh(factory._thresh)
1031 bool do_refine = factory.
_refine;
1041 std::vector<coordT> functor_special_points=
functor->special_points();
1042 if (!functor_special_points.empty())
special_points.insert(
special_points.end(), functor_special_points.begin(), functor_special_points.end());
1046 if (it->second.is_leaf())
1067 template <
typename Q>
1099 const std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > >&
get_pmap()
const;
1107 currentmap->redistribute(
world,newmap);
1112 template <
typename Q>
1117 const keyT& key = it->first;
1129 template<
typename Q,
typename R>
1148 template<
typename Q,
typename R>
1160 template<
typename Q,
typename R>
1177 const double beta,
const implT&
g,
const bool fence);
1180 template <
typename Q,
typename R>
1189 const keyT& key = it->first;
1192 f->coeffs.send(key, &nodeT:: template gaxpy_inplace<Q,R>,
alpha, other_node,
beta);
1195 template <
typename Archive>
1205 template <
typename Q,
typename R>
1218 template <
typename Archive>
1236 template <
typename Archive>
1273 std::shared_ptr<FunctionFunctorInterface<T,NDIM> >
get_functor();
1275 std::shared_ptr<FunctionFunctorInterface<T,NDIM> >
get_functor()
const;
1324 void truncate(
double tol,
bool fence);
1361 void print_tree(std::ostream& os = std::cout,
Level maxlevel = 10000)
const;
1394 double val2=log10(val) - log10(
lower());
1396 val2=0.7-(0.7/
upper)*val2;
1397 color= std::max(0.0,val2);
1398 color= std::min(0.7,color);
1400 double hue=0.7-(0.7/
limit)*(val);
1401 color= std::max(0.0,hue);
1428 const int xaxis,
const int yaxis,
const coordT el2);
1450 template<
size_t FDIM>
1451 typename std::enable_if<NDIM==FDIM>::type
1452 read_grid(
const std::string keyfile,
const std::string gridfile,
1455 std::ifstream kfile(keyfile.c_str());
1456 std::ifstream gfile(gridfile.c_str());
1460 if (not (std::getline(kfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of key data",0);
1461 if (not (std::istringstream(line) >> ndata))
MADNESS_EXCEPTION(
"failed reading k",0);
1462 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of grid data",0);
1463 if (not (std::istringstream(line) >> ndata1))
MADNESS_EXCEPTION(
"failed reading k",0);
1465 if (not (std::getline(kfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of key data",0);
1466 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of grid data",0);
1470 const size_t npt = qx.
dim(0);
1473 long npoints=power<NDIM>(npt);
1475 long nboxes=ndata/npoints;
1477 print(
"reading ",nboxes,
"boxes from file",gridfile,keyfile);
1483 std::string gline,kline;
1485 while (std::getline(kfile,kline)) {
1487 double x,y,z,x1,y1,z1,val;
1494 std::stringstream(kline) >> nn >> l1 >> l2 >> l3;
1502 const double h = std::pow(0.5,
double(n));
1509 for (
size_t i=0; i<npt; ++i) {
1510 c[0] = cell(0,0) +
h*cell_width[0]*(l[0] + qx(i));
1511 for (
size_t j=0; j<npt; ++j) {
1512 c[1] = cell(1,0) +
h*cell_width[1]*(l[1] + qx(j));
1513 for (
size_t k=0;
k<npt; ++
k) {
1514 c[2] = cell(2,0) +
h*cell_width[2]*(l[2] + qx(
k));
1516 auto& success1 = std::getline(gfile,gline);
MADNESS_CHECK(success1);
1517 auto& success2 = std::getline(kfile,kline);
MADNESS_CHECK(success2);
1518 std::istringstream(gline) >> x >> y >> z >> val;
1519 std::istringstream(kline) >> x1 >> y1 >> z1;
1528 if (vnuc_functor) val-=(*vnuc_functor)(
c);
1538 const bool has_children=
false;
1540 nodeT node(coeff,has_children);
1557 template<
size_t FDIM>
1558 typename std::enable_if<NDIM==FDIM>::type
1562 std::ifstream gfile(gridfile.c_str());
1566 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of grid data",0);
1567 if (not (std::istringstream(line) >> ndata))
MADNESS_EXCEPTION(
"failed reading k",0);
1568 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of grid data",0);
1572 const size_t npt = qx.
dim(0);
1575 long npoints=power<NDIM>(npt);
1577 long nboxes=ndata/npoints;
1579 print(
"reading ",nboxes,
"boxes from file",gridfile);
1587 while (std::getline(gfile,gline)) {
1589 double x1,y1,z1,val;
1596 std::stringstream(gline) >> nn >> l1 >> l2 >> l3;
1603 const double h = std::pow(0.5,
double(n));
1610 for (
int i=0; i<npt; ++i) {
1611 c[0] = cell(0,0) +
h*cell_width[0]*(l[0] + qx(i));
1612 for (
int j=0; j<npt; ++j) {
1613 c[1] = cell(1,0) +
h*cell_width[1]*(l[1] + qx(j));
1614 for (
int k=0;
k<npt; ++
k) {
1615 c[2] = cell(2,0) +
h*cell_width[2]*(l[2] + qx(
k));
1617 auto& success = std::getline(gfile,gline);
1619 std::istringstream(gline) >> x1 >> y1 >> z1 >> val;
1625 if (vnuc_functor) val-=(*vnuc_functor)(
c);
1635 const bool has_children=
false;
1637 nodeT node(coeff,has_children);
1711 const coeffT& coeff)
const;
1717 template <
typename Q>
1733 template <
typename Q>
1735 const bool s_only)
const {
1769 template <
typename Q>
1787 for (std::size_t
d=0;
d<
NDIM; ++
d) {
1818 template <
typename Q>
1843 template <
typename Q>
1850 template <
typename Q>
1857 template <
typename Q>
1871 template <
typename Q>
1878 MADNESS_EXCEPTION(
"FunctionImpl: fcube_for_mul: child-parent relationship bad?",0);
1882 for (std::size_t
d=0;
d<
NDIM; ++
d) {
1899 template <
typename Q>
1906 MADNESS_EXCEPTION(
"FunctionImpl: fcube_for_mul: child-parent relationship bad?",0);
1910 for (
size_t d=0;
d<
NDIM;
d++) {
1921 template <
typename L,
typename R>
1946 template<
typename R>
1948 const int npt,
const keyT& key)
const {
1955 c11(this->cdata.
s0)=c1;
1956 c22(this->cdata.
s0)=c2;
1968 return copy(result(this->cdata.
s0));
1973 template <
typename L,
typename R,
typename opT>
1984 op(key, tcube, lcube, rcube);
1996 template <
typename L,
typename R>
2006 const keyT& key = it->first;
2008 coeffs.
send(key, &nodeT:: template gaxpy_inplace<T,L>, 1.0, other_node,
alpha);
2014 const keyT& key = it->first;
2016 coeffs.
send(key, &nodeT:: template gaxpy_inplace<T,R>, 1.0, other_node,
beta);
2024 template <
typename opT>
2028 const keyT& parent = it->first;
2029 nodeT& node = it->second;
2045 template <
typename opT>
2049 const keyT& parent = it->first;
2050 nodeT& node = it->second;
2062 template<std::
size_t LDIM>
2077 coeffT g_values =
g->coeffs2values(key,g_coeff);
2080 const long rank=g_values.
rank();
2081 const long maxk=
f->get_k();
2087 tensorT result(maxk,maxk,maxk);
2089 for (
long i=0; i<rank; ++i) {
2093 double singular_value_i = g_values.
get_svdtensor().weights(i);
2094 result += (singular_value_i*c1);
2098 tensorT f_coeff =
f->values2coeffs(key1,result);
2107 template<std::
size_t LDIM>
2112 const keyT& key = it->first;
2120 woT::task(
p, &implT:: template dirac_convolution_op<LDIM>, key, node,
f);
2126 f->trickle_down(
true);
2136 template <
typename opT>
2146 template <
typename opT>
2171 const keyT& key = it->first;
2172 nodeT& node = it->second;
2177 const double error=
d.normf();
2183 template <
typename Archive>
void serialize(
const Archive& ar) {}
2196 nodeT& node = it->second;
2200 template <
typename Archive>
void serialize(
const Archive& ar) {}
2212 nodeT& node = it->second;
2216 template <
typename Archive>
void serialize(
const Archive& ar) {}
2231 nodeT& node = it->second;
2236 template <
typename Archive>
void serialize(
const Archive& ar) {}
2258 nodeT& node = it->second;
2262 template <
typename Archive>
void serialize(
const Archive& ar) {}
2278 if constexpr(
NDIM==6) {
2279 const keyT& key = it->first;
2280 const nodeT& fnode = it->second;
2288 std::vector<long> map(
NDIM);
2289 map[0]=3; map[1]=4; map[2]=5;
2290 map[3]=0; map[4]=1; map[5]=2;
2310 if (have_c1 and have_c2) {
2314 norm=(c1-c2).normf();
2315 }
else if (have_c1) {
2318 }
else if (have_c2) {
2338 template <
typename Archive>
void serialize(
const Archive& ar) {
2350 template<
typename Q,
typename R>
2362 const keyT& key = it->first;
2363 const nodeT& node = it->second;
2369 template <
typename Archive>
void serialize(
const Archive& ar) {
2379 template<
typename Q,
typename R>
2392 const keyT& key = it->first;
2393 const nodeT& fnode = it->second;
2399 nodeT& gnode=acc->second;
2409 template <
typename Archive>
void serialize(
const Archive& ar) {
2427 const keyT& key = it->first;
2428 const nodeT& node = it->second;
2439 template <
typename Archive>
void serialize(
const Archive& ar) {
2457 const keyT& key = it->first;
2458 const nodeT& node = it->second;
2463 for (std::size_t i=0; i<
NDIM; ++i) {
2470 std::vector<Slice> s(
___);
2473 for (
size_t i=0; i<
NDIM; ++i) {
2474 std::size_t
kmax=
c.dim(i);
2476 for (
size_t k=1;
k<
kmax;
k+=2) {
2489 template <
typename Archive>
void serialize(
const Archive& ar) {
2508 const keyT& key = it->first;
2509 const nodeT& node = it->second;
2517 for (std::size_t i=0; i<
NDIM; ++i) l1[
map[i]] = l[i];
2526 for (std::size_t i=0; i<
NDIM; ++i) {
2527 if (
mirror[i]==-1) l1[i]= lmax - l[i];
2533 std::vector<Slice> s(
___);
2536 for (
size_t i=0; i<
NDIM; ++i) {
2537 std::size_t
kmax=
c.dim(i);
2539 for (
size_t k=1;
k<
kmax;
k+=2) {
2553 template <
typename Archive>
void serialize(
const Archive& ar) {
2573 const keyT& key = it->first;
2574 const nodeT& fnode = it->second;
2582 nodeT& gnode=acc->second;
2591 template <
typename Archive>
void serialize(
const Archive& ar) {}
2611 nodeT& node = it->second;
2619 template <
typename Archive>
void serialize(
const Archive& ar) {}
2632 it->second.consolidate_buffer(
targs);
2635 template <
typename Archive>
void serialize(
const Archive& ar) {}
2640 template <
typename opT>
2647 const keyT& key = it->first;
2648 nodeT& node = it->second;
2664 template <
typename Archive>
void serialize(
const Archive& ar) {}
2667 template <
typename Q,
typename R>
2675 std::vector<unsigned int> ind(vleft.size());
2676 for (
unsigned int i=0; i<vleft.size(); ++i) {
2679 for (
unsigned int i=0; i<vleft.size(); ++i) {
2681 std::swap(ind[i],ind[j]);
2686 if (it->second.has_coeff()) {
2692 for (
unsigned int j=0; j<vleft.size(); ++j) {
2693 unsigned int i = ind[j];
2695 implT* left = vleft[i].get();
2698 if (newnode && key.
level()>0) {
2706 nodeT& node = acc->second;
2723 const std::vector<tensorT>&
c,
2730 template <
typename opT>
2732 std::vector<tensorT>
c(
v.size());
2733 for (
unsigned int i=0; i<
v.size(); i++) {
2736 c[i]=
cc.full_tensor();
2747 template <
typename opT>
2750 for (std::size_t i=1; i<
v.size(); ++i) {
2751 if (
v[i] and
v[i-1]) {
2757 const keyT& key = it->first;
2758 if (it->second.has_coeff())
2759 world.
taskq.
add(*
this, &implT:: template multiop_values_doit<opT>, key,
op,
v);
2772 template <
typename opT>
2774 const std::vector<implT*>& vin, std::vector<implT*>& vout) {
2775 std::vector<tensorT>
c(vin.size());
2776 for (
unsigned int i=0; i<vin.size(); i++) {
2779 c[i]=
cc.full_tensor();
2782 std::vector<tensorT> r =
op(key,
c);
2784 for (std::size_t i=0; i<vout.size(); ++i) {
2795 template <
typename opT>
2797 std::vector<implT*>& vout,
const bool fence=
true) {
2799 for (std::size_t i=1; i<vin.size(); ++i) {
2800 if (vin[i] and vin[i-1]) {
2806 const keyT& key = it->first;
2807 if (it->second.has_coeff())
2808 world.
taskq.
add(*
this, &implT:: template multi_to_multi_op_values_doit<opT>,
2809 key,
op, vin, vout);
2812 for (
implT* it2 : vout) {
2824 template <
typename Q,
typename R>
2830 for (
unsigned int j=0; j<vright.size(); ++j) {
2831 world.
taskq.
add(*
this, &implT:: template vtransform_doit<Q,R>, vright[j],
copy(
c(j,
_)), vleft, tol);
2839 template <
typename opT>
2859 template <
typename L,
typename R>
2869 double lnorm = 1e99;
2871 if (lc.
size() == 0) {
2874 lnorm = it->second.get_norm_tree();
2875 if (it->second.has_coeff())
2876 lc = it->second.coeff().full_tensor_copy();
2880 std::vector<FunctionImpl<T,NDIM>*> vresult;
2881 std::vector<const FunctionImpl<R,NDIM>*> vright;
2882 std::vector< Tensor<R> > vrc;
2883 vresult.reserve(vrightin.size());
2884 vright.reserve(vrightin.size());
2885 vrc.reserve(vrightin.size());
2887 for (
unsigned int i=0; i<vrightin.size(); ++i) {
2892 if (rc.
size() == 0) {
2895 rnorm = it->second.get_norm_tree();
2896 if (it->second.has_coeff())
2897 rc = it->second.coeff().full_tensor_copy();
2904 result->
task(
world.
rank(), &implT:: template do_mul<L,R>, key, lc, std::make_pair(key,rc));
2906 else if (tol && lnorm*rnorm <
truncate_tol(tol, key)) {
2911 vresult.push_back(result);
2912 vright.push_back(right);
2917 if (vresult.size()) {
2925 std::vector< Tensor<R> > vrss(vresult.size());
2926 for (
unsigned int i=0; i<vresult.size(); ++i) {
2927 if (vrc[i].
size()) {
2930 vrss[i] = vright[i]->unfilter(rd);
2935 const keyT& child = kit.key();
2943 std::vector< Tensor<R> > vv(vresult.size());
2944 for (
unsigned int i=0; i<vresult.size(); ++i) {
2946 vv[i] =
copy(vrss[i](cp));
2949 woT::task(
coeffs.
owner(child), &implT:: template mulXXveca<L,R>, child, left, ll, vright, vv, vresult, tol);
2963 template <
typename L,
typename R>
2971 double lnorm=1e99, rnorm=1e99;
2974 if (lc.
size() == 0) {
2977 lnorm = it->second.get_norm_tree();
2978 if (it->second.has_coeff())
2979 lc = it->second.coeff().reconstruct_tensor();
2983 if (rc.
size() == 0) {
2986 rnorm = it->second.get_norm_tree();
2987 if (it->second.has_coeff())
2988 rc = it->second.coeff().reconstruct_tensor();
2993 do_mul<L,R>(key, lc, std::make_pair(key,rc));
3026 const keyT& child = kit.key();
3034 woT::task(
coeffs.
owner(child), &implT:: template mulXXa<L,R>, child, left, ll, right, rr, tol);
3049 template <
typename L,
typename R,
typename opT>
3058 if (lc.
size() == 0) {
3061 if (it->second.has_coeff())
3062 lc = it->second.coeff().reconstruct_tensor();
3066 if (rc.
size() == 0) {
3069 if (it->second.has_coeff())
3070 rc = it->second.coeff().reconstruct_tensor();
3074 do_binary_op<L,R>(key, lc, std::make_pair(key,rc),
op);
3096 const keyT& child = kit.key();
3108 template <
typename Q,
typename opT>
3127 template <
typename Archive>
3141 template <
typename Q,
typename opT>
3146 const Tensor<Q> fc =
func->coeffs.find(key).get()->second.coeff().reconstruct_tensor();
3148 if (fc.
size() == 0) {
3152 const keyT& child = kit.key();
3166 template <
typename L,
typename R>
3180 template <
typename L,
typename R,
typename opT>
3182 const opT&
op,
bool fence) {
3194 template <
typename Q,
typename opT>
3207 template <
typename Q,
typename opT>
3223 template <
typename L,
typename R>
3229 std::vector< Tensor<R> > vr(vright.size());
3285 const coordT& plotlo,
const coordT& plothi,
const std::vector<long>& npt,
3286 bool eval_refine)
const;
3296 const std::vector<long>& npt,
3297 const bool eval_refine =
false)
const;
3384 template<
size_t LDIM>
3411 double glo=0.0, ghi=0.0, flo=0.0, fhi=0.0;
3415 double total_hi=glo*fhi + ghi*flo + fhi*ghi;
3435 coeffT coeff1=
f.get_impl()->parent_to_child(
f.coeff(),
f.key(),key);
3443 bool is_leaf=
screen(coeff1_2D,coeff2,key);
3444 if (key.
level()<2) is_leaf=
false;
3450 coeffT hvalues=
f.get_impl()->coeffs2values(key,coeff1_2D);
3463 return std::pair<bool,coeffT> (is_leaf,hcoeff);
3487 template <
typename Archive>
void serialize(
const Archive& ar) {
3513 bool is_leaf=(
f.is_leaf() and
g.is_leaf());
3514 if (not is_leaf)
return std::pair<bool,coeffT> (is_leaf,
coeffT());
3516 coeffT fcoeff=
f.get_impl()->parent_to_child(
f.coeff(),
f.key(),key);
3517 coeffT gcoeff=
g.get_impl()->parent_to_child(
g.coeff(),
g.key(),key);
3520 hcoeff.
reduce_rank(
f.get_impl()->get_tensor_args().thresh);
3521 return std::pair<bool,coeffT> (is_leaf,hcoeff);
3541 template <
typename Archive>
void serialize(
const Archive& ar) {
3554 template<
size_t LDIM>
3561 coeff_opT coeff_op(
this,ff,gg,
particle);
3564 apply_opT apply_op(
this);
3569 woT::task(
p, &implT:: template forward_traverse<coeff_opT,apply_opT>, coeff_op, apply_op,
key0);
3576 template<
size_t LDIM,
typename leaf_opT>
3604 if (not is_leaf)
return std::pair<bool,coeffT> (is_leaf,
coeffT());
3614 return std::pair<bool,coeffT>(is_leaf,coeff);
3637 template <
typename Archive>
void serialize(
const Archive& ar) {
3648 template<
typename coeff_opT,
typename apply_opT>
3652 woT::task(
world.
rank(), &implT:: template traverse_tree<coeff_opT,apply_opT>, active_coeff, apply_op, key);
3662 template<
typename coeff_opT,
typename apply_opT>
3666 typedef typename std::pair<bool,coeffT> argT;
3667 const argT
arg=coeff_op(key);
3668 apply_op.operator()(key,
arg.second,
arg.first);
3670 const bool has_children=(not
arg.first);
3673 const keyT& child=kit.key();
3674 coeff_opT child_op=coeff_op.make_child(child);
3678 void (
implT::*ft)(
const coeff_opT&,
const apply_opT&,
const keyT&)
const = &implT::forward_traverse<coeff_opT,apply_opT>;
3692 template<std::
size_t LDIM,
typename leaf_opT>
3695 const leaf_opT&
leaf_op,
bool fence) {
3696 MADNESS_CHECK_THROW(p1.size()==p2.size(),
"hartree_product: p1 and p2 must have the same size");
3697 for (
auto&
p : p1)
MADNESS_CHECK(
p->is_nonstandard() or
p->is_nonstandard_with_leaves());
3698 for (
auto&
p : p2)
MADNESS_CHECK(
p->is_nonstandard() or
p->is_nonstandard_with_leaves());
3702 for (std::size_t i=0; i<p1.size(); ++i) {
3711 coeff_opT coeff_op(
this,iap1,iap2,
leaf_op);
3716 apply_opT apply_op(
this);
3719 coeff_op, apply_op,
cdata.key0);
3729 template <
typename opT,
typename R>
3734 const double cnorm =
c.normf();
3743 int maxdir = s ? 1 : -1;
3744 for (
int direction=-1; direction<=maxdir; direction+=2) {
3745 lnew[
axis] = lold + direction*s;
3746 if (lnew[
axis] >= 0 && lnew[
axis] < maxs) {
3748 double Rnorm = r.
normf();
3754 if (s <= 1 || r.
normf()*cnorm > tol) {
3758 if (result.
normf() > tol*0.3) {
3780 template <
typename opT,
typename R>
3787 fiterT end =
f->coeffs.end();
3789 for (fiterT it=
f->coeffs.begin(); it!=end; ++it) {
3790 const fnodeT& node = it->second;
3791 if (node.has_coeff()) {
3792 const keyT& key = it->first;
3793 const Tensor<R>&
c = node.coeff().full_tensor_copy();
3794 woT::task(
me, &implT:: template apply_1d_realspace_push_op<opT,R>,
3804 const std::pair<keyT,coeffT>& left,
3805 const std::pair<keyT,coeffT>& center,
3806 const std::pair<keyT,coeffT>& right);
3811 const std::pair<keyT,coeffT>& left,
3812 const std::pair<keyT,coeffT>& center,
3813 const std::pair<keyT,coeffT>& right);
3857 template<std::
size_t LDIM>
3883 bool use_tnorm=
false;
3888 tensorT val_rhs=fcf.coeffs2values(key, coeff_rhs);
3890 return fcf.values2coeffs(key,val_rhs);
3899 coeff1(
cdata.s0)=coeff_rhs;
3903 tensorT coeff_lhs_k1(cdata_npt.vk);
3908 val_lhs_k1.
emul(val_rhs_k1);
3915 result1(
cdata.s0)=0.0;
3925 const long k=coeff_rhs.
dim(0);
3939 coeff_rhs_npt1(fcf_lo.
cdata.s0)=coeff_rhs;
3953 val_lhs_npt.
emul(val_rhs);
3960 result1(
cdata.s0)=0.0;
3965 template <
typename Archive>
void serialize(
const Archive& ar) {
3978 template<
typename opT,
size_t LDIM>
4019 if(
leaf_op.do_pre_screening()){
4021 if(
leaf_op.pre_screening(key)){
4025 return std::pair<bool,coeffT> (
true,
coeffT());
4036 if(key.
level()<
int(il)){
4048 if(
leaf_op.post_screening(key,sum_coeff)){
4050 return std::pair<bool,coeffT> (
true,
coeffT());
4056 return std::pair<bool,coeffT> (
true,
coeffT());
4060 std::vector<bool> child_is_leaf(1<<
NDIM,
false);
4075 keyT child=kit.key();
4076 bool is_leaf=child_is_leaf[i];
4094 return std::pair<bool,coeffT> (
true,
coeffT());
4124 double dnorm_ket, snorm_ket;
4126 snorm_ket=
iaket.coeff(key).normf();
4127 dnorm_ket=
iaket.dnorm(key);
4134 dnorm_ket=s1*d2 + s2*d1 + d1*d2;
4140 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4145 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4149 double snorm=s_coeffs.
normf();
4152 double dnorm=
d.normf();
4153 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4185 double error=refine_error;
4213 return std::make_pair(cresult,
error);
4235 iaket1,iap11,iap21,iav11,iav21,
eri);
4239 const ctL& iap11,
const ctL& iap21,
const ctL& iav11,
const ctL& iav21,
4240 const implT* eri1) {
4245 template <
typename Archive>
void serialize(
const Archive& ar) {
4257 template<
typename opT>
4260 constexpr size_t LDIM=
NDIM/2;
4267 std::shared_ptr< FunctionFunctorInterface<T,NDIM> > func2(this->
get_functor());
4275 if (fence)
func->make_redundant(
true);
4279 for (
auto& ket :
func->impl_ket_vector) {
4288 for (std::size_t i=0; i<
func->impl_p1_vector.size(); ++i) {
4318 template<
typename opT, std::
size_t LDIM>
4323 const bool fence=
true) {
4334 coeff_opT coeff_op(
this,
leaf_op,iaket,iap1,iap2,iav1,iav2,eri);
4342 coeff_op, apply_op,
cdata.key0);
4351 void mapdim(
const implT&
f,
const std::vector<long>& map,
bool fence);
4361 const std::vector<long>&
mirror,
bool fence);
4394 auto& node=it->second;
4395 node.recompute_snorm_and_dnorm(
cdata);
4465 template <
typename opT>
4472 nodeT& node = acc->second;
4480 const keyT& child = kit.key();
4490 template <
typename opT>
4503 template <
typename opT>
4516 void broaden_op(
const keyT& key,
const std::vector< Future <bool> >&
v);
4522 void broaden(std::vector<bool> is_periodic,
bool fence);
4620 const keyT& key = it->first;
4621 nodeT& node = it->second;
4635 template <
typename Archive>
void serialize(
const Archive& ar) {
4642 template<
size_t OPDIM>
4651 template <
class Archive>
4662 template <
typename opT,
typename R,
size_t OPDIM>
4690 template <
typename opT,
typename R,
size_t OPDIM>
4728 template <
typename opT,
typename R,
size_t OPDIM>
4733 if (2*OPDIM==
NDIM) result=
op->apply2_lowdim(args.
key, args.
d, coeff,
4735 if (OPDIM==
NDIM) result =
op->apply2(args.
key, args.
d, coeff,
4738 const double result_norm=result.
svd_normf();
4740 if (result_norm> 0.3*args.
tol/args.
fac) {
4770 template <
typename opT,
typename R>
4782 typedef typename opT::keyT opkeyT;
4783 static const size_t opdim=opT::opdim;
4784 const opkeyT
source=
op->get_source_key(key);
4803 double radius = 1.5 + 0.33*std::max(0.0,2-std::log10(
thresh)-
k);
4807 double cnorm =
c.normf();
4809 const std::vector<opkeyT>& disp =
op->get_disp(key.
level());
4810 const std::vector<bool> is_periodic(
NDIM,
false);
4813 uint64_t distsq = 99999999999999;
4814 for (
typename std::vector<opkeyT>::const_iterator it=disp.begin(); it != disp.end(); ++it) {
4817 if (
op->particle()==1)
d=it->merge_with(nullkey);
4818 if (
op->particle()==2)
d=nullkey.merge_with(*it);
4820 uint64_t dsq =
d.distsq();
4821 if (dsq != distsq) {
4822 if (nvalid > 0 && nused == 0 && dsq > 1) {
4840 if (cnorm*opnorm> tol/fac) {
4843 if (result.
normf() > 0.3*tol/fac) {
4856 template <
typename opT,
typename R>
4863 const keyT& key = it->first;
4893 template <
typename opT,
typename R>
4895 const bool& do_kernel) {
4898 typedef typename opT::keyT opkeyT;
4901 std::list<opkeyT> blacklist;
4903 static const size_t opdim=opT::opdim;
4907 const opkeyT
source=
op->get_source_key(key);
4912 double fac=std::pow(3,
NDIM*0.5);
4913 double cnorm = coeff.
normf();
4917 apply_targs.
thresh=tol/fac*0.03;
4927#ifdef HAVE_GENTENSOR
4931 const std::vector<opkeyT>& disp =
op->get_disp(key.
level());
4932 const std::vector<bool> is_periodic(
NDIM,
false);
4934 for (
typename std::vector<opkeyT>::const_iterator it=disp.begin(); it != disp.end(); ++it) {
4935 const opkeyT&
d = *it;
4937 const int shell=
d.distsq();
4938 if (do_kernel and (shell>0))
break;
4939 if ((not do_kernel) and (shell==0))
continue;
4943 else if (
op->particle()==2) disp1=nullkey.
merge_with(*it);
4955 bool screened=
false;
4956 typename std::list<opkeyT>::const_iterator it2;
4957 for (it2=blacklist.begin(); it2!=blacklist.end(); it2++) {
4958 if (
d.is_farther_out_than(*it2)) {
4968 if (cnorm*opnorm> tol/fac) {
4970 double cost_ratio=
op->estimate_costs(
source,
d, coeff_SVD, tol/fac/cnorm, tol/fac);
4974 if (cost_ratio>0.0) {
4978 if (cost_ratio<1.0) {
4982 if (2*opdim==
NDIM) {
4988 maxnorm=std::max(
norm,maxnorm);
4991 }
else if (shell >= 12) {
4994 if (
norm<0.3*tol/fac) blacklist.push_back(
d);
5002 template <
typename opT,
typename R>
5011 const keyT& key = it->first;
5012 const coeffT& coeff = it->second.coeff();
5016 woT::task(
p, &implT:: template do_apply_directed_screening<opT,R>, &
op, key, coeff,
true);
5017 woT::task(
p, &implT:: template do_apply_directed_screening<opT,R>, &
op, key, coeff,
false);
5043 template<
typename opT, std::
size_t LDIM>
5056 coeff_opT coeff_op(
this,ff,gg,&apply_op);
5062 woT::task(
p, &implT:: template forward_traverse<coeff_opT,apply_opT>, coeff_op, apply_op,
key0);
5070 template<
typename opT, std::
size_t LDIM>
5111 bool is_leaf=
leaf_op(key,fcoeff,gcoeff);
5125 result->
task(
p,&implT:: template do_apply_directed_screening<opT,T>,
5131 return std::pair<bool,coeffT> (is_leaf,
coeffT());
5137 const coeffT& coeff)
const {
5140 if (key.
level()<2) is_leaf=
false;
5141 return std::pair<bool,coeffT> (is_leaf,coeff);
5162 const opT* apply_op1) {
5166 template <
typename Archive>
void serialize(
const Archive& ar) {
5177 template<
typename opT>
5187 coeff_opT coeff_op(
this,fimpl,&apply_op);
5193 coeff_op, apply_op,
cdata.key0);
5201 template<
typename opT>
5207 typedef std::pair<bool,coeffT>
argT;
5235 result->
task(
p,&implT:: template do_apply_directed_screening<opT,T>,
5241 if (
iaf.is_leaf())
return argT(
true,coeff);
5245 const bool is_leaf=
true;
5255 if (key.
level()<2) is_leaf=
false;
5256 return argT(is_leaf,coeff);
5278 return this_type(result1,iaf1,apply_op1);
5281 template <
typename Archive>
void serialize(
const Archive& ar) {
5290 template <
typename opT>
5295 std::vector<long> vq(
NDIM);
5296 for (std::size_t i=0; i<
NDIM; ++i)
5298 tensorT fval(vq,
false), work(vq,
false), result(vq,
false);
5316 double err = fval.normf();
5320 template <
typename opT>
5339 const keyT& key = it->first;
5340 const nodeT& node = it->second;
5351 template <
typename Archive>
5358 template <
typename opT>
5362 const int npt =
cdata.npt + 1;
5377 const nodeT& node = it->second;
5391 template <
typename Archive>
void serialize(
const Archive& ar) {
5401 template<
typename R>
5412 const keyT& key=it->first;
5413 const nodeT& fnode = it->second;
5420 MADNESS_EXCEPTION(
"functions have different k or compress/reconstruct error", 0);
5439 template <
typename Archive>
void serialize(
const Archive& ar) {
5447 template <
typename R>
5462 template<
typename R>
5474 constexpr std::size_t LDIM=std::max(
NDIM/2,std::size_t(1));
5476 const keyT& key=it->first;
5477 const nodeT& fnode = it->second;
5478 if (not fnode.
has_coeff())
return resultT(0.0);
5481 auto find_valid_parent = [](
auto& key,
auto& impl,
auto&& find_valid_parent) {
5482 MADNESS_CHECK(impl->get_coeffs().owner(key)==impl->world.rank());
5483 if (impl->get_coeffs().probe(key))
return key;
5484 auto parentkey=key.
parent();
5485 return find_valid_parent(parentkey, impl, find_valid_parent);
5489 auto get_coeff = [&find_valid_parent](
const auto& key,
const auto& v_impl) {
5490 if ((v_impl.size()>0) and v_impl.front().get()) {
5491 auto impl=v_impl.front();
5495 auto parentkey = find_valid_parent(key, impl, find_valid_parent);
5497 typename decltype(impl->coeffs)::accessor acc;
5498 impl->get_coeffs().find(acc,parentkey);
5499 auto parentcoeff=acc->second.coeff();
5500 auto coeff=impl->parent_to_child(parentcoeff, parentkey, key);
5504 typedef typename std::decay_t<
decltype(v_impl)>::value_type::element_type::typeT S;
5511 auto make_vector = [](
auto&
arg) {
5512 return std::vector<std::decay_t<
decltype(
arg)>>(1,
arg);
5523 "only one ket function supported in inner_on_demand");
5525 "only one p1 function supported in inner_on_demand");
5527 "only one p2 function supported in inner_on_demand");
5528 auto coeff_bra=fnode.
coeff();
5529 auto coeff_ket=get_coeff(key,
func->impl_ket_vector);
5530 auto coeff_v1=get_coeff(key1,make_vector(
func->impl_m1));
5531 auto coeff_v2=get_coeff(key2,make_vector(
func->impl_m2));
5532 auto coeff_p1=get_coeff(key1,
func->impl_p1_vector);
5533 auto coeff_p2=get_coeff(key2,
func->impl_p2_vector);
5537 if (coeff_ket.has_data() and coeff_p1.has_data()) {
5541 }
else if (coeff_ket.has_data() or coeff_p1.has_data()) {
5542 coeff_ket = (coeff_ket.has_data()) ? coeff_ket :
outer(coeff_p1,coeff_p2);
5549 if (coeff_v1.has_data()) {
5551 v1v2ket = pm(key,coeff_v1.full_tensor(), 1);
5553 v1v2ket+= pm(key,coeff_v2.full_tensor(), 2);
5556 v1v2ket = coeff_ket;
5560 if (
func->impl_eri) {
5564 tensorT braket=pm(key,coeff_bra.full_tensor_copy().conj());
5570 result=coeff_bra.full_tensor_copy().trace_conj(v1v2ket.
full_tensor_copy());
5579 template <
typename Archive>
void serialize(
const Archive& ar) {
5587 template <
typename R>
5599 typedef std::vector< std::pair<int,const coeffT*> >
mapvecT;
5608 typename mapT::accessor acc;
5609 const keyT& key = it->first;
5612 [[maybe_unused]]
auto inserted = map->insert(acc,key);
5613 acc->second.push_back(std::make_pair(index,&(node.
coeff())));
5626 for (
unsigned int i=0; i<
v.size(); i++) {
5630 if (
v.size())
v[0]->world.taskq.fence();
5636 template <
typename R>
5638 const typename mapT::iterator lend,
5645 for (
typename mapT::iterator lit=lstart; lit!=lend; ++lit) {
5646 const keyT& key = lit->first;
5648 if (rit != rmap_ptr->end()) {
5649 const mapvecT& leftv = lit->second;
5651 const int nleft = leftv.
size();
5652 const int nright= rightv.
size();
5654 for (
int iv=0; iv<nleft; iv++) {
5655 const int i = leftv[iv].first;
5658 for (
int jv=0; jv<nright; jv++) {
5659 const int j = rightv[jv].first;
5662 if (!sym || (sym && i<=j))
5663 r(i,j) += iptr->trace_conj(*jptr);
5673 template <
typename R>
5675 const typename mapT::iterator lend,
5682 for (
typename mapT::iterator lit=lstart; lit!=lend; ++lit) {
5683 const keyT& key = lit->first;
5685 if (rit != rmap_ptr->end()) {
5686 const mapvecT& leftv = lit->second;
5688 const size_t nleft = leftv.
size();
5689 const size_t nright= rightv.
size();
5691 unsigned int size = leftv[0].second->size();
5695 for(
unsigned int iv = 0; iv < nleft; ++iv) Left(iv,
_) = *(leftv[iv].second);
5696 for(
unsigned int jv = 0; jv < nright; ++jv) Right(jv,
_) = *(rightv[jv].second);
5701 for(
unsigned int iv = 0; iv < nleft; ++iv) {
5702 const int i = leftv[iv].first;
5703 for(
unsigned int jv = 0; jv < nright; ++jv) {
5704 const int j = rightv[jv].first;
5705 if (!sym || (sym && i<=j)) result(i,j) += r(iv,jv);
5716 template <
typename R>
5717 static void do_dot_localX(
const typename mapT::iterator lstart,
5718 const typename mapT::iterator lend,
5725 for (
typename mapT::iterator lit = lstart; lit != lend; ++lit) {
5726 const keyT& key = lit->first;
5728 if (rit != rmap_ptr->end()) {
5729 const mapvecT& leftv = lit->second;
5731 const int nleft = leftv.
size();
5732 const int nright = rightv.
size();
5734 for (
int iv = 0; iv < nleft; iv++) {
5735 const int i = leftv[iv].first;
5738 for (
int jv = 0; jv < nright; jv++) {
5739 const int j = rightv[jv].first;
5742 if (!sym || (sym && i <= j))
5743 r(i, j) += iptr->
trace(*jptr);
5753 template <
typename R>
5755 const typename mapT::iterator lend,
5762 for (
typename mapT::iterator lit = lstart; lit != lend; ++lit) {
5763 const keyT& key = lit->first;
5765 if (rit != rmap_ptr->end()) {
5766 const mapvecT& leftv = lit->second;
5768 const size_t nleft = leftv.
size();
5769 const size_t nright= rightv.
size();
5771 unsigned int size = leftv[0].second->size();
5775 for(
unsigned int iv = 0; iv < nleft; ++iv) Left(iv,
_) = *(leftv[iv].second);
5776 for(
unsigned int jv = 0; jv < nright; ++jv) Right(jv,
_) = *(rightv[jv].second);
5780 for(
unsigned int iv = 0; iv < nleft; ++iv) {
5781 const int i = leftv[iv].first;
5782 for(
unsigned int jv = 0; jv < nright; ++jv) {
5783 const int j = rightv[jv].first;
5784 if (!sym || (sym && i <= j)) result(i, j) += r(iv, jv);
5797 static std::complex<double>
conj(
const std::complex<double> x) {
5798 return std::conj(x);
5801 template <
typename R>
5827 size_t chunk = (lmap.size()-1)/(3*4*5)+1;
5832 typename mapT::iterator lstart=lmap.begin();
5833 while (lstart != lmap.end()) {
5834 typename mapT::iterator lend = lstart;
5835 advance(lend,chunk);
5839 left[0]->world.taskq.fence();
5842 for (
long i=0; i<r.
dim(0); i++) {
5843 for (
long j=0; j<i; j++) {
5853 template <
typename R>
5879 size_t chunk = (lmap.size() - 1) / (3 * 4 * 5) + 1;
5884 typename mapT::iterator lstart=lmap.begin();
5885 while (lstart != lmap.end()) {
5886 typename mapT::iterator lend = lstart;
5887 advance(lend, chunk);
5891 left[0]->world.taskq.fence();
5895 for (
long i = 0; i < r.
dim(0); i++) {
5896 for (
long j = 0; j < i; j++) {
5906 template <
typename R>
5909 static_assert(!std::is_same<R, int>::value &&
5910 std::is_same<R, int>::value,
5911 "Compilation failed because you wanted to know the type; see below:");
5921 template<
typename Q, std::size_t LDIM,
typename R, std::size_t KDIM,
5922 std::size_t CDIM = (KDIM + LDIM -
NDIM) / 2>
5924 const std::array<int, CDIM> v1,
const std::array<int, CDIM> v2) {
5926 typedef std::multimap<Key<NDIM>, std::list<Key<CDIM>>> contractionmapT;
5940 std::list<contractionmapT> all_contraction_maps;
5941 for (std::size_t n=0; n<nmax; ++n) {
5946 auto [h_ijlist, h_jlist] =
h.get_contraction_node_lists(n, v2);
5947 if ((g_ijlist.size() == 0) and (h_ijlist.size() == 0))
break;
5957 bool this_first =
true;
5961 h_ijlist, h_jlist, this_first,
thresh);
5967 h_nc.
key0(), hnode0, v2, v1,
5968 g_ijlist, g_jlist, this_first,
thresh);
5971 contraction_map.merge(contraction_map1);
5973 auto it = contraction_map.begin();
5974 while (it != contraction_map.end()) {
5975 auto it_end = contraction_map.upper_bound(it->first);
5978 while (it2 != it_end) {
5979 it->second.splice(it->second.end(), it2->second);
5980 it2 = contraction_map.erase(it2);
5988 for (
auto& elem: contraction_map) {
5990 elem.second.unique();
5998 all_contraction_maps.push_back(contraction_map);
6000 long mapsize=contraction_map.
size();
6001 if (mapsize==0)
break;
6006 for (
const auto& contraction_map : all_contraction_maps) {
6007 for (
const auto& key_list : contraction_map) {
6009 const std::list<Key<CDIM>>& list=key_list.second;
6011 &
g,&
h,v1,v2,key,list);
6023 template<std::
size_t CDIM>
6024 std::tuple<std::set<Key<NDIM>>, std::map<Key<CDIM>,
double>>
6028 auto has_d_coeffs = [&
cdata](
const coeffT& coeff) {
6029 if (coeff.has_no_data())
return false;
6030 return (coeff.dim(0)==2*
cdata.k);
6034 std::set<Key<NDIM>> ij_list;
6035 std::map<Key<CDIM>,
double> j_list;
6040 if ((key.
level()==n) and (has_d_coeffs(node.
coeff()))) {
6041 ij_list.insert(key);
6043 for (std::size_t i=0; i<CDIM; ++i) j_trans[i]=key.
translation()[
v[i]];
6045 const double max_d_norm=j_list[jkey];
6046 j_list.insert_or_assign(jkey,std::max(max_d_norm,node.
get_dnorm()));
6048 while (j_list.count(parent_jkey)==0) {
6049 j_list.insert({parent_jkey,1.0});
6050 parent_jkey=parent_jkey.
parent();
6054 return std::make_tuple(ij_list,j_list);
6077 template<std::size_t CDIM, std::size_t ODIM, std::size_t FDIM=
NDIM+ODIM-2*CDIM>
6080 const std::array<int,CDIM>& v_this,
6081 const std::array<int,CDIM>& v_other,
6082 const std::set<
Key<ODIM>>& ij_other_list,
6083 const std::map<
Key<CDIM>,
double>& j_other_list,
6084 bool this_first,
const double thresh) {
6086 std::multimap<Key<FDIM>, std::list<Key<CDIM>>> contraction_map;
6089 if (j_other_list.empty())
return contraction_map;
6096 const double max_d_norm=j_other_list.find(j_this_key)->second;
6102 bool final_scale=key.
level()==ij_other_list.begin()->level();
6103 if (final_scale and sd_norm_product_large) {
6104 for (
auto& other_key : ij_other_list) {
6105 const auto j_other_key=other_key.extract_key(v_other);
6106 if (j_this_key != j_other_key)
continue;
6108 auto k_key=other_key.extract_complement_key(v_other);
6114 contraction_map.insert(std::make_pair(ik_key,std::list<
Key<CDIM>>{j_this_key}));
6116 return contraction_map;
6119 bool continue_recursion = (j_other_list.count(j_this_key)==1);
6120 if (not continue_recursion)
return contraction_map;
6124 continue_recursion = (node.
has_children() or sd_norm_product_large);
6126 if (continue_recursion) {
6128 bool compute_child_s_coeffs=
true;
6133 keyT child=kit.key();
6138 bool need_s_coeffs= childnode_exists ? (acc->second.get_snorm()<=0.0) :
true;
6141 if (need_s_coeffs and compute_child_s_coeffs) {
6142 if (
d.dim(0)==
cdata.vk[0]) {
6150 compute_child_s_coeffs=
false;
6153 if (not childnode_exists) {
6156 }
else if (childnode_exists and need_s_coeffs) {
6157 acc->second.coeff()=child_s_coeffs;
6161 nodeT& childnode = acc->second;
6165 ij_other_list, j_other_list, this_first,
thresh));
6171 return contraction_map;
6183 template<
typename Q, std::size_t LDIM,
typename R, std::size_t KDIM,
6184 std::size_t CDIM = (KDIM + LDIM -
NDIM) / 2>
6186 const std::array<int, CDIM> v1,
const std::array<int, CDIM> v2,
6189 Key<LDIM - CDIM> i_key;
6190 Key<KDIM - CDIM> k_key;
6194 for (
const auto& j_key: j_key_list) {
6196 auto v_complement = [](
const auto&
v,
const auto& vc) {
6197 constexpr std::size_t VDIM = std::tuple_size<std::decay_t<
decltype(
v)>>::value;
6198 constexpr std::size_t VCDIM = std::tuple_size<std::decay_t<
decltype(vc)>>::value;
6199 std::array<int, VCDIM> result;
6200 for (std::size_t i = 0; i < VCDIM; i++) result[i] = (
v.back() + i + 1) % (VDIM + VCDIM);
6203 auto make_ij_key = [&v_complement](
const auto i_key,
const auto j_key,
const auto&
v) {
6204 constexpr std::size_t IDIM = std::decay_t<
decltype(i_key)>::static_size;
6205 constexpr std::size_t JDIM = std::decay_t<
decltype(j_key)>::static_size;
6206 static_assert(JDIM == std::tuple_size<std::decay_t<
decltype(
v)>>::value);
6209 for (std::size_t i = 0; i <
v.size(); ++i) l[
v[i]] = j_key.translation()[i];
6210 std::array<int, IDIM> vc1;
6211 auto vc = v_complement(
v, vc1);
6212 for (std::size_t i = 0; i < vc.size(); ++i) l[vc[i]] = i_key.translation()[i];
6217 Key<LDIM> ij_key = make_ij_key(i_key, j_key, v1);
6218 Key<KDIM> jk_key = make_ij_key(k_key, j_key, v2);
6222 const coeffT& gcoeff =
g->get_coeffs().find(ij_key).get()->second.coeff();
6223 const coeffT& hcoeff =
h->get_coeffs().find(jk_key).get()->second.coeff();
6225 if (gcoeff.
dim(0) ==
g->get_cdata().k) {
6226 gcoeff1 =
coeffT(
g->get_cdata().v2k,
g->get_tensor_args());
6227 gcoeff1(
g->get_cdata().s0) += gcoeff;
6231 if (hcoeff.
dim(0) ==
g->get_cdata().k) {
6232 hcoeff1 =
coeffT(
h->get_cdata().v2k,
h->get_tensor_args());
6233 hcoeff1(
h->get_cdata().s0) += hcoeff;
6239 auto fuse = [](
Tensor<T> tensor,
const std::array<int, CDIM>&
v,
int offset) {
6240 for (std::size_t i = 0; i < CDIM - 1; ++i) {
6250 auto contract2 = [](
const auto& svdcoeff,
const auto& tensor,
const int particle) {
6252 const int spectator_particle=(
particle+1)%2;
6253 Tensor<Q> gtensor = svdcoeff.get_svdtensor().make_vector_with_weights(
particle);
6254 gtensor=gtensor.
reshape(svdcoeff.rank(),gtensor.
size()/svdcoeff.rank());
6256 Tensor<Q> gtensor_other = svdcoeff.get_svdtensor().ref_vector(spectator_particle);
6273 if (key.
level() > 0) {
6276 gtensor = fuse(gtensor, v1,
offset);
6277 htensor = fuse(htensor, v2,
offset);
6290 int gparticle= v1[0]==0 ? 0 : 1;
6291 int hparticle= v2[0]==0 ? 0 : 1;
6303 result_tmp.
get_svdtensor().set_vectors_and_weights(
w,tmp2,htensor_other);
6304 if (key.
level() > 0) {
6317 result_coeff1.
get_svdtensor().set_vectors_and_weights(
w,tmp2,htensor_other);
6320 result_coeff+=result_tmp;
6330 int hparticle= v2[0]==0 ? 0 : 1;
6343 int gparticle= v1[0]==0 ? 0 : 1;
6376 return c.trace_conj(fc);
6389 T new_inner, result = 0.0;
6396 if (old_inner ==
T(0)) {
6400 if (
coeffs.
find(key).get()->second.has_children()) {
6406 const keyT& child = it.key();
6410 new_inner = inner_child.
sum();
6411 }
else if (leaf_refine) {
6428 const keyT& child = it.key();
6432 new_inner = inner_child.
sum();
6436 new_inner = old_inner;
6448 const keyT& child = it.key();
6458 const std::shared_ptr< FunctionFunctorInterface<T, NDIM> >
fref;
6464 const implT * impl,
const bool leaf_refine,
const bool do_leaves)
6465 : fref(
f), impl(impl), leaf_refine(leaf_refine), do_leaves(do_leaves) {};
6468 if (do_leaves and it->second.is_leaf()) {
6469 tensorT cc = it->second.coeff().full_tensor();
6471 }
else if ((not do_leaves) and (it->first.level() == impl->
initial_level)) {
6472 tensorT cc = it->second.coeff().full_tensor();
6483 template <
typename Archive>
void serialize(
const Archive& ar) {
6519 const bool leaf_refine,
T old_inner=
T(0))
const {
6536 const keyT& child = it.key();
6543 if (leaf_refine and (
std::abs(new_inner - old_inner) > tol)) {
6545 const keyT& child = it.key();
6569 template <
typename L>
6593 template <
typename L>
6602 if (not below_leaf) {
6603 bool left_leaf = left->
coeffs.
find(key).get()->second.is_leaf();
6609 const keyT& child = it.key();
6619 if (lc.
size() == 0) {
6622 if (it->second.has_coeff())
6623 lc = it->second.coeff().reconstruct_tensor();
6627 if (
c.size() == 0) {
6648 const keyT& child = it.key();
6660 double dnorm =
d.normf();
6671 const keyT& child = it.key();
6675 child, left, left_coeff, child_coeff,
f,
alpha,
beta, tol, below_leaf);
6680 template <
typename L>
6696 template<
size_t LDIM>
6698 const int dim,
const bool fence) {
6713 coeff_op, apply_op,
cdata.key0);
6722 template<
size_t LDIM>
6729 typedef std::pair<bool,coeffT>
argT;
6771 const int k=fcoeff.
dim(0);
6772 const int k_ldim=std::pow(
k,LDIM);
6773 std::vector<long> shape(LDIM,
k);
6779 final=
inner(gtensor,ftensor,0,
dim).reshape(shape);
6782 if (fcoeff.
rank()>0) {
6785 const int otherdim = (
dim + 1) % 2;
6789 const tensorT gatensor =
inner(gtensor, atensor, 0, 1);
6794 for (
int r = 0; r < fcoeff.
rank(); ++r)
final +=
weights(r) * btensor(r,
_);
6795 final =
final.reshape(shape);
6825 return this_type(fimpl1,result1,iag1,dim1);
6828 template <
typename Archive>
void serialize(
const Archive& ar) {
6842 template<
size_t LDIM>
6845 typedef std::pair< keyT,coeffT > pairT;
6850 fiterator end =
f->get_coeffs().end();
6851 for (fiterator it=
f->get_coeffs().begin(); it!=end; ++it) {
6868 woT::task(
world.
rank(),&implT:: template do_project_out<LDIM>,fcoeff,result,key1,key2,dim);
6870 }
else if (dim==1) {
6878 woT::task(
world.
rank(),&implT:: template do_project_out<LDIM>,fcoeff,result,key2,key1,dim);
6900 template<
size_t LDIM>
6902 const Key<NDIM>& dest,
const int dim)
const {
6915 const int otherdim=(dim+1)%2;
6916 const int k=fcoeff.
dim(0);
6917 std::vector<Slice> s(fcoeff.
config().dim_per_vector()+1,
_);
6920 for (
int r=0; r<fcoeff.
rank(); ++r) {
6922 const tensorT contracted_tensor=fcoeff.
config().ref_vector(dim)(s).reshape(
k,
k,
k);
6923 const tensorT other_tensor=fcoeff.
config().ref_vector(otherdim)(s).reshape(
k,
k,
k);
6924 const double ovlp= gtensor.trace_conj(contracted_tensor);
6925 const double fac=ovlp * fcoeff.
config().weights(r);
6926 result+=fac*other_tensor;
6953 std::size_t
size()
const;
6956 std::size_t
nCoeff()
const;
6971 template <
typename Q,
typename F>
6975 typename fdcT::const_iterator end =
f.coeffs.
end();
6976 for (
typename fdcT::const_iterator it=
f.coeffs.begin(); it!=end; ++it) {
6977 const keyT& key = it->first;
6978 const fnodeT& node = it->second;
6980 if (node.has_coeff()) {
7011 template <
class Archive,
class T, std::
size_t NDIM>
7023 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use a locally uninitialized object",0);
7026 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use an unregistered object",0);
7033 template <
class Archive,
class T, std::
size_t NDIM>
7036 bool exists=(ptr) ?
true :
false;
7038 if (exists) ar & ptr->
id();
7042 template <
class Archive,
class T, std::
size_t NDIM>
7054 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use a locally uninitialized object",0);
7057 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use an unregistered object",0);
7064 template <
class Archive,
class T, std::
size_t NDIM>
7067 bool exists=(ptr) ?
true :
false;
7069 if (exists) ar & ptr->
id();
7074 template <
class Archive,
class T, std::
size_t NDIM>
7083 template <
class Archive,
class T, std::
size_t NDIM>
7090 template <
class Archive,
class T, std::
size_t NDIM>
7099 template <
class Archive,
class T, std::
size_t NDIM>
double w(double t, double eps)
Definition DKops.h:22
double q(double t)
Definition DKops.h:18
This header should include pretty much everything needed for the parallel runtime.
An integer with atomic set, get, read+increment, read+decrement, and decrement+test operations.
Definition atomicint.h:126
long dim(int i) const
Returns the size of dimension i.
Definition basetensor.h:147
long ndim() const
Returns the number of dimensions in the tensor.
Definition basetensor.h:144
long size() const
Returns the number of elements in the tensor.
Definition basetensor.h:138
a class to track where relevant (parent) coeffs are
Definition funcimpl.h:788
const keyT & key() const
const reference to the key
Definition funcimpl.h:836
CoeffTracker(const CoeffTracker &other, const datumT &datum)
ctor with a pair<keyT,nodeT>
Definition funcimpl.h:818
const LeafStatus & is_leaf() const
const reference to is_leaf flag
Definition funcimpl.h:860
const implT * impl
the funcimpl that has the coeffs
Definition funcimpl.h:797
LeafStatus
Definition funcimpl.h:794
@ yes
Definition funcimpl.h:794
@ no
Definition funcimpl.h:794
@ unknown
Definition funcimpl.h:794
CoeffTracker(const CoeffTracker &other)
copy ctor
Definition funcimpl.h:826
double dnorm(const keyT &key) const
return the s and dnorm belonging to the passed-in key
Definition funcimpl.h:853
coeffT coeff_
the coefficients belonging to key
Definition funcimpl.h:803
const implT * get_impl() const
const reference to impl
Definition funcimpl.h:830
const coeffT & coeff() const
const reference to the coeffs
Definition funcimpl.h:833
keyT key_
the current key, which must exists in impl
Definition funcimpl.h:799
double dnorm_
norm of d coefficients corresponding to key
Definition funcimpl.h:805
CoeffTracker(const implT *impl)
the initial ctor making the root key
Definition funcimpl.h:813
void serialize(const Archive &ar)
serialization
Definition funcimpl.h:912
Future< CoeffTracker > activate() const
find the coefficients
Definition funcimpl.h:889
CoeffTracker()
default ctor
Definition funcimpl.h:810
GenTensor< T > coeffT
Definition funcimpl.h:792
CoeffTracker make_child(const keyT &child) const
make a child of this, ignoring the coeffs
Definition funcimpl.h:863
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:790
std::pair< Key< NDIM >, ShallowNode< T, NDIM > > datumT
Definition funcimpl.h:793
CoeffTracker forward_ctor(const CoeffTracker &other, const datumT &datum) const
taskq-compatible forwarding to the ctor
Definition funcimpl.h:906
LeafStatus is_leaf_
flag if key is a leaf node
Definition funcimpl.h:801
coeffT coeff(const keyT &key) const
return the coefficients belonging to the passed-in key
Definition funcimpl.h:844
Key< NDIM > keyT
Definition funcimpl.h:791
CompositeFunctorInterface implements a wrapper of holding several functions and functors.
Definition function_interface.h:165
Definition worldhashmap.h:396
Tri-diagonal operator traversing tree primarily for derivative operator.
Definition derivative.h:73
FunctionCommonData holds all Function data common for given k.
Definition function_common_data.h:52
Tensor< double > quad_phit
transpose of quad_phi
Definition function_common_data.h:102
Tensor< double > quad_phiw
quad_phiw(i,j) = at x[i] value of w[i]*phi[j]
Definition function_common_data.h:103
std::vector< long > vk
(k,...) used to initialize Tensors
Definition function_common_data.h:93
std::vector< Slice > s0
s[0] in each dimension to get scaling coeff
Definition function_common_data.h:91
static const FunctionCommonData< T, NDIM > & get(int k)
Definition function_common_data.h:111
static void _init_quadrature(int k, int npt, Tensor< double > &quad_x, Tensor< double > &quad_w, Tensor< double > &quad_phi, Tensor< double > &quad_phiw, Tensor< double > &quad_phit)
Initialize the quadrature information.
Definition mraimpl.h:88
collect common functionality does not need to be member function of funcimpl
Definition function_common_data.h:135
const FunctionCommonData< T, NDIM > & cdata
Definition function_common_data.h:138
GenTensor< T > coeffs2values(const Key< NDIM > &key, const GenTensor< T > &coeff) const
Definition function_common_data.h:142
Tensor< T > values2coeffs(const Key< NDIM > &key, const Tensor< T > &values) const
Definition function_common_data.h:155
FunctionDefaults holds default paramaters as static class members.
Definition funcdefaults.h:204
static const double & get_thresh()
Returns the default threshold.
Definition funcdefaults.h:279
static int get_max_refine_level()
Gets the default maximum adaptive refinement level.
Definition funcdefaults.h:316
static const Tensor< double > & get_cell_width()
Returns the width of each user cell dimension.
Definition funcdefaults.h:468
static bool get_apply_randomize()
Gets the random load balancing for integral operators flag.
Definition funcdefaults.h:392
static const Tensor< double > & get_cell()
Gets the user cell for the simulation.
Definition funcdefaults.h:446
FunctionFactory implements the named-parameter idiom for Function.
Definition function_factory.h:86
bool _refine
Definition function_factory.h:99
bool _empty
Definition function_factory.h:100
bool _fence
Definition function_factory.h:103
Abstract base class interface required for functors used as input to Functions.
Definition function_interface.h:68
Definition funcimpl.h:5321
double operator()(double a, double b) const
Definition funcimpl.h:5347
const opT * func
Definition funcimpl.h:5323
Tensor< double > qx
Definition funcimpl.h:5325
double operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5338
void serialize(const Archive &ar)
Definition funcimpl.h:5352
do_err_box(const implT *impl, const opT *func, int npt, const Tensor< double > &qx, const Tensor< double > &quad_phit, const Tensor< double > &quad_phiw)
Definition funcimpl.h:5331
int npt
Definition funcimpl.h:5324
Tensor< double > quad_phiw
Definition funcimpl.h:5327
const implT * impl
Definition funcimpl.h:5322
Tensor< double > quad_phit
Definition funcimpl.h:5326
do_err_box(const do_err_box &e)
Definition funcimpl.h:5335
FunctionImpl holds all Function state to facilitate shallow copy semantics.
Definition funcimpl.h:942
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
Definition funcimpl.h:6025
void copy_coeffs(const FunctionImpl< Q, NDIM > &other, bool fence)
Copy coeffs from other into self.
Definition funcimpl.h:1113
bool is_nonstandard() const
Definition mraimpl.h:252
T eval_cube(Level n, coordT &x, const tensorT &c) const
Definition mraimpl.h:2055
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
Definition funcimpl.h:6185
AtomicInt large
Definition funcimpl.h:998
Timer timer_target_driven
Definition funcimpl.h:996
void binaryXX(const FunctionImpl< L, NDIM > *left, const FunctionImpl< R, NDIM > *right, const opT &op, bool fence)
Definition funcimpl.h:3181
void do_apply(const opT *op, const keyT &key, const Tensor< R > &c)
apply an operator on the coeffs c (at node key)
Definition funcimpl.h:4771
void do_print_tree_graphviz(const keyT &key, std::ostream &os, Level maxlevel) const
Functor for the do_print_tree method (using GraphViz)
Definition mraimpl.h:2789
void add_keys_to_map(mapT *map, int index) const
Adds keys to union of local keys with specified index.
Definition funcimpl.h:5605
void change_tensor_type1(const TensorArgs &targs, bool fence)
change the tensor type of the coefficients in the FunctionNode
Definition mraimpl.h:1078
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)
Definition funcimpl.h:6594
int initial_level
Initial level for refinement.
Definition funcimpl.h:971
int max_refine_level
Do not refine below this level.
Definition funcimpl.h:974
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
Definition funcimpl.h:4729
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
Definition funcimpl.h:3693
void traverse_tree(const coeff_opT &coeff_op, const apply_opT &apply_op, const keyT &key) const
traverse a non-existing tree
Definition funcimpl.h:3663
void do_square_inplace(const keyT &key)
int special_level
Minimium level for refinement on special points.
Definition funcimpl.h:972
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
Definition funcimpl.h:4663
double errsq_local(const opT &func) const
Returns the sum of squares of errors from local info ... no comms.
Definition funcimpl.h:5359
WorldContainer< keyT, nodeT > dcT
Type of container holding the coefficients.
Definition funcimpl.h:954
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.
Definition mraimpl.h:2970
void scale_inplace(const T q, bool fence)
In-place scale by a constant.
Definition mraimpl.h:3141
void 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
Definition mraimpl.h:208
void unary_op_coeff_inplace(const opT &op, bool fence)
Definition funcimpl.h:2025
World & world
Definition funcimpl.h:961
void apply_1d_realspace_push_op(const archive::archive_ptr< const opT > &pop, int axis, const keyT &key, const Tensor< R > &c)
Definition funcimpl.h:3731
bool is_redundant() const
Returns true if the function is redundant.
Definition mraimpl.h:247
FunctionNode< T, NDIM > nodeT
Type of node.
Definition funcimpl.h:952
void print_size(const std::string name) const
print tree size and size
Definition mraimpl.h:1971
FunctionImpl(const FunctionImpl< T, NDIM > &p)
void print_info() const
Prints summary of data distribution.
Definition mraimpl.h:812
void abs_inplace(bool fence)
Definition mraimpl.h:3153
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)
Definition funcimpl.h:3050
void print_timer() const
Definition mraimpl.h:336
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.
Definition mraimpl.h:3012
const FunctionCommonData< T, NDIM > & cdata
Definition funcimpl.h:980
void do_print_grid(const std::string filename, const std::vector< keyT > &keys) const
print the grid in xyz format
Definition mraimpl.h:563
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)
Definition funcimpl.h:2964
const std::vector< Vector< double, NDIM > > & get_special_points() const
Definition funcimpl.h:966
std::size_t nCoeff() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1957
double vol_nsphere(int n, double R)
Definition funcimpl.h:4759
void compress(const TreeState newstate, bool fence)
compress the wave function
Definition mraimpl.h:1522
void do_dirac_convolution(FunctionImpl< T, LDIM > *f, bool fence) const
Definition funcimpl.h:2108
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
Definition mraimpl.h:1690
Future< bool > truncate_spawn(const keyT &key, double tol)
Returns true if after truncation this node has coefficients.
Definition mraimpl.h:2634
void print_type_in_compilation_error(R &&)
Definition funcimpl.h:5907
Future< double > norm_tree_spawn(const keyT &key)
Definition mraimpl.h:1592
std::vector< keyT > local_leaf_keys() const
return the keys of the local leaf boxes
Definition mraimpl.h:537
MADNESS_ASSERT(this->is_redundant()==g.is_redundant())
void do_print_tree(const keyT &key, std::ostream &os, Level maxlevel) const
Functor for the do_print_tree method.
Definition mraimpl.h:2707
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)
Definition funcimpl.h:2825
void unset_functor()
Definition mraimpl.h:291
void refine_spawn(const opT &op, const keyT &key)
Definition funcimpl.h:4491
void apply_1d_realspace_push(const opT &op, const FunctionImpl< R, NDIM > *f, int axis, bool fence)
Definition funcimpl.h:3782
static double conj(float x)
Definition funcimpl.h:5793
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
Definition mraimpl.h:478
std::pair< Key< NDIM >, ShallowNode< T, NDIM > > find_datum(keyT key) const
return the a std::pair<key, node>, which MUST exist
Definition mraimpl.h:944
void set_functor(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor1)
Definition mraimpl.h:272
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
Definition funcimpl.h:1559
void broaden(std::vector< bool > is_periodic, bool fence)
Definition mraimpl.h:1282
const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > & get_pmap() const
Definition mraimpl.h:192
Tensor< Q > fcube_for_mul(const keyT &child, const keyT &parent, const Tensor< Q > &coeff) const
Compute the function values for multiplication.
Definition funcimpl.h:1872
Timer timer_filter
Definition funcimpl.h:994
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.
Definition mraimpl.h:2847
void recursive_apply(opT &apply_op, const implT *fimpl, implT *rimpl, const bool fence)
traverse an existing tree and apply an operator
Definition funcimpl.h:5178
double get_thresh() const
Definition mraimpl.h:307
void trickle_down(bool fence)
sum all the contributions from all scales after applying an operator in mod-NS form
Definition mraimpl.h:1333
bool autorefine
If true, autorefine where appropriate.
Definition funcimpl.h:976
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
Definition mraimpl.h:1750
void set_autorefine(bool value)
Definition mraimpl.h:316
tensorT filter(const tensorT &s) const
Transform sum coefficients at level n to sums+differences at level n-1.
Definition mraimpl.h:1131
void chop_at_level(const int n, const bool fence=true)
remove all nodes with level higher than n
Definition mraimpl.h:1094
void unaryXXvalues(const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)
Definition funcimpl.h:3208
static std::complex< double > conj(const std::complex< double > x)
Definition funcimpl.h:5797
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
Definition funcimpl.h:5923
TreeState tree_state
Definition funcimpl.h:983
void print_tree_json(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2727
coeffT parent_to_child_NS(const keyT &child, const keyT &parent, const coeffT &coeff) const
Directly project parent NS coeffs to child NS coeffs.
Definition mraimpl.h:686
void mapdim(const implT &f, const std::vector< long > &map, bool fence)
Permute the dimensions of f according to map, result on this.
Definition mraimpl.h:1036
bool is_compressed() const
Returns true if the function is compressed.
Definition mraimpl.h:235
Vector< double, NDIM > coordT
Type of vector holding coordinates.
Definition funcimpl.h:956
void apply(opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
apply an operator on f to return this
Definition funcimpl.h:4857
Tensor< T > tensorT
Type of tensor for anything but to hold coeffs.
Definition funcimpl.h:949
void mirror(const implT &f, const std::vector< long > &mirror, bool fence)
mirror the dimensions of f according to map, result on this
Definition mraimpl.h:1045
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
Definition funcimpl.h:6517
void store(Archive &ar)
Definition funcimpl.h:1237
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.
Definition funcimpl.h:1974
void gaxpy_ext(const FunctionImpl< L, NDIM > *left, T(*f)(const coordT &), T alpha, T beta, double tol, bool fence)
Definition funcimpl.h:6681
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
Definition funcimpl.h:1161
void print_stats() const
print the number of configurations per node
Definition mraimpl.h:1999
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
Definition mraimpl.h:1639
void refine_op(const opT &op, const keyT &key)
Definition funcimpl.h:4466
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)
Definition funcimpl.h:5803
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.
Definition mraimpl.h:2472
Timer timer_change_tensor_type
Definition funcimpl.h:992
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 > ¢er, const std::pair< keyT, coeffT > &right)
Definition mraimpl.h:902
std::vector< Slice > child_patch(const keyT &child) const
Returns patch referring to coeffs of child in parent box.
Definition mraimpl.h:675
void print_tree_graphviz(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2780
void set_tree_state(const TreeState &state)
Definition funcimpl.h:1265
std::size_t min_nodes() const
Returns the min number of nodes on a processor.
Definition mraimpl.h:1895
std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor
Definition funcimpl.h:982
Timer timer_compress_svd
Definition funcimpl.h:995
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
Definition funcimpl.h:1947
void make_redundant(const bool fence)
convert this to redundant, i.e. have sum coefficients on all levels
Definition mraimpl.h:1550
void load(Archive &ar)
Definition funcimpl.h:1219
std::size_t max_nodes() const
Returns the max number of nodes on a processor.
Definition mraimpl.h:1886
T inner_ext_local(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const
Definition funcimpl.h:6492
coeffT upsample(const keyT &key, const coeffT &coeff) const
upsample the sum coefficients of level 1 to sum coeffs on level n+1
Definition mraimpl.h:1210
TensorArgs targs
type of tensor to be used in the FunctionNodes
Definition funcimpl.h:978
void flo_unary_op_node_inplace(const opT &op, bool fence)
Definition funcimpl.h:2137
GenTensor< Q > values2coeffs(const keyT &key, const GenTensor< Q > &values) const
Definition funcimpl.h:1851
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
Definition mraimpl.h:3319
T trace_local() const
Returns int(f(x),x) in local volume.
Definition mraimpl.h:3195
void print_grid(const std::string filename) const
Definition mraimpl.h:521
Future< std::pair< coeffT, double > > compress_spawn(const keyT &key, bool nonstandard, bool keepleaves, bool redundant1)
Invoked on node where key is local.
Definition mraimpl.h:3267
bool get_autorefine() const
Definition mraimpl.h:313
int k
Wavelet order.
Definition funcimpl.h:969
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)
Definition funcimpl.h:2669
MADNESS_CHECK(this->is_reconstructed())
void phi_for_mul(Level np, Translation lp, Level nc, Translation lc, Tensor< double > &phi) const
Compute the Legendre scaling functions for multiplication.
Definition mraimpl.h:3163
Future< std::pair< keyT, coeffT > > find_me(const keyT &key) const
find_me. Called by diff_bdry to get coefficients of boundary function
Definition mraimpl.h:3254
TensorType get_tensor_type() const
Definition mraimpl.h:298
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
Definition funcimpl.h:6901
void remove_leaf_coefficients(const bool fence)
Definition mraimpl.h:1544
void insert_zero_down_to_initial_level(const keyT &key)
Initialize nodes to zero function at initial_level of refinement.
Definition mraimpl.h:2603
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 > ¢er, const std::pair< keyT, coeffT > &right)
Definition mraimpl.h:913
typedef TENSOR_RESULT_TYPE(T, R) resultT
void unary_op_node_inplace(const opT &op, bool fence)
Definition funcimpl.h:2046
T inner_adaptive_local(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const
Definition funcimpl.h:6503
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.
Definition mraimpl.h:2758
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
Definition funcimpl.h:6078
std::shared_ptr< FunctionImpl< T, NDIM > > pimplT
pointer to this class
Definition funcimpl.h:948
void finalize_sum()
after summing up we need to do some cleanup;
Definition mraimpl.h:1843
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
Definition funcimpl.h:1452
dcT coeffs
The coefficients.
Definition funcimpl.h:985
bool exists_and_is_leaf(const keyT &key) const
Definition mraimpl.h:1254
void make_Vphi(const opT &leaf_op, const bool fence=true)
assemble the function V*phi using V and phi given from the functor
Definition funcimpl.h:4258
void unaryXX(const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)
Definition funcimpl.h:3195
std::vector< std::pair< int, const coeffT * > > mapvecT
Type of the entry in the map returned by make_key_vec_map.
Definition funcimpl.h:5599
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)>
Definition funcimpl.h:6697
void verify_tree() const
Verify tree is properly constructed ... global synchronization involved.
Definition mraimpl.h:109
void do_square_inplace2(const keyT &parent, const keyT &child, const tensorT &parent_coeff)
void gaxpy_inplace_reconstructed(const T &alpha, const FunctionImpl< Q, NDIM > &g, const R &beta, const bool fence)
Definition funcimpl.h:1130
void set_tensor_args(const TensorArgs &t)
Definition mraimpl.h:304
GenTensor< Q > fcube_for_mul(const keyT &child, const keyT &parent, const GenTensor< Q > &coeff) const
Compute the function values for multiplication.
Definition funcimpl.h:1900
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:5450
std::size_t real_size() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1944
bool exists_and_has_children(const keyT &key) const
Definition mraimpl.h:1249
void sum_down_spawn(const keyT &key, const coeffT &s)
is this the same as trickle_down() ?
Definition mraimpl.h:855
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.
Definition funcimpl.h:2796
long box_interior[1000]
Definition funcimpl.h:3239
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.
Definition funcimpl.h:1770
rangeT range(coeffs.begin(), coeffs.end())
void norm_tree(bool fence)
compute for each FunctionNode the norm of the function inside that node
Definition mraimpl.h:1569
void gaxpy_inplace(const T &alpha, const FunctionImpl< Q, NDIM > &other, const R &beta, bool fence)
Definition funcimpl.h:1206
bool has_leaves() const
Definition mraimpl.h:267
void apply_source_driven(opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
similar to apply, but for low rank coeffs
Definition funcimpl.h:5003
void distribute(std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > newmap) const
Definition funcimpl.h:1105
int get_special_level() const
Definition funcimpl.h:965
void reconstruct_op(const keyT &key, const coeffT &s, const bool accumulate_NS=true)
Definition mraimpl.h:2109
tensorT gaxpy_ext_node(keyT key, Tensor< L > lc, T(*f)(const coordT &), T alpha, T beta) const
Definition funcimpl.h:6570
const coeffT parent_to_child(const coeffT &s, const keyT &parent, const keyT &child) const
Directly project parent coeffs to child coeffs.
Definition mraimpl.h:3178
WorldObject< FunctionImpl< T, NDIM > > woT
Base class world object type.
Definition funcimpl.h:944
void undo_redundant(const bool fence)
convert this from redundant to standard reconstructed form
Definition mraimpl.h:1560
GenTensor< T > coeffT
Type of tensor used to hold coeffs.
Definition funcimpl.h:953
const keyT & key0() const
Returns cdata.key0.
Definition mraimpl.h:373
double finalize_apply()
after apply we need to do some cleanup;
Definition mraimpl.h:1800
bool leaves_only
Definition funcimpl.h:5455
friend hashT hash_value(const FunctionImpl< T, NDIM > *pimpl)
Hash a pointer to FunctionImpl.
Definition funcimpl.h:6995
const dcT & get_coeffs() const
Definition mraimpl.h:322
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.
Definition funcimpl.h:6369
double norm2sq_local() const
Returns the square of the local norm ... no comms.
Definition mraimpl.h:1852
const FunctionCommonData< T, NDIM > & get_cdata() const
Definition mraimpl.h:328
void sum_down(bool fence)
After 1d push operator must sum coeffs down the tree to restore correct scaling function coefficients...
Definition mraimpl.h:894
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
Definition funcimpl.h:6386
bool noautorefine(const keyT &key, const tensorT &t) const
Always returns false (for when autorefine is not wanted)
Definition mraimpl.h:838
double truncate_tol(double tol, const keyT &key) const
Returns the truncation threshold according to truncate_method.
Definition mraimpl.h:628
void flo_unary_op_node_inplace(const opT &op, bool fence) const
Definition funcimpl.h:2147
bool autorefine_square_test(const keyT &key, const nodeT &t) const
Returns true if this block of coeffs needs autorefining.
Definition mraimpl.h:844
void erase(const Level &max_level)
truncate tree at a certain level
Definition mraimpl.h:718
void mulXX(const FunctionImpl< L, NDIM > *left, const FunctionImpl< R, NDIM > *right, double tol, bool fence)
Definition funcimpl.h:3167
void reconstruct(bool fence)
reconstruct this tree – respects fence
Definition mraimpl.h:1490
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)
Definition funcimpl.h:3555
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
Definition mraimpl.h:992
static void tnorm(const tensorT &t, double *lo, double *hi)
Computes norm of low/high-order polyn. coeffs for autorefinement test.
Definition mraimpl.h:3055
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,...
Definition mraimpl.h:2941
std::size_t max_depth() const
Returns the maximum depth of the tree ... collective ... global sum/broadcast.
Definition mraimpl.h:1878
std::size_t size() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1913
void reduce_rank(const double thresh, bool fence)
reduce the rank of the coefficients tensors
Definition mraimpl.h:1086
TreeState get_tree_state() const
Definition funcimpl.h:1269
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
Definition funcimpl.h:1149
std::shared_ptr< FunctionFunctorInterface< T, NDIM > > get_functor()
Definition mraimpl.h:279
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)
Definition funcimpl.h:4894
tensorT unfilter(const tensorT &s) const
Transform sums+differences at level n to sum coefficients at level n+1.
Definition mraimpl.h:1160
int get_initial_level() const
getter
Definition funcimpl.h:964
Tensor< T > eval_plot_cube(const coordT &plotlo, const coordT &plothi, const std::vector< long > &npt, const bool eval_refine=false) const
Definition mraimpl.h:3412
virtual ~FunctionImpl()
Definition funcimpl.h:1097
Vector< Translation, NDIM > tranT
Type of array holding translation.
Definition funcimpl.h:950
void change_tree_state(const TreeState finalstate, bool fence=true)
change the tree state of this function, might or might not respect fence!
Definition mraimpl.h:1386
Future< coeffT > truncate_reconstructed_spawn(const keyT &key, const double tol)
truncate using a tree in reconstructed form
Definition mraimpl.h:1615
GenTensor< Q > coeffs2values(const keyT &key, const GenTensor< Q > &coeff) const
Definition funcimpl.h:1718
FunctionImpl(const FunctionFactory< T, NDIM > &factory)
Initialize function impl from data in factory.
Definition funcimpl.h:1001
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
Definition mraimpl.h:1055
Timer timer_lr_result
Definition funcimpl.h:993
void gaxpy(T alpha, const FunctionImpl< L, NDIM > &left, T beta, const FunctionImpl< R, NDIM > &right, bool fence)
Invoked by result to perform result += alpha*left+beta*right in wavelet basis.
Definition funcimpl.h:1997
void truncate(double tol, bool fence)
Truncate according to the threshold with optional global fence.
Definition mraimpl.h:357
void do_mul(const keyT &key, const Tensor< L > &left, const std::pair< keyT, Tensor< R > > &arg)
Functor for the mul method.
Definition funcimpl.h:1922
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)>
Definition funcimpl.h:6843
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
Definition funcimpl.h:4691
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)
Definition funcimpl.h:5855
Tensor< Q > coeffs2values(const keyT &key, const Tensor< Q > &coeff) const
Definition funcimpl.h:1844
Tensor< Q > values2coeffs(const keyT &key, const Tensor< Q > &values) const
Definition funcimpl.h:1858
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.
Definition funcimpl.h:2773
bool is_reconstructed() const
Returns true if the function is compressed.
Definition mraimpl.h:241
void replicate(bool fence=true)
Definition funcimpl.h:1101
double norm_tree_op(const keyT &key, const std::vector< Future< double > > &v)
Definition mraimpl.h:1577
void reset_timer()
Definition mraimpl.h:345
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.
Definition mraimpl.h:748
int get_k() const
Definition mraimpl.h:319
void dirac_convolution_op(const keyT &key, const nodeT &node, FunctionImpl< T, LDIM > *f) const
The operator.
Definition funcimpl.h:2063
FunctionImpl< T, NDIM > implT
Type of this class (implementation)
Definition funcimpl.h:947
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.
Definition mraimpl.h:2897
bool truncate_op(const keyT &key, double tol, const std::vector< Future< bool > > &v)
Definition mraimpl.h:2670
void zero_norm_tree()
Definition mraimpl.h:1271
std::size_t max_local_depth() const
Returns the maximum local depth of the tree ... no communications.
Definition mraimpl.h:1864
tensorT project(const keyT &key) const
Definition mraimpl.h:2815
double thresh
Screening threshold.
Definition funcimpl.h:970
double check_symmetry_local() const
Returns some asymmetry measure ... no comms.
Definition mraimpl.h:734
Future< double > get_norm_tree_recursive(const keyT &key) const
Definition mraimpl.h:2836
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)
Definition funcimpl.h:3224
Key< NDIM > keyT
Type of key.
Definition funcimpl.h:951
friend hashT hash_value(const std::shared_ptr< FunctionImpl< T, NDIM > > impl)
Hash a shared_ptr to FunctionImpl.
Definition funcimpl.h:7005
std::vector< Vector< double, NDIM > > special_points
special points for further refinement (needed for composite functions or multiplication)
Definition funcimpl.h:973
bool truncate_on_project
If true projection inserts at level n-1 not n.
Definition funcimpl.h:977
AtomicInt small
Definition funcimpl.h:997
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)
Definition funcimpl.h:5754
bool is_on_demand() const
Definition mraimpl.h:262
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.
Definition funcimpl.h:5291
void accumulate_timer(const double time) const
Definition mraimpl.h:331
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
Definition mraimpl.h:1344
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)
Definition funcimpl.h:5674
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)
Definition funcimpl.h:2860
void set_thresh(double value)
Definition mraimpl.h:310
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
Definition mraimpl.h:402
void sock_it_to_me_too(const keyT &key, const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &ref) const
Definition mraimpl.h:2875
void broaden_op(const keyT &key, const std::vector< Future< bool > > &v)
Definition mraimpl.h:1260
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.
Definition mraimpl.h:382
void print_tree(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2698
void project_refine_op(const keyT &key, bool do_refine, const std::vector< Vector< double, NDIM > > &specialpts)
Definition mraimpl.h:2484
void scale_oop(const Q q, const FunctionImpl< F, NDIM > &f, bool fence)
Out-of-place scale by a constant.
Definition funcimpl.h:6972
T typeT
Definition funcimpl.h:946
std::size_t tree_size() const
Returns the size of the tree structure of the function ... collective global sum.
Definition mraimpl.h:1904
ConcurrentHashMap< keyT, mapvecT > mapT
Type of the map returned by make_key_vec_map.
Definition funcimpl.h:5602
void add_scalar_inplace(T t, bool fence)
Adds a constant to the function. Local operation, optional fence.
Definition mraimpl.h:2562
void forward_traverse(const coeff_opT &coeff_op, const apply_opT &apply_op, const keyT &key) const
traverse a non-existing tree
Definition funcimpl.h:3649
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
Definition mraimpl.h:1180
void abs_square_inplace(bool fence)
Definition mraimpl.h:3158
FunctionImpl(const FunctionImpl< Q, NDIM > &other, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool dozero)
Copy constructor.
Definition funcimpl.h:1068
void refine(const opT &op, bool fence)
Definition funcimpl.h:4504
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.
Definition funcimpl.h:5623
void put_in_box(ProcessID from, long nl, long ni) const
Definition mraimpl.h:803
void unary_op_value_inplace(const opT &op, bool fence)
Definition funcimpl.h:2840
std::pair< const keyT, nodeT > datumT
Type of entry in container.
Definition funcimpl.h:955
Timer timer_accumulate
Definition funcimpl.h:991
TensorArgs get_tensor_args() const
Definition mraimpl.h:301
void unaryXXa(const keyT &key, const FunctionImpl< Q, NDIM > *func, const opT &op)
Definition funcimpl.h:3142
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
Definition funcimpl.h:4319
void average(const implT &rhs)
take the average of two functions, similar to: this=0.5*(this+rhs)
Definition mraimpl.h:1067
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
Definition funcimpl.h:5044
void diff(const DerivativeBase< T, NDIM > *D, const implT *f, bool fence)
Definition mraimpl.h:925
keyT neighbor(const keyT &key, const keyT &disp, const std::vector< bool > &is_periodic) const
Returns key of general neighbor enforcing BC.
Definition mraimpl.h:3237
void square_inplace(bool fence)
Pointwise squaring of function with optional global fence.
Definition mraimpl.h:3147
void remove_internal_coefficients(const bool fence)
Definition mraimpl.h:1539
void compute_snorm_and_dnorm(bool fence=true)
compute norm of s and d coefficients for all nodes
Definition mraimpl.h:1110
long box_leaf[1000]
Definition funcimpl.h:3238
void standard(bool fence)
Changes non-standard compressed form to standard compressed form.
Definition mraimpl.h:1787
void multiop_values_doit(const keyT &key, const opT &op, const std::vector< implT * > &v)
Definition funcimpl.h:2731
bool is_nonstandard_with_leaves() const
Definition mraimpl.h:257
GenTensor< Q > values2NScoeffs(const keyT &key, const GenTensor< Q > &values) const
convert function values of the a child generation directly to NS coeffs
Definition funcimpl.h:1819
int truncate_mode
0=default=(|d|<thresh), 1=(|d|<thresh/2^n), 1=(|d|<thresh/4^n);
Definition funcimpl.h:975
void multiop_values(const opT &op, const std::vector< implT * > &v)
Definition funcimpl.h:2748
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
Definition funcimpl.h:1734
FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree.
Definition funcimpl.h:124
FunctionNode< Q, NDIM > convert() const
Copy with possible type conversion of coefficients, copying all other state.
Definition funcimpl.h:191
GenTensor< T > coeffT
Definition funcimpl.h:126
bool has_coeff() const
Returns true if there are coefficients in this node.
Definition funcimpl.h:197
void recompute_snorm_and_dnorm(const FunctionCommonData< T, NDIM > &cdata)
Definition funcimpl.h:332
FunctionNode(const coeffT &coeff, bool has_children=false)
Constructor from given coefficients with optional children.
Definition funcimpl.h:153
FunctionNode()
Default constructor makes node without coeff or children.
Definition funcimpl.h:143
void serialize(Archive &ar)
Definition funcimpl.h:455
void consolidate_buffer(const TensorArgs &args)
Definition funcimpl.h:441
double get_dnorm() const
return the precomputed norm of the (virtual) d coefficients
Definition funcimpl.h:313
size_t size() const
Returns the number of coefficients in this node.
Definition funcimpl.h:239
void set_has_children_recursive(const typename FunctionNode< T, NDIM >::dcT &c, const Key< NDIM > &key)
Sets has_children attribute to true recurring up to ensure connected.
Definition funcimpl.h:256
FunctionNode< T, NDIM > & operator=(const FunctionNode< T, NDIM > &other)
Definition funcimpl.h:173
double snorm
norm of the s coefficients
Definition funcimpl.h:138
void clear_coeff()
Clears the coefficients (has_coeff() will subsequently return false)
Definition funcimpl.h:292
Tensor< T > tensorT
Definition funcimpl.h:127
coeffT buffer
The coefficients, if any.
Definition funcimpl.h:136
T trace_conj(const FunctionNode< T, NDIM > &rhs) const
Definition funcimpl.h:450
void scale(Q a)
Scale the coefficients of this node.
Definition funcimpl.h:298
bool is_leaf() const
Returns true if this does not have children.
Definition funcimpl.h:210
void set_has_children(bool flag)
Sets has_children attribute to value of flag.
Definition funcimpl.h:251
void accumulate(const coeffT &t, const typename FunctionNode< T, NDIM >::dcT &c, const Key< NDIM > &key, const TensorArgs &args)
Accumulate inplace and if necessary connect node to parent.
Definition funcimpl.h:413
double get_norm_tree() const
Gets the value of norm_tree.
Definition funcimpl.h:308
bool _has_children
True if there are children.
Definition funcimpl.h:135
FunctionNode(const coeffT &coeff, double norm_tree, double snorm, double dnorm, bool has_children)
Definition funcimpl.h:163
void set_snorm(const double sn)
set the precomputed norm of the (virtual) s coefficients
Definition funcimpl.h:318
coeffT _coeffs
The coefficients, if any.
Definition funcimpl.h:133
void accumulate2(const tensorT &t, const typename FunctionNode< T, NDIM >::dcT &c, const Key< NDIM > &key)
Accumulate inplace and if necessary connect node to parent.
Definition funcimpl.h:380
void reduceRank(const double &eps)
reduces the rank of the coefficients (if applicable)
Definition funcimpl.h:246
WorldContainer< Key< NDIM >, FunctionNode< T, NDIM > > dcT
Definition funcimpl.h:141
void gaxpy_inplace(const T &alpha, const FunctionNode< Q, NDIM > &other, const R &beta)
General bi-linear operation — this = this*alpha + other*beta.
Definition funcimpl.h:362
double _norm_tree
After norm_tree will contain norm of coefficients summed up tree.
Definition funcimpl.h:134
void set_is_leaf(bool flag)
Sets has_children attribute to value of !flag.
Definition funcimpl.h:277
void print_json(std::ostream &s) const
Definition funcimpl.h:463
double get_snorm() const
get the precomputed norm of the (virtual) s coefficients
Definition funcimpl.h:328
const coeffT & coeff() const
Returns a const reference to the tensor containing the coeffs.
Definition funcimpl.h:234
FunctionNode(const coeffT &coeff, double norm_tree, bool has_children)
Definition funcimpl.h:158
bool has_children() const
Returns true if this node has children.
Definition funcimpl.h:204
void set_coeff(const coeffT &coeffs)
Takes a shallow copy of the coeff — same as this->coeff()=coeff.
Definition funcimpl.h:282
void set_dnorm(const double dn)
set the precomputed norm of the (virtual) d coefficients
Definition funcimpl.h:323
double dnorm
norm of the d coefficients, also defined if there are no d coefficients
Definition funcimpl.h:137
bool is_invalid() const
Returns true if this node is invalid (no coeffs and no children)
Definition funcimpl.h:216
FunctionNode(const FunctionNode< T, NDIM > &other)
Definition funcimpl.h:167
coeffT & coeff()
Returns a non-const reference to the tensor containing the coeffs.
Definition funcimpl.h:224
void set_norm_tree(double norm_tree)
Sets the value of norm_tree.
Definition funcimpl.h:303
Implements the functionality of futures.
Definition future.h:74
A future is a possibly yet unevaluated value.
Definition future.h:373
remote_refT remote_ref(World &world) const
Returns a structure used to pass references to another process.
Definition future.h:675
RemoteReference< FutureImpl< T > > remote_refT
Definition future.h:398
Definition lowranktensor.h:59
bool is_of_tensortype(const TensorType &tt) const
Definition gentensor.h:225
GenTensor convert(const TensorArgs &targs) const
Definition gentensor.h:198
GenTensor full_tensor() const
Definition gentensor.h:200
long dim(const int i) const
return the number of entries in dimension i
Definition lowranktensor.h:391
Tensor< T > full_tensor_copy() const
Definition gentensor.h:206
long ndim() const
Definition lowranktensor.h:386
void add_SVD(const GenTensor< T > &rhs, const double &eps)
Definition gentensor.h:235
constexpr bool is_full_tensor() const
Definition gentensor.h:224
GenTensor get_tensor() const
Definition gentensor.h:203
GenTensor reconstruct_tensor() const
Definition gentensor.h:199
bool has_no_data() const
Definition gentensor.h:211
void normalize()
Definition gentensor.h:218
GenTensor< T > & emul(const GenTensor< T > &other)
Inplace multiply by corresponding elements of argument Tensor.
Definition lowranktensor.h:631
float_scalar_type normf() const
Definition lowranktensor.h:406
double svd_normf() const
Definition gentensor.h:213
SRConf< T > config() const
Definition gentensor.h:237
void reduce_rank(const double &eps)
Definition gentensor.h:217
long rank() const
Definition gentensor.h:212
long size() const
Definition lowranktensor.h:482
SVDTensor< T > & get_svdtensor()
Definition gentensor.h:228
TensorType tensor_type() const
Definition gentensor.h:221
bool has_data() const
Definition gentensor.h:210
GenTensor & gaxpy(const T alpha, const GenTensor &other, const T beta)
Definition lowranktensor.h:580
bool is_assigned() const
Definition gentensor.h:209
IsSupported< TensorTypeData< Q >, GenTensor< T > & >::type scale(Q fac)
Inplace multiplication by scalar of supported type (legacy name)
Definition lowranktensor.h:426
constexpr bool is_svd_tensor() const
Definition gentensor.h:222
Iterates in lexical order thru all children of a key.
Definition key.h:374
Key is the index for a node of the 2^NDIM-tree.
Definition key.h:66
Key< NDIM+LDIM > merge_with(const Key< LDIM > &rhs) const
merge with other key (ie concatenate), use level of rhs, not of this
Definition key.h:313
Level level() const
Definition key.h:159
bool is_valid() const
Checks if a key is valid.
Definition key.h:114
Key< NDIM-VDIM > extract_complement_key(const std::array< int, VDIM > &v) const
extract a new key with the Translations complementary to the ones indicated in the v array
Definition key.h:299
Key< VDIM > extract_key(const std::array< int, VDIM > &v) const
extract a new key with the Translations indicated in the v array
Definition key.h:291
Key parent(int generation=1) const
Returns the key of the parent.
Definition key.h:187
const Vector< Translation, NDIM > & translation() const
Definition key.h:164
void break_apart(Key< LDIM > &key1, Key< KDIM > &key2) const
break key into two low-dimensional keys
Definition key.h:269
A pmap that locates children on odd levels with their even level parents.
Definition funcimpl.h:102
LevelPmap(World &world)
Definition funcimpl.h:108
const int nproc
Definition funcimpl.h:104
LevelPmap()
Definition funcimpl.h:106
ProcessID owner(const keyT &key) const
Find the owner of a given key.
Definition funcimpl.h:111
Mutex using pthread mutex operations.
Definition worldmutex.h:131
void unlock() const
Free a mutex owned by this thread.
Definition worldmutex.h:165
void lock() const
Acquire the mutex waiting if necessary.
Definition worldmutex.h:155
Range, vaguely a la Intel TBB, to encapsulate a random-access, STL-like start and end iterator with c...
Definition range.h:64
Simple structure used to manage references/pointers to remote instances.
Definition worldref.h:395
Definition SVDTensor.h:42
A simple process map.
Definition funcimpl.h:83
SimplePmap(World &world)
Definition funcimpl.h:89
const int nproc
Definition funcimpl.h:85
const ProcessID me
Definition funcimpl.h:86
ProcessID owner(const keyT &key) const
Maps key to processor.
Definition funcimpl.h:92
A slice defines a sub-range or patch of a dimension.
Definition slice.h:103
static TaskAttributes hipri()
Definition thread.h:450
Traits class to specify support of numeric types.
Definition type_data.h:56
A tensor is a multidimension array.
Definition tensor.h:317
float_scalar_type normf() const
Returns the Frobenius norm of the tensor.
Definition tensor.h:1726
T sum() const
Returns the sum of all elements of the tensor.
Definition tensor.h:1662
Tensor< T > reshape(int ndimnew, const long *d)
Returns new view/tensor reshaping size/number of dimensions to conforming tensor.
Definition tensor.h:1384
T * ptr()
Returns a pointer to the internal data.
Definition tensor.h:1824
Tensor< T > mapdim(const std::vector< long > &map)
Returns new view/tensor permuting the dimensions.
Definition tensor.h:1624
IsSupported< TensorTypeData< Q >, Tensor< T > & >::type scale(Q x)
Inplace multiplication by scalar of supported type (legacy name)
Definition tensor.h:686
T trace(const Tensor< T > &t) const
Return the trace of two tensors (no complex conjugate invoked)
Definition tensor.h:1776
Tensor< T > & emul(const Tensor< T > &t)
Inplace multiply by corresponding elements of argument Tensor.
Definition tensor.h:1798
bool has_data() const
Definition tensor.h:1886
Tensor< T > fusedim(long i)
Returns new view/tensor fusing contiguous dimensions i and i+1.
Definition tensor.h:1587
Tensor< T > flat()
Returns new view/tensor rehshaping to flat (1-d) tensor.
Definition tensor.h:1555
Tensor< T > & gaxpy(T alpha, const Tensor< T > &t, T beta)
Inplace generalized saxpy ... this = this*alpha + other*beta.
Definition tensor.h:1804
Tensor< T > & conj()
Inplace complex conjugate.
Definition tensor.h:716
Definition function_common_data.h:169
void accumulate(const double time) const
accumulate timer
Definition function_common_data.h:183
A simple, fixed dimension vector.
Definition vector.h:64
Makes a distributed container with specified attributes.
Definition worlddc.h:866
void process_pending()
Process pending messages.
Definition worlddc.h:1166
bool find(accessor &acc, const keyT &key)
Write access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).
Definition worlddc.h:987
bool probe(const keyT &key) const
Returns true if local data is immediately available (no communication)
Definition worlddc.h:1024
iterator begin()
Returns an iterator to the beginning of the local data (no communication)
Definition worlddc.h:1070
ProcessID owner(const keyT &key) const
Returns processor that logically owns key (no communication)
Definition worlddc.h:1034
implT::const_iterator const_iterator
Definition worlddc.h:872
void replicate(bool fence=true)
replicates this WorldContainer on all ProcessIDs
Definition worlddc.h:968
void replace(const pairT &datum)
Inserts/replaces key+value pair (non-blocking communication if key not local)
Definition worlddc.h:974
iterator end()
Returns an iterator past the end of the local data (no communication)
Definition worlddc.h:1084
const std::shared_ptr< WorldDCPmapInterface< keyT > > & get_pmap() const
Returns shared pointer to the process mapping.
Definition worlddc.h:1142
bool insert(accessor &acc, const keyT &key)
Write access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remo...
Definition worlddc.h:1001
implT::iterator iterator
Definition worlddc.h:871
std::size_t size() const
Returns the number of local entries (no communication)
Definition worlddc.h:1135
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> task(const keyT &key, memfunT memfun, const TaskAttributes &attr=TaskAttributes())
Adds task "resultT memfun()" in process owning item (non-blocking comm if remote)
Definition worlddc.h:1426
bool is_local(const keyT &key) const
Returns true if the key maps to the local processor (no communication)
Definition worlddc.h:1041
Future< MEMFUN_RETURNT(memfunT)> send(const keyT &key, memfunT memfun)
Sends message "resultT memfun()" to item (non-blocking comm if remote)
Definition worlddc.h:1183
implT::accessor accessor
Definition worlddc.h:873
Interface to be provided by any process map.
Definition worlddc.h:82
void fence(bool debug=false)
Synchronizes all processes in communicator AND globally ensures no pending AM or tasks.
Definition worldgop.cc:161
Implements most parts of a globally addressable object (via unique ID).
Definition world_object.h:364
const uniqueidT & id() const
Returns the globally unique object ID.
Definition world_object.h:711
void process_pending()
To be called from derived constructor to process pending messages.
Definition world_object.h:656
ProcessID me
Rank of self.
Definition world_object.h:385
detail::task_result_type< memfnT >::futureT send(ProcessID dest, memfnT memfn) const
Definition world_object.h:731
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)().
Definition world_object.h:1005
Future< bool > for_each(const rangeT &range, const opT &op)
Apply op(item) on all items in range.
Definition world_task_queue.h:572
void add(TaskInterface *t)
Add a new local task, taking ownership of the pointer.
Definition world_task_queue.h:466
Future< resultT > reduce(const rangeT &range, const opT &op)
Reduce op(item) for all items in range using op(sum,op(item)).
Definition world_task_queue.h:527
A parallel world class.
Definition world.h:132
static World * world_from_id(std::uint64_t id)
Convert a World ID to a World pointer.
Definition world.h:474
WorldTaskQueue & taskq
Task queue.
Definition world.h:204
ProcessID rank() const
Returns the process rank in this World (same as MPI_Comm_rank()).
Definition world.h:318
ProcessID size() const
Returns the number of processes in this World (same as MPI_Comm_size()).
Definition world.h:328
WorldGopInterface & gop
Global operations.
Definition world.h:205
std::optional< T * > ptr_from_id(uniqueidT id) const
Look up a local pointer from a world-wide unique ID.
Definition world.h:414
ProcessID random_proc()
Returns a random process number; that is, an integer in [0,world.size()).
Definition world.h:573
Wrapper for an opaque pointer for serialization purposes.
Definition archive.h:850
Class for unique global IDs.
Definition uniqueid.h:53
unsigned long get_obj_id() const
Access the object ID.
Definition uniqueid.h:97
unsigned long get_world_id() const
Access the World ID.
Definition uniqueid.h:90
static const double R
Definition csqrt.cc:46
double(* f1)(const coord_3d &)
Definition derivatives.cc:55
char * p(char *buf, const char *name, int k, int initial_level, double thresh, int order)
Definition derivatives.cc:72
static double lo
Definition dirac-hatom.cc:23
@ upper
Definition dirac-hatom.cc:15
Provides FunctionDefaults and utilities for coordinate transformation.
auto T(World &world, response_space &f) -> response_space
Definition global_functions.cc:34
archive_array< unsigned char > wrap_opaque(const T *, unsigned int)
Factory function to wrap a pointer to contiguous data as an opaque (uchar) archive_array.
Definition archive.h:925
Tensor< typename Tensor< T >::scalar_type > arg(const Tensor< T > &t)
Return a new tensor holding the argument of each element of t (complex types only)
Definition tensor.h:2502
Tensor< TENSOR_RESULT_TYPE(T, Q) > & fast_transform(const Tensor< T > &t, const Tensor< Q > &c, Tensor< TENSOR_RESULT_TYPE(T, Q) > &result, Tensor< TENSOR_RESULT_TYPE(T, Q) > &workspace)
Restricted but heavily optimized form of transform()
Definition tensor.h:2443
const double beta
Definition gygi_soltion.cc:62
static const double v
Definition hatom_sf_dirac.cc:20
Tensor< double > op(const Tensor< double > &x)
Definition kain.cc:508
Multidimension Key for MRA tree and associated iterators.
static double pow(const double *a, const double *b)
Definition lda.h:74
#define MADNESS_CHECK(condition)
Check a condition — even in a release build the condition is always evaluated so it can have side eff...
Definition madness_exception.h:182
#define MADNESS_EXCEPTION(msg, value)
Macro for throwing a MADNESS exception.
Definition madness_exception.h:119
#define MADNESS_ASSERT(condition)
Assert a condition that should be free of side-effects since in release builds this might be a no-op.
Definition madness_exception.h:134
#define MADNESS_CHECK_THROW(condition, msg)
Check a condition — even in a release build the condition is always evaluated so it can have side eff...
Definition madness_exception.h:207
Header to declare stuff which has not yet found a home.
const double pi
Mathematical constant .
Definition constants.h:48
MemFuncWrapper< objT *, memfnT, typename result_of< memfnT >::type > wrap_mem_fn(objT &obj, memfnT memfn)
Create a member function wrapper (MemFuncWrapper) from an object and a member function pointer.
Definition mem_func_wrapper.h:251
void combine_hash(hashT &seed, hashT hash)
Internal use only.
Definition worldhash.h:248
Namespace for all elements and tools of MADNESS.
Definition DFParameters.h:10
std::ostream & operator<<(std::ostream &os, const particle< PDIM > &p)
Definition lowrankfunction.h:397
static const char * filename
Definition legendre.cc:96
static const std::vector< Slice > ___
Entire dimension.
Definition slice.h:128
static double cpu_time()
Returns the cpu time in seconds relative to an arbitrary origin.
Definition timers.h:127
GenTensor< TENSOR_RESULT_TYPE(R, Q)> general_transform(const GenTensor< R > &t, const Tensor< Q > c[])
Definition gentensor.h:274
response_space scale(response_space a, double b)
void finalize()
Call this once at the very end of your main program instead of MPI_Finalize().
Definition world.cc:232
void norm_tree(World &world, const std::vector< Function< T, NDIM > > &v, bool fence=true)
Makes the norm tree for all functions in a vector.
Definition vmra.h:1147
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > transform(World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true)
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
Definition vmra.h:689
TreeState
Definition funcdefaults.h:58
@ nonstandard_after_apply
s and d coeffs, state after operator application
Definition funcdefaults.h:63
@ redundant_after_merge
s coeffs everywhere, must be summed up to yield the result
Definition funcdefaults.h:65
@ reconstructed
s coeffs at the leaves only
Definition funcdefaults.h:59
@ nonstandard
s and d coeffs in internal nodes
Definition funcdefaults.h:61
@ redundant
s coeffs everywhere
Definition funcdefaults.h:64
static Tensor< double > weights[max_npt+1]
Definition legendre.cc:99
int64_t Translation
Definition key.h:54
static const Slice _(0,-1, 1)
std::shared_ptr< FunctionFunctorInterface< double, 3 > > func(new opT(g))
void change_tensor_type(GenTensor< T > &t, const TensorArgs &targs)
change representation to targ.tt
Definition gentensor.h:284
int Level
Definition key.h:55
std::enable_if< std::is_base_of< ProjectorBase, projT >::value, OuterProjector< projT, projQ > >::type outer(const projT &p0, const projQ &p1)
Definition projector.h:457
int RandomValue< int >()
Random int.
Definition ran.cc:250
static double pop(std::vector< double > &v)
Definition SCF.cc:113
void print(const T &t, const Ts &... ts)
Print items to std::cout (items separated by spaces) and terminate with a new line.
Definition print.h:225
Tensor< T > fcube(const Key< NDIM > &, T(*f)(const Vector< double, NDIM > &), const Tensor< double > &)
Definition mraimpl.h:2163
TensorType
low rank representations of tensors (see gentensor.h)
Definition gentensor.h:120
@ TT_2D
Definition gentensor.h:120
@ TT_FULL
Definition gentensor.h:120
NDIM & f
Definition mra.h:2416
void error(const char *msg)
Definition world.cc:139
NDIM const Function< R, NDIM > & g
Definition mra.h:2416
std::size_t hashT
The hash value type.
Definition worldhash.h:145
static const int kmax
Definition twoscale.cc:52
double inner(response_space &a, response_space &b)
Definition response_functions.h:442
GenTensor< TENSOR_RESULT_TYPE(R, Q)> transform_dir(const GenTensor< R > &t, const Tensor< Q > &c, const int axis)
Definition lowranktensor.h:1099
std::string name(const FuncType &type, const int ex=-1)
Definition ccpairfunction.h:28
void mxmT(long dimi, long dimj, long dimk, T *MADNESS_RESTRICT c, const T *a, const T *b)
Matrix += Matrix * matrix transpose ... MKL interface version.
Definition mxm.h:225
Function< T, NDIM > copy(const Function< T, NDIM > &f, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool fence=true)
Create a new copy of the function with different distribution and optional fence.
Definition mra.h:2002
static const int MAXK
The maximum wavelet order presently supported.
Definition funcdefaults.h:51
static long abs(long a)
Definition tensor.h:218
const double cc
Definition navstokes_cosines.cc:107
static const double b
Definition nonlinschro.cc:119
static const double d
Definition nonlinschro.cc:121
static const double a
Definition nonlinschro.cc:118
Defines simple templates for printing to std::cout "a la Python".
double Q(double a)
Definition relops.cc:20
static const double c
Definition relops.cc:10
static const double L
Definition rk.cc:46
static const double thresh
Definition rk.cc:45
Definition test_ar.cc:204
Definition test_ccpairfunction.cc:22
given a ket and the 1- and 2-electron potentials, construct the function V phi
Definition funcimpl.h:3979
implT * result
where to construct Vphi, no need to track parents
Definition funcimpl.h:3987
bool have_v2() const
Definition funcimpl.h:3996
ctL iav1
Definition funcimpl.h:3991
Vphi_op_NS(implT *result, const opT &leaf_op, const ctT &iaket, const ctL &iap1, const ctL &iap2, const ctL &iav1, const ctL &iav2, const implT *eri)
Definition funcimpl.h:4005
ctL iap1
Definition funcimpl.h:3990
bool have_v1() const
Definition funcimpl.h:3995
std::pair< bool, coeffT > continue_recursion(const std::vector< bool > child_is_leaf, const tensorT &coeffs, const keyT &key) const
loop over all children and either insert their sum coeffs or continue the recursion
Definition funcimpl.h:4071
opT leaf_op
deciding if a given FunctionNode will be a leaf node
Definition funcimpl.h:3988
std::pair< coeffT, double > make_sum_coeffs(const keyT &key) const
make the sum coeffs for key
Definition funcimpl.h:4164
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:3984
ctL iap2
the particles 1 and 2 (exclusive with ket)
Definition funcimpl.h:3990
bool have_ket() const
Definition funcimpl.h:3994
const implT * eri
2-particle potential, must be on-demand
Definition funcimpl.h:3992
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:3985
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
make and insert the coefficients into result's tree
Definition funcimpl.h:4016
void serialize(const Archive &ar)
serialize this (needed for use in recursive_op)
Definition funcimpl.h:4245
Vphi_op_NS< opT, LDIM > this_type
Definition funcimpl.h:3983
ctT iaket
the ket of a pair function (exclusive with p1, p2)
Definition funcimpl.h:3989
double compute_error_from_inaccurate_refinement(const keyT &key, const tensorT &ceri) const
the error is computed from the d coefficients of the constituent functions
Definition funcimpl.h:4117
void accumulate_into_result(const Key< NDIM > &key, const coeffT &coeff) const
Definition funcimpl.h:3999
this_type make_child(const keyT &child) const
Definition funcimpl.h:4216
tensorT eri_coeffs(const keyT &key) const
Definition funcimpl.h:4097
ctL iav2
potentials for particles 1 and 2
Definition funcimpl.h:3991
bool have_eri() const
Definition funcimpl.h:3997
this_type forward_ctor(implT *result1, const opT &leaf_op, const ctT &iaket1, const ctL &iap11, const ctL &iap21, const ctL &iav11, const ctL &iav21, const implT *eri1)
Definition funcimpl.h:4238
Vphi_op_NS()
Definition funcimpl.h:4004
Future< this_type > activate() const
Definition funcimpl.h:4227
bool randomize() const
Definition funcimpl.h:3981
add two functions f and g: result=alpha * f + beta * g
Definition funcimpl.h:3494
bool randomize() const
Definition funcimpl.h:3499
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:3529
add_op(const ctT &f, const ctT &g, const double alpha, const double beta)
Definition funcimpl.h:3507
ctT f
tracking coeffs of first and second addend
Definition funcimpl.h:3502
double alpha
prefactor for f, g
Definition funcimpl.h:3504
add_op this_type
Definition funcimpl.h:3497
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:3496
void serialize(const Archive &ar)
Definition funcimpl.h:3541
ctT g
Definition funcimpl.h:3502
std::pair< bool, coeffT > operator()(const keyT &key) const
if we are at the bottom of the trees, return the sum of the coeffs
Definition funcimpl.h:3511
double beta
Definition funcimpl.h:3504
this_type make_child(const keyT &child) const
Definition funcimpl.h:3524
this_type forward_ctor(const ctT &f1, const ctT &g1, const double alpha, const double beta)
taskq-compatible ctor
Definition funcimpl.h:3537
Definition funcimpl.h:3109
opT op
Definition funcimpl.h:3112
opT::resultT resultT
Definition funcimpl.h:3110
Tensor< resultT > operator()(const Key< NDIM > &key, const Tensor< Q > &t) const
Definition funcimpl.h:3119
coeff_value_adaptor(const FunctionImpl< Q, NDIM > *impl_func, const opT &op)
Definition funcimpl.h:3115
const FunctionImpl< Q, NDIM > * impl_func
Definition funcimpl.h:3111
coeff_value_adaptor()=default
void serialize(Archive &ar)
Definition funcimpl.h:3128
merge the coefficent boxes of this into result's tree
Definition funcimpl.h:2351
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2352
do_accumulate_trees()=default
void serialize(const Archive &ar)
Definition funcimpl.h:2369
FunctionImpl< Q, NDIM > * result
Definition funcimpl.h:2353
do_accumulate_trees(FunctionImpl< Q, NDIM > &result, const T alpha)
Definition funcimpl.h:2356
T alpha
Definition funcimpl.h:2354
bool operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2360
"put" this on g
Definition funcimpl.h:2562
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2563
void serialize(const Archive &ar)
Definition funcimpl.h:2591
implT * g
Definition funcimpl.h:2565
do_average()
Definition funcimpl.h:2567
bool operator()(typename rangeT::iterator &it) const
iterator it points to this
Definition funcimpl.h:2571
do_average(implT &g)
Definition funcimpl.h:2568
change representation of nodes' coeffs to low rank, optional fence
Definition funcimpl.h:2595
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2596
void serialize(const Archive &ar)
Definition funcimpl.h:2619
TensorArgs targs
Definition funcimpl.h:2599
do_change_tensor_type(const TensorArgs &targs, implT &g)
Definition funcimpl.h:2605
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2608
implT * f
Definition funcimpl.h:2600
do_change_tensor_type()=default
check symmetry wrt particle exchange
Definition funcimpl.h:2268
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2269
double operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2275
do_check_symmetry_local()
Definition funcimpl.h:2271
void serialize(const Archive &ar)
Definition funcimpl.h:2338
double operator()(double a, double b) const
Definition funcimpl.h:2334
do_check_symmetry_local(const implT &f)
Definition funcimpl.h:2272
const implT * f
Definition funcimpl.h:2270
compute the norm of the wavelet coefficients
Definition funcimpl.h:4386
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:4387
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:4393
do_compute_snorm_and_dnorm(const FunctionCommonData< T, NDIM > &cdata)
Definition funcimpl.h:4390
const FunctionCommonData< T, NDIM > & cdata
Definition funcimpl.h:4389
Definition funcimpl.h:2622
TensorArgs targs
Definition funcimpl.h:2626
do_consolidate_buffer()=default
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2631
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2623
do_consolidate_buffer(const TensorArgs &targs)
Definition funcimpl.h:2630
void serialize(const Archive &ar)
Definition funcimpl.h:2635
Definition funcimpl.h:1384
double operator()(double val) const
Definition funcimpl.h:1390
double limit
Definition funcimpl.h:1385
do_convert_to_color(const double limit, const bool log)
Definition funcimpl.h:1389
bool log
Definition funcimpl.h:1386
do_convert_to_color()=default
static double lower()
Definition funcimpl.h:1387
functor for the gaxpy_inplace method
Definition funcimpl.h:1181
FunctionImpl< T, NDIM > * f
prefactor for current function impl
Definition funcimpl.h:1183
do_gaxpy_inplace(FunctionImpl< T, NDIM > *f, T alpha, R beta)
Definition funcimpl.h:1187
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:1188
R beta
prefactor for other function impl
Definition funcimpl.h:1185
void serialize(Archive &ar)
Definition funcimpl.h:1196
Range< typename FunctionImpl< Q, NDIM >::dcT::const_iterator > rangeT
Definition funcimpl.h:1182
T alpha
the current function impl
Definition funcimpl.h:1184
do_gaxpy_inplace()=default
Definition funcimpl.h:6457
const bool do_leaves
start with leaf nodes instead of initial_level
Definition funcimpl.h:6461
T operator()(T a, T b) const
Definition funcimpl.h:6479
do_inner_ext_local_ffi(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const implT *impl, const bool leaf_refine, const bool do_leaves)
Definition funcimpl.h:6463
void serialize(const Archive &ar)
Definition funcimpl.h:6483
const bool leaf_refine
Definition funcimpl.h:6460
const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > fref
Definition funcimpl.h:6458
T operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:6467
const implT * impl
Definition funcimpl.h:6459
compute the inner product of this range with other
Definition funcimpl.h:5463
const FunctionImpl< T, NDIM > * bra
Definition funcimpl.h:5464
void serialize(const Archive &ar)
Definition funcimpl.h:5579
const FunctionImpl< R, NDIM > * ket
Definition funcimpl.h:5465
typedef TENSOR_RESULT_TYPE(T, R) resultT
bool leaves_only
Definition funcimpl.h:5466
do_inner_local_on_demand(const FunctionImpl< T, NDIM > *bra, const FunctionImpl< R, NDIM > *ket, const bool leaves_only=true)
Definition funcimpl.h:5469
resultT operator()(resultT a, resultT b) const
Definition funcimpl.h:5575
resultT operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5472
compute the inner product of this range with other
Definition funcimpl.h:5402
resultT operator()(resultT a, resultT b) const
Definition funcimpl.h:5435
bool leaves_only
Definition funcimpl.h:5404
void serialize(const Archive &ar)
Definition funcimpl.h:5439
do_inner_local(const FunctionImpl< R, NDIM > *other, const bool leaves_only)
Definition funcimpl.h:5407
const FunctionImpl< R, NDIM > * other
Definition funcimpl.h:5403
resultT operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5409
typedef TENSOR_RESULT_TYPE(T, R) resultT
keep only the sum coefficients in each node
Definition funcimpl.h:2222
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2223
do_keep_sum_coeffs(implT *impl)
constructor need impl for cdata
Definition funcimpl.h:2227
implT * impl
Definition funcimpl.h:2224
void serialize(const Archive &ar)
Definition funcimpl.h:2236
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2229
mirror dimensions of this, write result on f
Definition funcimpl.h:2496
do_map_and_mirror()=default
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2506
implT * f
Definition funcimpl.h:2500
std::vector< long > mirror
Definition funcimpl.h:2499
void serialize(const Archive &ar)
Definition funcimpl.h:2553
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2497
std::vector< long > map
Definition funcimpl.h:2499
do_map_and_mirror(const std::vector< long > map, const std::vector< long > mirror, implT &f)
Definition funcimpl.h:2503
map this on f
Definition funcimpl.h:2416
do_mapdim(const std::vector< long > map, implT &f)
Definition funcimpl.h:2423
void serialize(const Archive &ar)
Definition funcimpl.h:2439
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2417
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2425
std::vector< long > map
Definition funcimpl.h:2419
do_mapdim()
Definition funcimpl.h:2422
implT * f
Definition funcimpl.h:2420
merge the coefficent boxes of this into other's tree
Definition funcimpl.h:2380
bool operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2390
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2381
FunctionImpl< Q, NDIM > * other
Definition funcimpl.h:2382
do_merge_trees(const T alpha, const R beta, FunctionImpl< Q, NDIM > &other)
Definition funcimpl.h:2386
T alpha
Definition funcimpl.h:2383
do_merge_trees()
Definition funcimpl.h:2385
R beta
Definition funcimpl.h:2384
void serialize(const Archive &ar)
Definition funcimpl.h:2409
mirror dimensions of this, write result on f
Definition funcimpl.h:2446
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2455
implT * f
Definition funcimpl.h:2450
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2447
do_mirror()
Definition funcimpl.h:2452
do_mirror(const std::vector< long > mirror, implT &f)
Definition funcimpl.h:2453
void serialize(const Archive &ar)
Definition funcimpl.h:2489
std::vector< long > mirror
Definition funcimpl.h:2449
Definition funcimpl.h:5375
double operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5376
void serialize(const Archive &ar)
Definition funcimpl.h:5391
double operator()(double a, double b) const
Definition funcimpl.h:5387
laziness
Definition funcimpl.h:4643
void serialize(Archive &ar)
Definition funcimpl.h:4652
Key< OPDIM > d
Definition funcimpl.h:4644
Key< OPDIM > key
Definition funcimpl.h:4644
keyT dest
Definition funcimpl.h:4645
double fac
Definition funcimpl.h:4646
do_op_args(const Key< OPDIM > &key, const Key< OPDIM > &d, const keyT &dest, double tol, double fac, double cnorm)
Definition funcimpl.h:4649
double cnorm
Definition funcimpl.h:4646
double tol
Definition funcimpl.h:4646
reduce the rank of the nodes, optional fence
Definition funcimpl.h:2242
do_reduce_rank(const TensorArgs &targs)
Definition funcimpl.h:2250
TensorArgs args
Definition funcimpl.h:2246
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2256
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2243
do_reduce_rank(const double &thresh)
Definition funcimpl.h:2251
void serialize(const Archive &ar)
Definition funcimpl.h:2262
Changes non-standard compressed form to standard compressed form.
Definition funcimpl.h:4607
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:4618
do_standard(implT *impl)
Definition funcimpl.h:4615
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:4608
void serialize(const Archive &ar)
Definition funcimpl.h:4635
implT * impl
Definition funcimpl.h:4611
given an NS tree resulting from a convolution, truncate leafs if appropriate
Definition funcimpl.h:2163
void serialize(const Archive &ar)
Definition funcimpl.h:2183
const implT * f
Definition funcimpl.h:2165
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2169
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2164
do_truncate_NS_leafs(const implT *f)
Definition funcimpl.h:2167
Definition funcimpl.h:2641
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2642
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2646
implT * impl
Definition funcimpl.h:2643
void serialize(const Archive &ar)
Definition funcimpl.h:2664
opT op
Definition funcimpl.h:2644
do_unary_op_value_inplace(implT *impl, const opT &op)
Definition funcimpl.h:2645
Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function.
Definition funcimpl.h:3577
this_type forward_ctor(implT *result1, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
Definition funcimpl.h:3633
bool randomize() const
Definition funcimpl.h:3578
void serialize(const Archive &ar)
Definition funcimpl.h:3637
hartree_op(implT *result, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
Definition funcimpl.h:3589
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:3581
ctL p2
tracking coeffs of the two lo-dim functions
Definition funcimpl.h:3584
leaf_opT leaf_op
determine if a given node will be a leaf node
Definition funcimpl.h:3585
hartree_op()
Definition funcimpl.h:3588
implT * result
where to construct the pair function
Definition funcimpl.h:3583
hartree_op< LDIM, leaf_opT > this_type
Definition funcimpl.h:3580
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
Definition funcimpl.h:3594
ctL p1
Definition funcimpl.h:3584
this_type make_child(const keyT &child) const
Definition funcimpl.h:3617
Future< this_type > activate() const
Definition funcimpl.h:3626
perform this multiplication: h(1,2) = f(1,2) * g(1)
Definition funcimpl.h:3385
multiply_op()
Definition funcimpl.h:3397
ctL g
Definition funcimpl.h:3394
Future< this_type > activate() const
Definition funcimpl.h:3476
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:3389
implT * h
the result function h(1,2) = f(1,2) * g(1)
Definition funcimpl.h:3392
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:3388
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
apply this on a FunctionNode of f and g of Key key
Definition funcimpl.h:3424
this_type forward_ctor(implT *h1, const ctT &f1, const ctL &g1, const int particle)
Definition funcimpl.h:3483
static bool randomize()
Definition funcimpl.h:3387
int particle
if g is g(1) or g(2)
Definition funcimpl.h:3395
ctT f
Definition funcimpl.h:3393
multiply_op< LDIM > this_type
Definition funcimpl.h:3390
multiply_op(implT *h1, const ctT &f1, const ctL &g1, const int particle1)
Definition funcimpl.h:3399
bool screen(const coeffT &fcoeff, const coeffT &gcoeff, const keyT &key) const
return true if this will be a leaf node
Definition funcimpl.h:3405
this_type make_child(const keyT &child) const
Definition funcimpl.h:3466
void serialize(const Archive &ar)
Definition funcimpl.h:3487
Definition funcimpl.h:3858
coeffT val_lhs
Definition funcimpl.h:3859
double lo
Definition funcimpl.h:3862
double lo1
Definition funcimpl.h:3862
long oversampling
Definition funcimpl.h:3860
pointwise_multiplier()=default
double error
Definition funcimpl.h:3861
tensorT operator()(const Key< NDIM > key, const tensorT &coeff_rhs)
multiply values of rhs and lhs, result on rhs, rhs and lhs are of the same dimensions
Definition funcimpl.h:3877
coeffT coeff_lhs
Definition funcimpl.h:3859
void serialize(const Archive &ar)
Definition funcimpl.h:3965
double lo2
Definition funcimpl.h:3862
double hi1
Definition funcimpl.h:3862
pointwise_multiplier(const Key< NDIM > key, const coeffT &clhs)
Definition funcimpl.h:3865
coeffT operator()(const Key< NDIM > key, const tensorT &coeff_rhs, const int particle)
multiply values of rhs and lhs, result on rhs, rhs and lhs are of differnet dimensions
Definition funcimpl.h:3922
double hi2
Definition funcimpl.h:3862
double hi
Definition funcimpl.h:3862
project the low-dim function g on the hi-dim function f: result(x) = <f(x,y) | g(y)>
Definition funcimpl.h:6723
project_out_op(const implT *fimpl, implL1 *result, const ctL &iag, const int dim)
Definition funcimpl.h:6738
ctL iag
the low dim function g
Definition funcimpl.h:6733
FunctionImpl< T, NDIM-LDIM > implL1
Definition funcimpl.h:6728
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:6817
std::pair< bool, coeffT > argT
Definition funcimpl.h:6729
const implT * fimpl
the hi dim function f
Definition funcimpl.h:6731
this_type forward_ctor(const implT *fimpl1, implL1 *result1, const ctL &iag1, const int dim1)
taskq-compatible ctor
Definition funcimpl.h:6824
this_type make_child(const keyT &child) const
Definition funcimpl.h:6808
project_out_op< LDIM > this_type
Definition funcimpl.h:6726
implL1 * result
the low dim result function
Definition funcimpl.h:6732
Future< argT > operator()(const Key< NDIM > &key) const
do the actual contraction
Definition funcimpl.h:6745
void serialize(const Archive &ar)
Definition funcimpl.h:6828
project_out_op(const project_out_op &other)
Definition funcimpl.h:6740
int dim
0: project 0..LDIM-1, 1: project LDIM..NDIM-1
Definition funcimpl.h:6734
bool randomize() const
Definition funcimpl.h:6724
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:6727
recursive part of recursive_apply
Definition funcimpl.h:5202
ctT iaf
Definition funcimpl.h:5210
recursive_apply_op2< opT > this_type
Definition funcimpl.h:5205
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:5265
const opT * apply_op
need this for randomization
Definition funcimpl.h:5211
bool randomize() const
Definition funcimpl.h:5203
recursive_apply_op2(const recursive_apply_op2 &other)
Definition funcimpl.h:5218
void serialize(const Archive &ar)
Definition funcimpl.h:5281
argT finalize(const double kernel_norm, const keyT &key, const coeffT &coeff, const implT *r) const
sole purpose is to wait for the kernel norm, wrap it and send it back to caller
Definition funcimpl.h:5251
this_type make_child(const keyT &child) const
Definition funcimpl.h:5260
recursive_apply_op2()=default
recursive_apply_op2(implT *result, const ctT &iaf, const opT *apply_op)
Definition funcimpl.h:5215
std::pair< bool, coeffT > argT
Definition funcimpl.h:5207
implT * result
Definition funcimpl.h:5209
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:5206
argT operator()(const Key< NDIM > &key) const
send off the application of the operator
Definition funcimpl.h:5227
this_type forward_ctor(implT *result1, const ctT &iaf1, const opT *apply_op1)
taskq-compatible ctor
Definition funcimpl.h:5277
recursive part of recursive_apply
Definition funcimpl.h:5071
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
make the NS-coefficients and send off the application of the operator
Definition funcimpl.h:5096
this_type forward_ctor(implT *r, const CoeffTracker< T, LDIM > &f1, const CoeffTracker< T, LDIM > &g1, const opT *apply_op1)
Definition funcimpl.h:5161
opT * apply_op
Definition funcimpl.h:5079
recursive_apply_op(const recursive_apply_op &other)
Definition funcimpl.h:5089
recursive_apply_op< opT, LDIM > this_type
Definition funcimpl.h:5074
Future< this_type > activate() const
Definition funcimpl.h:5154
bool randomize() const
Definition funcimpl.h:5072
implT * result
Definition funcimpl.h:5076
CoeffTracker< T, LDIM > iaf
Definition funcimpl.h:5077
void serialize(const Archive &ar)
Definition funcimpl.h:5166
recursive_apply_op()=default
std::pair< bool, coeffT > finalize(const double kernel_norm, const keyT &key, const coeffT &coeff) const
sole purpose is to wait for the kernel norm, wrap it and send it back to caller
Definition funcimpl.h:5136
recursive_apply_op(implT *result, const CoeffTracker< T, LDIM > &iaf, const CoeffTracker< T, LDIM > &iag, const opT *apply_op)
Definition funcimpl.h:5083
this_type make_child(const keyT &child) const
Definition funcimpl.h:5145
CoeffTracker< T, LDIM > iag
Definition funcimpl.h:5078
remove all coefficients of internal nodes
Definition funcimpl.h:2188
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2189
remove_internal_coeffs()=default
constructor need impl for cdata
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2194
void serialize(const Archive &ar)
Definition funcimpl.h:2200
remove all coefficients of leaf nodes
Definition funcimpl.h:2205
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2211
remove_leaf_coeffs()=default
constructor need impl for cdata
void serialize(const Archive &ar)
Definition funcimpl.h:2216
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2206
Definition funcimpl.h:4458
void serialize(Archive &ar)
Definition funcimpl.h:4462
bool operator()(const implT *f, const keyT &key, const nodeT &t) const
Definition funcimpl.h:4459
shallow-copy, pared-down version of FunctionNode, for special purpose only
Definition funcimpl.h:746
coeffT & coeff()
Definition funcimpl.h:760
GenTensor< T > coeffT
Definition funcimpl.h:747
bool is_leaf() const
Definition funcimpl.h:762
void serialize(Archive &ar)
Definition funcimpl.h:764
ShallowNode(const ShallowNode< T, NDIM > &node)
Definition funcimpl.h:755
ShallowNode(const FunctionNode< T, NDIM > &node)
Definition funcimpl.h:752
bool has_children() const
Definition funcimpl.h:761
ShallowNode()
Definition funcimpl.h:751
bool _has_children
Definition funcimpl.h:749
double dnorm
Definition funcimpl.h:750
const coeffT & coeff() const
Definition funcimpl.h:759
coeffT _coeffs
Definition funcimpl.h:748
TensorArgs holds the arguments for creating a LowRankTensor.
Definition gentensor.h:134
double thresh
Definition gentensor.h:135
TensorType tt
Definition gentensor.h:136
inserts/accumulates coefficients into impl's tree
Definition funcimpl.h:713
FunctionImpl< T, NDIM > * impl
Definition funcimpl.h:717
FunctionNode< T, NDIM > nodeT
Definition funcimpl.h:715
accumulate_op(const accumulate_op &other)=default
void operator()(const Key< NDIM > &key, const coeffT &coeff, const bool &is_leaf) const
Definition funcimpl.h:721
void serialize(Archive &ar)
Definition funcimpl.h:725
GenTensor< T > coeffT
Definition funcimpl.h:714
accumulate_op(FunctionImpl< T, NDIM > *f)
Definition funcimpl.h:719
static void load(const Archive &ar, FunctionImpl< T, NDIM > *&ptr)
Definition funcimpl.h:7044
static void load(const Archive &ar, const FunctionImpl< T, NDIM > *&ptr)
Definition funcimpl.h:7013
static void load(const Archive &ar, std::shared_ptr< FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7092
static void load(const Archive &ar, std::shared_ptr< const FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7076
Default load of an object via serialize(ar, t).
Definition archive.h:666
static void load(const A &ar, const U &t)
Load an object.
Definition archive.h:678
static void store(const Archive &ar, FunctionImpl< T, NDIM > *const &ptr)
Definition funcimpl.h:7066
static void store(const Archive &ar, const FunctionImpl< T, NDIM > *const &ptr)
Definition funcimpl.h:7035
static void store(const Archive &ar, const std::shared_ptr< FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7101
static void store(const Archive &ar, const std::shared_ptr< const FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7085
Default store of an object via serialize(ar, t).
Definition archive.h:611
static std::enable_if_t< is_output_archive_v< A > &&!std::is_function< U >::value &&(has_member_serialize_v< U, A >||has_nonmember_serialize_v< U, A >||has_freestanding_serialize_v< U, A >||has_freestanding_default_serialize_v< U, A >), void > store(const A &ar, const U &t)
Definition archive.h:621
Definition funcimpl.h:607
void serialize(Archive &ar)
Definition funcimpl.h:671
const opT * op
Definition funcimpl.h:614
hartree_convolute_leaf_op(const implT *f, const implL *g, const opT *op)
Definition funcimpl.h:618
bool operator()(const Key< NDIM > &key) const
no pre-determination
Definition funcimpl.h:622
hartree_convolute_leaf_op()=default
bool operator()(const Key< NDIM > &key, const Tensor< T > &fcoeff, const Tensor< T > &gcoeff) const
post-determination: true if f is a leaf and the result is well-represented
Definition funcimpl.h:635
const implL * g
Definition funcimpl.h:613
const FunctionImpl< T, NDIM > * f
Definition funcimpl.h:612
FunctionImpl< T, LDIM > implL
Definition funcimpl.h:610
bool do_error_leaf_op() const
Definition funcimpl.h:615
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:609
bool operator()(const Key< NDIM > &key, const GenTensor< T > &coeff) const
no post-determination
Definition funcimpl.h:625
returns true if the result of a hartree_product is a leaf node (compute norm & error)
Definition funcimpl.h:497
hartree_leaf_op()=default
bool do_error_leaf_op() const
Definition funcimpl.h:502
const FunctionImpl< T, NDIM > * f
Definition funcimpl.h:500
hartree_leaf_op(const implT *f, const long &k)
Definition funcimpl.h:505
long k
Definition funcimpl.h:501
void serialize(Archive &ar)
Definition funcimpl.h:553
bool operator()(const Key< NDIM > &key, const GenTensor< T > &coeff) const
no post-determination
Definition funcimpl.h:511
bool operator()(const Key< NDIM > &key, const Tensor< T > &fcoeff, const Tensor< T > &gcoeff) const
post-determination: true if f is a leaf and the result is well-represented
Definition funcimpl.h:521
bool operator()(const Key< NDIM > &key) const
no pre-determination
Definition funcimpl.h:508
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:499
insert/replaces the coefficients into the function
Definition funcimpl.h:689
insert_op()
Definition funcimpl.h:696
implT * impl
Definition funcimpl.h:695
void operator()(const keyT &key, const coeffT &coeff, const bool &is_leaf) const
Definition funcimpl.h:699
FunctionNode< T, NDIM > nodeT
Definition funcimpl.h:693
Key< NDIM > keyT
Definition funcimpl.h:691
insert_op(const insert_op &other)
Definition funcimpl.h:698
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:690
GenTensor< T > coeffT
Definition funcimpl.h:692
insert_op(implT *f)
Definition funcimpl.h:697
void serialize(Archive &ar)
Definition funcimpl.h:703
Definition funcimpl.h:677
bool operator()(const Key< NDIM > &key, const GenTensor< T > &fcoeff, const GenTensor< T > &gcoeff) const
Definition funcimpl.h:679
void serialize(Archive &ar)
Definition funcimpl.h:683
void operator()(const Key< NDIM > &key, const GenTensor< T > &coeff, const bool &is_leaf) const
Definition funcimpl.h:678
Definition funcimpl.h:561
bool operator()(const Key< NDIM > &key, const double &cnorm) const
post-determination: return true if operator and coefficient norms are small
Definition funcimpl.h:582
void serialize(Archive &ar)
Definition funcimpl.h:597
const implT * f
the source or result function, needed for truncate_tol
Definition funcimpl.h:565
op_leaf_op(const opT *op, const implT *f)
Definition funcimpl.h:569
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:562
const opT * op
the convolution operator
Definition funcimpl.h:564
bool do_error_leaf_op() const
Definition funcimpl.h:566
bool operator()(const Key< NDIM > &key) const
pre-determination: we can't know if this will be a leaf node before we got the final coeffs
Definition funcimpl.h:572
bool operator()(const Key< NDIM > &key, const GenTensor< T > &coeff) const
post-determination: return true if operator and coefficient norms are small
Definition funcimpl.h:575
Definition lowrankfunction.h:332
Definition funcimpl.h:733
void serialize(Archive &ar)
Definition funcimpl.h:740
bool operator()(const Key< NDIM > &key, const T &t, const R &r) const
Definition funcimpl.h:739
bool operator()(const Key< NDIM > &key, const T &t) const
Definition funcimpl.h:736
int np
Definition tdse1d.cc:165
static const double s0
Definition tdse4.cc:83
Defines and implements most of Tensor.
#define ITERATOR(t, exp)
Definition tensor_macros.h:249
#define IND
Definition tensor_macros.h:204
#define TERNARY_OPTIMIZED_ITERATOR(X, x, Y, y, Z, z, exp)
Definition tensor_macros.h:719
AtomicInt sum
Definition test_atomicint.cc:46
double norm(const T i1)
Definition test_cloud.cc:72
int task(int i)
Definition test_runtime.cpp:4
void e()
Definition test_sig.cc:75
static const double alpha
Definition testcosine.cc:10
const double offset
Definition testfuns.cc:143
double h(const coord_1d &r)
Definition testgconv.cc:68
static const std::size_t NDIM
Definition testpdiff.cc:42
std::size_t axis
Definition testpdiff.cc:59
double source(const coordT &r)
Definition testperiodic.cc:48
#define TENSOR_RESULT_TYPE(L, R)
This macro simplifies access to TensorResultType.
Definition type_data.h:205
#define PROFILE_MEMBER_FUNC(classname)
Definition worldprofile.h:210
#define PROFILE_BLOCK(name)
Definition worldprofile.h:208
int ProcessID
Used to clearly identify process number/rank.
Definition worldtypes.h:43