32#ifndef MADNESS_MRA_FUNCIMPL_H__INCLUDED
33#define MADNESS_MRA_FUNCIMPL_H__INCLUDED
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>
70 template<
typename T, std::
size_t NDIM>
71 class FunctionFactory;
73 template<
typename T, std::
size_t NDIM, std::
size_t MDIM>
74 class CompositeFunctorInterface;
85 template<
typename keyT>
104 template <
typename keyT>
115 Level n = key.level();
116 if (n == 0)
return 0;
118 if (n <= 3 || (n&0x1)) hash = key.
hash();
126 template<
typename T, std::
size_t NDIM>
177 if (
this != &other) {
288 print(
"set_coeff: may have a problem");
289 print(
"set_coeff: coeff.dim[0] =", coeffs.
dim(0),
", 2* MAXK =", 2*
MAXK);
300 template <
typename Q>
339 }
else if (
coeff().dim(0) == cdata.
vk[0]) {
342 }
else if (
coeff().is_full_tensor()) {
348 }
else if (
coeff().is_svd_tensor()) {
364 template <
typename Q,
typename R>
405 if (
c.is_local(parent))
436 if (
c.is_local(parent))
454 return this->_coeffs.trace_conj((rhs.
_coeffs));
457 template <
typename Archive>
467 s <<
"\"has_coeff\":" << this->
has_coeff()
468 <<
",\"has_children\":" << this->
has_children() <<
",\"norm\":";
475 s <<
norm <<
",\"norm_tree\":" << nt <<
",\"snorm\":"
478 if (this->
coeff().is_assigned())
479 s <<
",\"dim\":" << this->
coeff().
dim(0);
484 template <
typename T, std::
size_t NDIM>
491 if (nt == 1e300) nt = 0.0;
499 template<
typename T,
size_t NDIM>
526 if (key.
level()<2)
return false;
528 std::vector<Slice>
s0(
NDIM/2,s);
530 const double tol=
f->get_thresh();
531 const double thresh=
f->truncate_tol(tol, key)*0.3;
533 const double fnorm=fcoeff.
normf();
534 const double gnorm=gcoeff.
normf();
537 const double norm=fnorm*gnorm;
541 const double sfnorm=fcoeff(
s0).
normf();
542 const double sgnorm=gcoeff(
s0).
normf();
546 const double ferror=sqrt(
std::abs(fnorm*fnorm-sfnorm*sfnorm));
547 const double gerror=sqrt(
std::abs(gnorm*gnorm-sgnorm*sgnorm));
550 const double error=fnorm*gerror + ferror*gnorm + ferror*gerror;
556 template <
typename Archive>
void serialize (Archive& ar) {
563 template<
typename T,
size_t NDIM,
typename opT>
579 if (key.
level()<2)
return false;
580 const double cnorm=coeff.
normf();
586 if (key.
level()<2)
return false;
589 const opkeyT
source=
op->get_source_key(key);
592 const std::vector<opkeyT>& disp =
op->get_disp(key.
level());
593 const opkeyT&
d = *disp.begin();
595 const double norm=opnorm*cnorm;
600 template <
typename Archive>
void serialize (Archive& ar) {
609 template<
typename T,
size_t NDIM,
size_t LDIM,
typename opT>
641 if (key.
level()<2)
return false;
643 const double tol=
f->get_thresh();
644 const double thresh=
f->truncate_tol(tol, key);
646 const double fnorm=fcoeff.
normf();
647 const double gnorm=gcoeff.
normf();
650 const double sfnorm=fcoeff(
g->get_cdata().s0).
normf();
651 const double sgnorm=gcoeff(
g->get_cdata().s0).
normf();
654 const double norm=fnorm*gnorm;
658 const double ferror=sqrt(fnorm*fnorm-sfnorm*sfnorm);
659 const double gerror=sqrt(gnorm*gnorm-sgnorm*sgnorm);
662 const double error=fnorm*gerror + ferror*gnorm + ferror*gerror;
666 const std::vector<Key<NDIM> >& disp =
op->get_disp(key.
level());
668 const double opnorm =
op->norm(key.
level(),
d, key);
669 const double final_norm=opnorm*sfnorm*sgnorm;
670 if (final_norm <
thresh)
return true;
674 template <
typename Archive>
void serialize (Archive& ar) {
679 template<
typename T,
size_t NDIM>
686 template <
typename Archive>
void serialize (Archive& ar) {}
691 template<
typename T, std::
size_t NDIM>
706 template <
typename Archive>
void serialize (Archive& ar) {
715 template<
typename T, std::
size_t NDIM>
726 impl->get_coeffs().task(key, &nodeT::accumulate, coeff,
impl->get_coeffs(), key,
impl->get_tensor_args());
728 template <
typename Archive>
void serialize (Archive& ar) {
741 template<
typename T,
typename R>
743 template <
typename Archive>
void serialize (Archive& ar) {}
748 template<
typename T, std::
size_t NDIM>
757 dnorm(node.get_dnorm()) {}
766 template <
typename Archive>
790 template<
typename T,
size_t NDIM>
915 template <
typename Archive>
void serialize(
const Archive& ar) {
922 template<
typename T, std::
size_t NDIM>
944 template <
typename T, std::
size_t NDIM>
951 typedef std::shared_ptr< FunctionImpl<T,NDIM> >
pimplT;
958 typedef std::pair<const keyT,nodeT>
datumT;
985 std::shared_ptr< FunctionFunctorInterface<T,NDIM> >
functor;
1006 ,
world(factory._world)
1008 ,
thresh(factory._thresh)
1034 bool do_refine = factory.
_refine;
1044 std::vector<coordT> functor_special_points=
functor->special_points();
1045 if (!functor_special_points.empty())
special_points.insert(
special_points.end(), functor_special_points.begin(), functor_special_points.end());
1051 if (it->second.is_leaf())
1072 template <
typename Q>
1086 template <
typename Q>
1119 const std::shared_ptr< WorldDCPmapInterface< Key<NDIM> > >&
get_pmap()
const;
1127 currentmap->redistribute(
world,newmap);
1133 template <
typename Q>
1143 template<
typename Q>
1146 copy_remote_coeffs_from_pid<Q>(pid, other,
false);
1152 template <
typename Q>
1155 auto v=other.
task(pid, &implQ::serialize_remote_coeffs).get();
1163 std::vector<unsigned char>
v;
1170 template <
typename Q>
1172 for (
const auto& [key, node] : other.
coeffs) {
1184 template<
typename Q,
typename R>
1204 template<
typename Q,
typename R>
1216 template<
typename Q,
typename R>
1233 const double beta,
const implT&
g,
const bool fence);
1236 template <
typename Q,
typename R>
1245 const keyT& key = it->first;
1248 f->coeffs.send(key, &nodeT:: template gaxpy_inplace<Q,R>,
alpha, other_node,
beta);
1251 template <
typename Archive>
1264 template <
typename Q,
typename R>
1277 template <
typename Archive>
1295 template <
typename Archive>
1335 std::shared_ptr<FunctionFunctorInterface<T,NDIM> >
get_functor();
1337 std::shared_ptr<FunctionFunctorInterface<T,NDIM> >
get_functor()
const;
1386 void truncate(
double tol,
bool fence);
1423 void print_tree(std::ostream& os = std::cout,
Level maxlevel = 10000)
const;
1456 double val2=log10(val) - log10(
lower());
1458 val2=0.7-(0.7/
upper)*val2;
1459 color= std::max(0.0,val2);
1460 color= std::min(0.7,color);
1462 double hue=0.7-(0.7/
limit)*(val);
1463 color= std::max(0.0,hue);
1490 const int xaxis,
const int yaxis,
const coordT el2);
1512 template<
size_t FDIM>
1513 typename std::enable_if<NDIM==FDIM>::type
1514 read_grid(
const std::string keyfile,
const std::string gridfile,
1517 std::ifstream kfile(keyfile.c_str());
1518 std::ifstream gfile(gridfile.c_str());
1522 if (not (std::getline(kfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of key data",0);
1523 if (not (std::istringstream(line) >> ndata))
MADNESS_EXCEPTION(
"failed reading k",0);
1524 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of grid data",0);
1525 if (not (std::istringstream(line) >> ndata1))
MADNESS_EXCEPTION(
"failed reading k",0);
1527 if (not (std::getline(kfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of key data",0);
1528 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of grid data",0);
1532 const size_t npt = qx.
dim(0);
1535 long npoints=power<NDIM>(npt);
1537 long nboxes=ndata/npoints;
1539 print(
"reading ",nboxes,
"boxes from file",gridfile,keyfile);
1545 std::string gline,kline;
1547 while (std::getline(kfile,kline)) {
1549 double x,y,z,x1,y1,z1,val;
1556 std::stringstream(kline) >> nn >> l1 >> l2 >> l3;
1564 const double h = std::pow(0.5,
double(n));
1571 for (
size_t i=0; i<npt; ++i) {
1572 c[0] = cell(0,0) +
h*cell_width[0]*(l[0] + qx(i));
1573 for (
size_t j=0; j<npt; ++j) {
1574 c[1] = cell(1,0) +
h*cell_width[1]*(l[1] + qx(j));
1575 for (
size_t k=0;
k<npt; ++
k) {
1576 c[2] = cell(2,0) +
h*cell_width[2]*(l[2] + qx(
k));
1578 auto& success1 = std::getline(gfile,gline);
MADNESS_CHECK(success1);
1579 auto& success2 = std::getline(kfile,kline);
MADNESS_CHECK(success2);
1580 std::istringstream(gline) >> x >> y >> z >> val;
1581 std::istringstream(kline) >> x1 >> y1 >> z1;
1590 if (vnuc_functor) val-=(*vnuc_functor)(
c);
1600 const bool has_children=
false;
1602 nodeT node(coeff,has_children);
1619 template<
size_t FDIM>
1620 typename std::enable_if<NDIM==FDIM>::type
1624 std::ifstream gfile(gridfile.c_str());
1628 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 1st line of grid data",0);
1629 if (not (std::istringstream(line) >> ndata))
MADNESS_EXCEPTION(
"failed reading k",0);
1630 if (not (std::getline(gfile,line)))
MADNESS_EXCEPTION(
"failed reading 2nd line of grid data",0);
1634 const size_t npt = qx.
dim(0);
1637 long npoints=power<NDIM>(npt);
1639 long nboxes=ndata/npoints;
1641 print(
"reading ",nboxes,
"boxes from file",gridfile);
1649 while (std::getline(gfile,gline)) {
1651 double x1,y1,z1,val;
1658 std::stringstream(gline) >> nn >> l1 >> l2 >> l3;
1665 const double h = std::pow(0.5,
double(n));
1672 for (
int i=0; i<npt; ++i) {
1673 c[0] = cell(0,0) +
h*cell_width[0]*(l[0] + qx(i));
1674 for (
int j=0; j<npt; ++j) {
1675 c[1] = cell(1,0) +
h*cell_width[1]*(l[1] + qx(j));
1676 for (
int k=0;
k<npt; ++
k) {
1677 c[2] = cell(2,0) +
h*cell_width[2]*(l[2] + qx(
k));
1679 auto& success = std::getline(gfile,gline);
1681 std::istringstream(gline) >> x1 >> y1 >> z1 >> val;
1687 if (vnuc_functor) val-=(*vnuc_functor)(
c);
1697 const bool has_children=
false;
1699 nodeT node(coeff,has_children);
1775 const coeffT& coeff)
const;
1781 template <
typename Q>
1797 template <
typename Q>
1799 const bool s_only)
const {
1833 template <
typename Q>
1851 for (std::size_t
d=0;
d<
NDIM; ++
d) {
1882 template <
typename Q>
1907 template <
typename Q>
1914 template <
typename Q>
1921 template <
typename Q>
1935 template <
typename Q>
1942 MADNESS_EXCEPTION(
"FunctionImpl: fcube_for_mul: child-parent relationship bad?",0);
1946 for (std::size_t
d=0;
d<
NDIM; ++
d) {
1963 template <
typename Q>
1970 MADNESS_EXCEPTION(
"FunctionImpl: fcube_for_mul: child-parent relationship bad?",0);
1974 for (
size_t d=0;
d<
NDIM;
d++) {
1985 template <
typename L,
typename R>
2010 template<
typename R>
2012 const int npt,
const keyT& key)
const {
2019 c11(this->cdata.
s0)=c1;
2020 c22(this->cdata.
s0)=c2;
2032 return copy(result(this->cdata.
s0));
2037 template <
typename L,
typename R,
typename opT>
2048 op(key, tcube, lcube, rcube);
2060 template <
typename L,
typename R>
2070 const keyT& key = it->first;
2072 coeffs.
send(key, &nodeT:: template gaxpy_inplace<T,L>, 1.0, other_node,
alpha);
2078 const keyT& key = it->first;
2080 coeffs.
send(key, &nodeT:: template gaxpy_inplace<T,R>, 1.0, other_node,
beta);
2088 template <
typename opT>
2092 const keyT& parent = it->first;
2093 nodeT& node = it->second;
2109 template <
typename opT>
2113 const keyT& parent = it->first;
2114 nodeT& node = it->second;
2126 template<std::
size_t LDIM>
2141 coeffT g_values =
g->coeffs2values(key,g_coeff);
2144 const long rank=g_values.
rank();
2145 const long maxk=
f->get_k();
2151 tensorT result(maxk,maxk,maxk);
2153 for (
long i=0; i<rank; ++i) {
2157 double singular_value_i = g_values.
get_svdtensor().weights(i);
2158 result += (singular_value_i*c1);
2162 tensorT f_coeff =
f->values2coeffs(key1,result);
2171 template<std::
size_t LDIM>
2176 const keyT& key = it->first;
2184 woT::task(
p, &implT:: template dirac_convolution_op<LDIM>, key, node,
f);
2190 f->trickle_down(
true);
2200 template <
typename opT>
2210 template <
typename opT>
2235 const keyT& key = it->first;
2236 nodeT& node = it->second;
2241 const double error=
d.normf();
2247 template <
typename Archive>
void serialize(
const Archive& ar) {}
2260 nodeT& node = it->second;
2264 template <
typename Archive>
void serialize(
const Archive& ar) {}
2276 nodeT& node = it->second;
2280 template <
typename Archive>
void serialize(
const Archive& ar) {}
2295 nodeT& node = it->second;
2300 template <
typename Archive>
void serialize(
const Archive& ar) {}
2322 nodeT& node = it->second;
2326 template <
typename Archive>
void serialize(
const Archive& ar) {}
2342 if constexpr(
NDIM==6) {
2343 const keyT& key = it->first;
2344 const nodeT& fnode = it->second;
2352 std::vector<long> map(
NDIM);
2353 map[0]=3; map[1]=4; map[2]=5;
2354 map[3]=0; map[4]=1; map[5]=2;
2374 if (have_c1 and have_c2) {
2378 norm=(c1-c2).normf();
2379 }
else if (have_c1) {
2382 }
else if (have_c2) {
2402 template <
typename Archive>
void serialize(
const Archive& ar) {
2414 template<
typename Q,
typename R>
2426 const keyT& key = it->first;
2427 const nodeT& node = it->second;
2433 template <
typename Archive>
void serialize(
const Archive& ar) {
2443 template<
typename Q,
typename R>
2456 const keyT& key = it->first;
2457 const nodeT& fnode = it->second;
2463 nodeT& gnode=acc->second;
2473 template <
typename Archive>
void serialize(
const Archive& ar) {
2491 const keyT& key = it->first;
2492 const nodeT& node = it->second;
2503 template <
typename Archive>
void serialize(
const Archive& ar) {
2521 const keyT& key = it->first;
2522 const nodeT& node = it->second;
2527 for (std::size_t i=0; i<
NDIM; ++i) {
2534 std::vector<Slice> s(
___);
2537 for (
size_t i=0; i<
NDIM; ++i) {
2538 std::size_t
kmax=
c.dim(i);
2540 for (
size_t k=1;
k<
kmax;
k+=2) {
2553 template <
typename Archive>
void serialize(
const Archive& ar) {
2572 const keyT& key = it->first;
2573 const nodeT& node = it->second;
2581 for (std::size_t i=0; i<
NDIM; ++i) l1[
map[i]] = l[i];
2590 for (std::size_t i=0; i<
NDIM; ++i) {
2591 if (
mirror[i]==-1) l1[i]= lmax - l[i];
2597 std::vector<Slice> s(
___);
2600 for (
size_t i=0; i<
NDIM; ++i) {
2601 std::size_t
kmax=
c.dim(i);
2603 for (
size_t k=1;
k<
kmax;
k+=2) {
2617 template <
typename Archive>
void serialize(
const Archive& ar) {
2637 const keyT& key = it->first;
2638 const nodeT& fnode = it->second;
2646 nodeT& gnode=acc->second;
2655 template <
typename Archive>
void serialize(
const Archive& ar) {}
2675 nodeT& node = it->second;
2683 template <
typename Archive>
void serialize(
const Archive& ar) {}
2696 it->second.consolidate_buffer(
targs);
2699 template <
typename Archive>
void serialize(
const Archive& ar) {}
2704 template <
typename opT>
2711 const keyT& key = it->first;
2712 nodeT& node = it->second;
2728 template <
typename Archive>
void serialize(
const Archive& ar) {}
2731 template <
typename Q,
typename R>
2739 std::vector<unsigned int> ind(vleft.size());
2740 for (
unsigned int i=0; i<vleft.size(); ++i) {
2743 for (
unsigned int i=0; i<vleft.size(); ++i) {
2745 std::swap(ind[i],ind[j]);
2750 if (it->second.has_coeff()) {
2756 for (
unsigned int j=0; j<vleft.size(); ++j) {
2757 unsigned int i = ind[j];
2759 implT* left = vleft[i].get();
2762 if (newnode && key.
level()>0) {
2770 nodeT& node = acc->second;
2787 const std::vector<tensorT>&
c,
2794 template <
typename opT>
2796 std::vector<tensorT>
c(
v.size());
2797 for (
unsigned int i=0; i<
v.size(); i++) {
2800 c[i]=
cc.full_tensor();
2811 template <
typename opT>
2814 for (std::size_t i=1; i<
v.size(); ++i) {
2815 if (
v[i] and
v[i-1]) {
2821 const keyT& key = it->first;
2822 if (it->second.has_coeff())
2823 world.
taskq.
add(*
this, &implT:: template multiop_values_doit<opT>, key,
op,
v);
2836 template <
typename opT>
2838 const std::vector<implT*>& vin, std::vector<implT*>& vout) {
2839 std::vector<tensorT>
c(vin.size());
2840 for (
unsigned int i=0; i<vin.size(); i++) {
2843 c[i]=
cc.full_tensor();
2846 std::vector<tensorT> r =
op(key,
c);
2848 for (std::size_t i=0; i<vout.size(); ++i) {
2859 template <
typename opT>
2861 std::vector<implT*>& vout,
const bool fence=
true) {
2863 for (std::size_t i=1; i<vin.size(); ++i) {
2864 if (vin[i] and vin[i-1]) {
2870 const keyT& key = it->first;
2871 if (it->second.has_coeff())
2872 world.
taskq.
add(*
this, &implT:: template multi_to_multi_op_values_doit<opT>,
2873 key,
op, vin, vout);
2876 for (
implT* it2 : vout) {
2888 template <
typename Q,
typename R>
2894 for (
unsigned int j=0; j<vright.size(); ++j) {
2895 world.
taskq.
add(*
this, &implT:: template vtransform_doit<Q,R>, vright[j],
copy(
c(j,
_)), vleft, tol);
2903 template <
typename opT>
2923 template <
typename L,
typename R>
2933 double lnorm = 1e99;
2935 if (lc.
size() == 0) {
2938 lnorm = it->second.get_norm_tree();
2939 if (it->second.has_coeff())
2940 lc = it->second.coeff().full_tensor_copy();
2944 std::vector<FunctionImpl<T,NDIM>*> vresult;
2945 std::vector<const FunctionImpl<R,NDIM>*> vright;
2946 std::vector< Tensor<R> > vrc;
2947 vresult.reserve(vrightin.size());
2948 vright.reserve(vrightin.size());
2949 vrc.reserve(vrightin.size());
2951 for (
unsigned int i=0; i<vrightin.size(); ++i) {
2956 if (rc.
size() == 0) {
2959 rnorm = it->second.get_norm_tree();
2960 if (it->second.has_coeff())
2961 rc = it->second.coeff().full_tensor_copy();
2968 result->
task(
world.
rank(), &implT:: template do_mul<L,R>, key, lc, std::make_pair(key,rc));
2970 else if (tol && lnorm*rnorm <
truncate_tol(tol, key)) {
2975 vresult.push_back(result);
2976 vright.push_back(right);
2981 if (vresult.size()) {
2989 std::vector< Tensor<R> > vrss(vresult.size());
2990 for (
unsigned int i=0; i<vresult.size(); ++i) {
2991 if (vrc[i].
size()) {
2994 vrss[i] = vright[i]->unfilter(rd);
2999 const keyT& child = kit.key();
3007 std::vector< Tensor<R> > vv(vresult.size());
3008 for (
unsigned int i=0; i<vresult.size(); ++i) {
3010 vv[i] =
copy(vrss[i](cp));
3013 woT::task(
coeffs.
owner(child), &implT:: template mulXXveca<L,R>, child, left, ll, vright, vv, vresult, tol);
3027 template <
typename L,
typename R>
3035 double lnorm=1e99, rnorm=1e99;
3038 if (lc.
size() == 0) {
3041 lnorm = it->second.get_norm_tree();
3042 if (it->second.has_coeff())
3043 lc = it->second.coeff().reconstruct_tensor();
3047 if (rc.
size() == 0) {
3050 rnorm = it->second.get_norm_tree();
3051 if (it->second.has_coeff())
3052 rc = it->second.coeff().reconstruct_tensor();
3057 do_mul<L,R>(key, lc, std::make_pair(key,rc));
3090 const keyT& child = kit.key();
3098 woT::task(
coeffs.
owner(child), &implT:: template mulXXa<L,R>, child, left, ll, right, rr, tol);
3113 template <
typename L,
typename R,
typename opT>
3122 if (lc.
size() == 0) {
3125 if (it->second.has_coeff())
3126 lc = it->second.coeff().reconstruct_tensor();
3130 if (rc.
size() == 0) {
3133 if (it->second.has_coeff())
3134 rc = it->second.coeff().reconstruct_tensor();
3138 do_binary_op<L,R>(key, lc, std::make_pair(key,rc),
op);
3160 const keyT& child = kit.key();
3172 template <
typename Q,
typename opT>
3191 template <
typename Archive>
3205 template <
typename Q,
typename opT>
3210 const Tensor<Q> fc =
func->coeffs.find(key).get()->second.coeff().reconstruct_tensor();
3212 if (fc.
size() == 0) {
3216 const keyT& child = kit.key();
3230 template <
typename L,
typename R>
3244 template <
typename L,
typename R,
typename opT>
3246 const opT&
op,
bool fence) {
3258 template <
typename Q,
typename opT>
3271 template <
typename Q,
typename opT>
3287 template <
typename L,
typename R>
3293 std::vector< Tensor<R> > vr(vright.size());
3361 const coordT& plotlo,
const coordT& plothi,
const std::vector<long>& npt,
3362 bool eval_refine)
const;
3372 const std::vector<long>& npt,
3373 const bool eval_refine =
false)
const;
3460 template<
size_t LDIM>
3487 double glo=0.0, ghi=0.0, flo=0.0, fhi=0.0;
3491 double total_hi=glo*fhi + ghi*flo + fhi*ghi;
3511 coeffT coeff1=
f.get_impl()->parent_to_child(
f.coeff(),
f.key(),key);
3519 bool is_leaf=
screen(coeff1_2D,coeff2,key);
3520 if (key.
level()<2) is_leaf=
false;
3526 coeffT hvalues=
f.get_impl()->coeffs2values(key,coeff1_2D);
3539 return std::pair<bool,coeffT> (is_leaf,hcoeff);
3563 template <
typename Archive>
void serialize(
const Archive& ar) {
3589 bool is_leaf=(
f.is_leaf() and
g.is_leaf());
3590 if (not is_leaf)
return std::pair<bool,coeffT> (is_leaf,
coeffT());
3592 coeffT fcoeff=
f.get_impl()->parent_to_child(
f.coeff(),
f.key(),key);
3593 coeffT gcoeff=
g.get_impl()->parent_to_child(
g.coeff(),
g.key(),key);
3596 hcoeff.
reduce_rank(
f.get_impl()->get_tensor_args().thresh);
3597 return std::pair<bool,coeffT> (is_leaf,hcoeff);
3617 template <
typename Archive>
void serialize(
const Archive& ar) {
3630 template<
size_t LDIM>
3637 coeff_opT coeff_op(
this,ff,gg,
particle);
3640 apply_opT apply_op(
this);
3645 woT::task(
p, &implT:: template forward_traverse<coeff_opT,apply_opT>, coeff_op, apply_op,
key0);
3652 template<
size_t LDIM,
typename leaf_opT>
3680 if (not is_leaf)
return std::pair<bool,coeffT> (is_leaf,
coeffT());
3690 return std::pair<bool,coeffT>(is_leaf,coeff);
3713 template <
typename Archive>
void serialize(
const Archive& ar) {
3724 template<
typename coeff_opT,
typename apply_opT>
3728 woT::task(
world.
rank(), &implT:: template traverse_tree<coeff_opT,apply_opT>, active_coeff, apply_op, key);
3738 template<
typename coeff_opT,
typename apply_opT>
3742 typedef typename std::pair<bool,coeffT> argT;
3743 const argT
arg=coeff_op(key);
3744 apply_op.operator()(key,
arg.second,
arg.first);
3746 const bool has_children=(not
arg.first);
3749 const keyT& child=kit.key();
3750 coeff_opT child_op=coeff_op.make_child(child);
3754 void (
implT::*ft)(
const coeff_opT&,
const apply_opT&,
const keyT&)
const = &implT::forward_traverse<coeff_opT,apply_opT>;
3768 template<std::
size_t LDIM,
typename leaf_opT>
3771 const leaf_opT&
leaf_op,
bool fence) {
3772 MADNESS_CHECK_THROW(p1.size()==p2.size(),
"hartree_product: p1 and p2 must have the same size");
3773 for (
auto&
p : p1)
MADNESS_CHECK(
p->is_nonstandard() or
p->is_nonstandard_with_leaves());
3774 for (
auto&
p : p2)
MADNESS_CHECK(
p->is_nonstandard() or
p->is_nonstandard_with_leaves());
3778 for (std::size_t i=0; i<p1.size(); ++i) {
3787 coeff_opT coeff_op(
this,iap1,iap2,
leaf_op);
3792 apply_opT apply_op(
this);
3795 coeff_op, apply_op,
cdata.key0);
3805 template <
typename opT,
typename R>
3810 const double cnorm =
c.normf();
3819 int maxdir = s ? 1 : -1;
3820 for (
int direction=-1; direction<=maxdir; direction+=2) {
3821 lnew[
axis] = lold + direction*s;
3822 if (lnew[
axis] >= 0 && lnew[
axis] < maxs) {
3824 double Rnorm = r.
normf();
3830 if (s <= 1 || r.
normf()*cnorm > tol) {
3834 if (result.
normf() > tol*0.3) {
3856 template <
typename opT,
typename R>
3863 fiterT end =
f->coeffs.end();
3865 for (fiterT it=
f->coeffs.begin(); it!=end; ++it) {
3866 const fnodeT& node = it->second;
3867 if (node.has_coeff()) {
3868 const keyT& key = it->first;
3869 const Tensor<R>&
c = node.coeff().full_tensor_copy();
3870 woT::task(
me, &implT:: template apply_1d_realspace_push_op<opT,R>,
3880 const std::pair<keyT,coeffT>& left,
3881 const std::pair<keyT,coeffT>& center,
3882 const std::pair<keyT,coeffT>& right);
3887 const std::pair<keyT,coeffT>& left,
3888 const std::pair<keyT,coeffT>& center,
3889 const std::pair<keyT,coeffT>& right);
3938 template<std::
size_t LDIM>
3964 bool use_tnorm=
false;
3969 tensorT val_rhs=fcf.coeffs2values(key, coeff_rhs);
3971 return fcf.values2coeffs(key,val_rhs);
3980 coeff1(
cdata.s0)=coeff_rhs;
3984 tensorT coeff_lhs_k1(cdata_npt.vk);
3989 val_lhs_k1.
emul(val_rhs_k1);
3996 result1(
cdata.s0)=0.0;
4006 const long k=coeff_rhs.
dim(0);
4020 coeff_rhs_npt1(fcf_lo.
cdata.s0)=coeff_rhs;
4034 val_lhs_npt.
emul(val_rhs);
4041 result1(
cdata.s0)=0.0;
4046 template <
typename Archive>
void serialize(
const Archive& ar) {
4059 template<
typename opT,
size_t LDIM>
4100 if(
leaf_op.do_pre_screening()){
4102 if(
leaf_op.pre_screening(key)){
4106 return std::pair<bool,coeffT> (
true,
coeffT());
4117 if(key.
level()<
int(il)){
4129 if(
leaf_op.post_screening(key,sum_coeff)){
4131 return std::pair<bool,coeffT> (
true,
coeffT());
4137 return std::pair<bool,coeffT> (
true,
coeffT());
4141 std::vector<bool> child_is_leaf(1<<
NDIM,
false);
4156 keyT child=kit.key();
4157 bool is_leaf=child_is_leaf[i];
4175 return std::pair<bool,coeffT> (
true,
coeffT());
4205 double dnorm_ket, snorm_ket;
4207 snorm_ket=
iaket.coeff(key).normf();
4208 dnorm_ket=
iaket.dnorm(key);
4215 dnorm_ket=s1*d2 + s2*d1 + d1*d2;
4221 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4226 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4230 double snorm=s_coeffs.
normf();
4233 double dnorm=
d.normf();
4234 error+=snorm*dnorm_ket + dnorm*snorm_ket + dnorm*dnorm_ket;
4266 double error=refine_error;
4294 return std::make_pair(cresult,
error);
4316 iaket1,iap11,iap21,iav11,iav21,
eri);
4320 const ctL& iap11,
const ctL& iap21,
const ctL& iav11,
const ctL& iav21,
4321 const implT* eri1) {
4326 template <
typename Archive>
void serialize(
const Archive& ar) {
4338 template<
typename opT>
4341 constexpr size_t LDIM=
NDIM/2;
4348 std::shared_ptr< FunctionFunctorInterface<T,NDIM> > func2(this->
get_functor());
4356 if (fence)
func->make_redundant(
true);
4360 for (
auto& ket :
func->impl_ket_vector) {
4369 for (std::size_t i=0; i<
func->impl_p1_vector.size(); ++i) {
4399 template<
typename opT, std::
size_t LDIM>
4404 const bool fence=
true) {
4415 coeff_opT coeff_op(
this,
leaf_op,iaket,iap1,iap2,iav1,iav2,eri);
4423 coeff_op, apply_op,
cdata.key0);
4432 void mapdim(
const implT&
f,
const std::vector<long>& map,
bool fence);
4442 const std::vector<long>&
mirror,
bool fence);
4475 auto& node=it->second;
4476 node.recompute_snorm_and_dnorm(
cdata);
4546 template <
typename opT>
4553 nodeT& node = acc->second;
4561 const keyT& child = kit.key();
4571 template <
typename opT>
4584 template <
typename opT>
4597 void broaden_op(
const keyT& key,
const std::vector< Future <bool> >&
v);
4701 const keyT& key = it->first;
4702 nodeT& node = it->second;
4716 template <
typename Archive>
void serialize(
const Archive& ar) {
4723 template<
size_t OPDIM>
4732 template <
class Archive>
4743 template <
typename opT,
typename R,
size_t OPDIM>
4771 template <
typename opT,
typename R,
size_t OPDIM>
4809 template <
typename opT,
typename R,
size_t OPDIM>
4814 if (2*OPDIM==
NDIM) result=
op->apply2_lowdim(args.
key, args.
d, coeff,
4816 if (OPDIM==
NDIM) result =
op->apply2(args.
key, args.
d, coeff,
4819 const double result_norm=result.
svd_normf();
4821 if (result_norm> 0.3*args.
tol/args.
fac) {
4851 template <
typename opT,
typename R>
4863 typedef typename opT::keyT opkeyT;
4864 constexpr auto opdim = opT::opdim;
4865 const opkeyT
source =
op->get_source_key(key);
4883 double radius = 1.5 + 0.33 * std::max(0.0, 2 - std::log10(
thresh) -
4889 double cnorm =
c.normf();
4896 (
op->particle() == 1)
4898 op->domain_is_periodic())
4900 op->domain_is_periodic());
4902 const auto default_distance_squared = [&](
const auto &
displacement)
4906 const auto default_skip_predicate = [&](
const auto &
displacement)
4910 const auto for_each = [&](
const auto &displacements,
4911 const auto &distance_squared,
4912 const auto &skip_predicate) -> std::optional<std::uint64_t> {
4928 std::optional<std::uint64_t> distsq;
4933 const auto &probing_displacement =
4934 displacements.probing_displacement();
4935 const double opnorm =
4937 if (cnorm * opnorm <= tol / fac) {
4942 const auto disp_end = displacements.
end();
4943 for (
auto disp_it = displacements.begin(); disp_it != disp_end;
4951 if (
op->particle() == 1)
4960 if (nvalid > 0 && nused == 0 && dsq > 1) {
4972 keyT dest =
neighbor(key,
d, this_is_treated_by_op_as_periodic);
4977 if (cnorm * opnorm > tol / fac) {
4980 if (result.
normf() > 0.3 * tol / fac) {
5000 const std::vector<opkeyT> &disp =
op->get_disp(key.
level());
5001 const auto max_distsq_reached = for_each(disp, default_distance_squared, default_skip_predicate);
5006 if (
op->range_restricted() && key.
level() >= 1) {
5008 std::array<std::optional<std::int64_t>, opdim> box_radius;
5009 std::array<std::optional<std::int64_t>, opdim> surface_thickness;
5010 auto &
range =
op->get_range();
5011 for (
int d = 0;
d != opdim; ++
d) {
5014 surface_thickness[
d] =
range[
d].finite_soft() ? 1 : 0;
5021 if (max_distsq_reached)
5025 auto opkey =
op->particle() == 1 ? key.template extract_front<opdim>() : key.template extract_front<opdim>();
5027 range_boundary_face_displacements(opkey, box_radius,
5029 op->lattice_summed(),
5032 range_boundary_face_displacements,
5034 [](
const auto &
displacement) -> std::uint64_t {
return 0; },
5035 default_skip_predicate);
5041 template <
typename opT,
typename R>
5048 const keyT& key = it->first;
5078 template <
typename opT,
typename R>
5080 const bool& do_kernel) {
5083 typedef typename opT::keyT opkeyT;
5086 std::list<opkeyT> blacklist;
5088 constexpr auto opdim=opT::opdim;
5092 const opkeyT
source=
op->get_source_key(key);
5097 double fac=std::pow(3,
NDIM*0.5);
5098 double cnorm = coeff.
normf();
5102 apply_targs.
thresh=tol/fac*0.03;
5112#ifdef HAVE_GENTENSOR
5121 for (
typename std::vector<opkeyT>::const_iterator it=disp.begin(); it != disp.end(); ++it) {
5122 const opkeyT&
d = *it;
5124 const int shell=
d.distsq_bc(
op->lattice_summed());
5125 if (do_kernel and (shell>0))
break;
5126 if ((not do_kernel) and (shell==0))
continue;
5130 else if (
op->particle()==2) disp1=nullkey.
merge_with(*it);
5142 bool screened=
false;
5143 typename std::list<opkeyT>::const_iterator it2;
5144 for (it2=blacklist.begin(); it2!=blacklist.end(); it2++) {
5145 if (
d.is_farther_out_than(*it2)) {
5155 if (cnorm*opnorm> tol/fac) {
5157 double cost_ratio=
op->estimate_costs(
source,
d, coeff_SVD, tol/fac/cnorm, tol/fac);
5161 if (cost_ratio>0.0) {
5165 if (cost_ratio<1.0) {
5169 if (2*opdim==
NDIM) {
5175 maxnorm=std::max(
norm,maxnorm);
5178 }
else if (shell >= 12) {
5181 if (
norm<0.3*tol/fac) blacklist.push_back(
d);
5189 template <
typename opT,
typename R>
5198 const keyT& key = it->first;
5199 const coeffT& coeff = it->second.coeff();
5203 woT::task(
p, &implT:: template do_apply_directed_screening<opT,R>, &
op, key, coeff,
true);
5204 woT::task(
p, &implT:: template do_apply_directed_screening<opT,R>, &
op, key, coeff,
false);
5230 template<
typename opT, std::
size_t LDIM>
5243 coeff_opT coeff_op(
this,ff,gg,&apply_op);
5249 woT::task(
p, &implT:: template forward_traverse<coeff_opT,apply_opT>, coeff_op, apply_op,
key0);
5257 template<
typename opT, std::
size_t LDIM>
5298 bool is_leaf=
leaf_op(key,fcoeff,gcoeff);
5312 result->
task(
p,&implT:: template do_apply_directed_screening<opT,T>,
5318 return std::pair<bool,coeffT> (is_leaf,
coeffT());
5324 const coeffT& coeff)
const {
5327 if (key.
level()<2) is_leaf=
false;
5328 return std::pair<bool,coeffT> (is_leaf,coeff);
5349 const opT* apply_op1) {
5353 template <
typename Archive>
void serialize(
const Archive& ar) {
5364 template<
typename opT>
5374 coeff_opT coeff_op(
this,fimpl,&apply_op);
5380 coeff_op, apply_op,
cdata.key0);
5388 template<
typename opT>
5394 typedef std::pair<bool,coeffT>
argT;
5422 result->
task(
p,&implT:: template do_apply_directed_screening<opT,T>,
5428 if (
iaf.is_leaf())
return argT(
true,coeff);
5432 const bool is_leaf=
true;
5442 if (key.
level()<2) is_leaf=
false;
5443 return argT(is_leaf,coeff);
5465 return this_type(result1,iaf1,apply_op1);
5468 template <
typename Archive>
void serialize(
const Archive& ar) {
5477 template <
typename opT>
5482 std::vector<long> vq(
NDIM);
5483 for (std::size_t i=0; i<
NDIM; ++i)
5485 tensorT fval(vq,
false), work(vq,
false), result(vq,
false);
5503 double err = fval.normf();
5507 template <
typename opT>
5526 const keyT& key = it->first;
5527 const nodeT& node = it->second;
5538 template <
typename Archive>
5545 template <
typename opT>
5549 const int npt =
cdata.npt + 1;
5564 const nodeT& node = it->second;
5578 template <
typename Archive>
void serialize(
const Archive& ar) {
5588 template<
typename R>
5599 const keyT& key=it->first;
5600 const nodeT& fnode = it->second;
5607 MADNESS_EXCEPTION(
"functions have different k or compress/reconstruct error", 0);
5626 template <
typename Archive>
void serialize(
const Archive& ar) {
5634 template <
typename R>
5649 template<
typename R>
5661 constexpr std::size_t LDIM=std::max(
NDIM/2,std::size_t(1));
5663 const keyT& key=it->first;
5664 const nodeT& fnode = it->second;
5665 if (not fnode.
has_coeff())
return resultT(0.0);
5668 auto find_valid_parent = [](
auto& key,
auto& impl,
auto&& find_valid_parent) {
5669 MADNESS_CHECK(impl->get_coeffs().owner(key)==impl->world.rank());
5670 if (impl->get_coeffs().probe(key))
return key;
5671 auto parentkey=key.
parent();
5672 return find_valid_parent(parentkey, impl, find_valid_parent);
5676 auto get_coeff = [&find_valid_parent](
const auto& key,
const auto& v_impl) {
5677 if ((v_impl.size()>0) and v_impl.front().get()) {
5678 auto impl=v_impl.front();
5682 auto parentkey = find_valid_parent(key, impl, find_valid_parent);
5684 typename decltype(impl->coeffs)::accessor acc;
5685 impl->get_coeffs().find(acc,parentkey);
5686 auto parentcoeff=acc->second.coeff();
5687 auto coeff=impl->parent_to_child(parentcoeff, parentkey, key);
5691 typedef typename std::decay_t<
decltype(v_impl)>::value_type::element_type::typeT S;
5698 auto make_vector = [](
auto&
arg) {
5699 return std::vector<std::decay_t<
decltype(
arg)>>(1,
arg);
5710 "only one ket function supported in inner_on_demand");
5712 "only one p1 function supported in inner_on_demand");
5714 "only one p2 function supported in inner_on_demand");
5715 auto coeff_bra=fnode.
coeff();
5716 auto coeff_ket=get_coeff(key,
func->impl_ket_vector);
5717 auto coeff_v1=get_coeff(key1,make_vector(
func->impl_m1));
5718 auto coeff_v2=get_coeff(key2,make_vector(
func->impl_m2));
5719 auto coeff_p1=get_coeff(key1,
func->impl_p1_vector);
5720 auto coeff_p2=get_coeff(key2,
func->impl_p2_vector);
5724 if (coeff_ket.has_data() and coeff_p1.has_data()) {
5728 }
else if (coeff_ket.has_data() or coeff_p1.has_data()) {
5729 coeff_ket = (coeff_ket.has_data()) ? coeff_ket :
outer(coeff_p1,coeff_p2);
5736 if (coeff_v1.has_data()) {
5738 v1v2ket = pm(key,coeff_v1.full_tensor(), 1);
5740 v1v2ket+= pm(key,coeff_v2.full_tensor(), 2);
5743 v1v2ket = coeff_ket;
5747 if (
func->impl_eri) {
5751 tensorT braket=pm(key,coeff_bra.full_tensor_copy().conj());
5766 template <
typename Archive>
void serialize(
const Archive& ar) {
5774 template <
typename R>
5786 template<
typename R>
5797 const keyT& key=it->first;
5798 const nodeT& fnode = it->second;
5805 MADNESS_EXCEPTION(
"functions have different k or compress/reconstruct error", 0);
5824 template <
typename Archive>
void serialize(
const Archive& ar) {
5832 template <
typename R>
5846 typedef std::vector< std::pair<int,const coeffT*> >
mapvecT;
5855 typename mapT::accessor acc;
5856 const keyT& key = it->first;
5859 [[maybe_unused]]
auto inserted = map->insert(acc,key);
5860 acc->second.push_back(std::make_pair(index,&(node.
coeff())));
5873 for (
unsigned int i=0; i<
v.size(); i++) {
5877 if (
v.size())
v[0]->world.taskq.fence();
5883 template <
typename R>
5885 const typename mapT::iterator lend,
5892 for (
typename mapT::iterator lit=lstart; lit!=lend; ++lit) {
5893 const keyT& key = lit->first;
5895 if (rit != rmap_ptr->end()) {
5896 const mapvecT& leftv = lit->second;
5898 const int nleft = leftv.
size();
5899 const int nright= rightv.
size();
5901 for (
int iv=0; iv<nleft; iv++) {
5902 const int i = leftv[iv].first;
5905 for (
int jv=0; jv<nright; jv++) {
5906 const int j = rightv[jv].first;
5909 if (!sym || (sym && i<=j))
5910 r(i,j) += iptr->trace_conj(*jptr);
5920 template <
typename R>
5922 const typename mapT::iterator lend,
5929 for (
typename mapT::iterator lit=lstart; lit!=lend; ++lit) {
5930 const keyT& key = lit->first;
5932 if (rit != rmap_ptr->end()) {
5933 const mapvecT& leftv = lit->second;
5935 const size_t nleft = leftv.
size();
5936 const size_t nright= rightv.
size();
5938 unsigned int size = leftv[0].second->size();
5942 for(
unsigned int iv = 0; iv < nleft; ++iv) Left(iv,
_) = (*(leftv[iv].second)).full_tensor();
5943 for(
unsigned int jv = 0; jv < nright; ++jv) Right(jv,
_) = (*(rightv[jv].second)).full_tensor();
5948 for(
unsigned int iv = 0; iv < nleft; ++iv) {
5949 const int i = leftv[iv].first;
5950 for(
unsigned int jv = 0; jv < nright; ++jv) {
5951 const int j = rightv[jv].first;
5952 if (!sym || (sym && i<=j)) result(i,j) += r(iv,jv);
5963 template <
typename R,
typename = std::enable_if_t<std::is_
floating_po
int_v<R>>>
5964 static void do_dot_localX(
const typename mapT::iterator lstart,
5965 const typename mapT::iterator lend,
5973 for (
typename mapT::iterator lit = lstart; lit != lend; ++lit) {
5974 const keyT& key = lit->first;
5976 if (rit != rmap_ptr->end()) {
5977 const mapvecT& leftv = lit->second;
5979 const int nleft = leftv.
size();
5980 const int nright = rightv.
size();
5982 for (
int iv = 0; iv < nleft; iv++) {
5983 const int i = leftv[iv].first;
5986 for (
int jv = 0; jv < nright; jv++) {
5987 const int j = rightv[jv].first;
5990 if (!sym || (sym && i <= j))
5991 r(i, j) += iptr->trace_conj(*jptr);
6001 template <
typename R>
6003 const typename mapT::iterator lend,
6010 for (
typename mapT::iterator lit = lstart; lit != lend; ++lit) {
6011 const keyT& key = lit->first;
6013 if (rit != rmap_ptr->end()) {
6014 const mapvecT& leftv = lit->second;
6016 const size_t nleft = leftv.
size();
6017 const size_t nright= rightv.
size();
6019 unsigned int size = leftv[0].second->size();
6023 for(
unsigned int iv = 0; iv < nleft; ++iv) Left(iv,
_) = (*(leftv[iv].second)).full_tensor();
6024 for(
unsigned int jv = 0; jv < nright; ++jv) Right(jv,
_) = (*(rightv[jv].second)).full_tensor();
6028 for(
unsigned int iv = 0; iv < nleft; ++iv) {
6029 const int i = leftv[iv].first;
6030 for(
unsigned int jv = 0; jv < nright; ++jv) {
6031 const int j = rightv[jv].first;
6032 if (!sym || (sym && i <= j)) result(i, j) += r(iv, jv);
6045 static std::complex<double>
conj(
const std::complex<double> x) {
6046 return std::conj(x);
6049 template <
typename R>
6075 size_t chunk = (lmap.size()-1)/(3*4*5)+1;
6080 typename mapT::iterator lstart=lmap.begin();
6081 while (lstart != lmap.end()) {
6082 typename mapT::iterator lend = lstart;
6083 advance(lend,chunk);
6087 left[0]->world.taskq.fence();
6090 for (
long i=0; i<r.
dim(0); i++) {
6091 for (
long j=0; j<i; j++) {
6101 template <
typename R>
6127 size_t chunk = (lmap.size() - 1) / (3 * 4 * 5) + 1;
6132 typename mapT::iterator lstart=lmap.begin();
6133 while (lstart != lmap.end()) {
6134 typename mapT::iterator lend = lstart;
6135 advance(lend, chunk);
6139 left[0]->world.taskq.fence();
6143 for (
long i = 0; i < r.
dim(0); i++) {
6144 for (
long j = 0; j < i; j++) {
6154 template <
typename R>
6157 static_assert(!std::is_same<R, int>::value &&
6158 std::is_same<R, int>::value,
6159 "Compilation failed because you wanted to know the type; see below:");
6169 template<
typename Q, std::size_t LDIM,
typename R, std::size_t KDIM,
6170 std::size_t CDIM = (KDIM + LDIM -
NDIM) / 2>
6172 const std::array<int, CDIM> v1,
const std::array<int, CDIM> v2) {
6174 typedef std::multimap<Key<NDIM>, std::list<Key<CDIM>>> contractionmapT;
6188 std::list<contractionmapT> all_contraction_maps;
6189 for (std::size_t n=0; n<nmax; ++n) {
6194 auto [h_ijlist, h_jlist] =
h.get_contraction_node_lists(n, v2);
6195 if ((g_ijlist.size() == 0) and (h_ijlist.size() == 0))
break;
6205 bool this_first =
true;
6209 h_ijlist, h_jlist, this_first,
thresh);
6215 h_nc.
key0(), hnode0, v2, v1,
6216 g_ijlist, g_jlist, this_first,
thresh);
6219 contraction_map.merge(contraction_map1);
6221 auto it = contraction_map.begin();
6222 while (it != contraction_map.end()) {
6223 auto it_end = contraction_map.upper_bound(it->first);
6226 while (it2 != it_end) {
6227 it->second.splice(it->second.end(), it2->second);
6228 it2 = contraction_map.erase(it2);
6236 for (
auto& elem: contraction_map) {
6238 elem.second.unique();
6246 all_contraction_maps.push_back(contraction_map);
6248 long mapsize=contraction_map.
size();
6249 if (mapsize==0)
break;
6254 for (
const auto& contraction_map : all_contraction_maps) {
6255 for (
const auto& key_list : contraction_map) {
6257 const std::list<Key<CDIM>>& list=key_list.second;
6259 &
g,&
h,v1,v2,key,list);
6271 template<std::
size_t CDIM>
6272 std::tuple<std::set<Key<NDIM>>, std::map<Key<CDIM>,
double>>
6276 auto has_d_coeffs = [&
cdata](
const coeffT& coeff) {
6277 if (coeff.has_no_data())
return false;
6278 return (coeff.dim(0)==2*
cdata.k);
6282 std::set<Key<NDIM>> ij_list;
6283 std::map<Key<CDIM>,
double> j_list;
6288 if ((key.
level()==n) and (has_d_coeffs(node.
coeff()))) {
6289 ij_list.insert(key);
6291 for (std::size_t i=0; i<CDIM; ++i) j_trans[i]=key.
translation()[
v[i]];
6293 const double max_d_norm=j_list[jkey];
6294 j_list.insert_or_assign(jkey,std::max(max_d_norm,node.
get_dnorm()));
6296 while (j_list.count(parent_jkey)==0) {
6297 j_list.insert({parent_jkey,1.0});
6298 parent_jkey=parent_jkey.
parent();
6302 return std::make_tuple(ij_list,j_list);
6325 template<std::size_t CDIM, std::size_t ODIM, std::size_t FDIM=
NDIM+ODIM-2*CDIM>
6328 const std::array<int,CDIM>& v_this,
6329 const std::array<int,CDIM>& v_other,
6330 const std::set<
Key<ODIM>>& ij_other_list,
6331 const std::map<
Key<CDIM>,
double>& j_other_list,
6332 bool this_first,
const double thresh) {
6334 std::multimap<Key<FDIM>, std::list<Key<CDIM>>> contraction_map;
6337 if (j_other_list.empty())
return contraction_map;
6344 const double max_d_norm=j_other_list.find(j_this_key)->second;
6350 bool final_scale=key.
level()==ij_other_list.begin()->level();
6351 if (final_scale and sd_norm_product_large) {
6352 for (
auto& other_key : ij_other_list) {
6353 const auto j_other_key=other_key.extract_key(v_other);
6354 if (j_this_key != j_other_key)
continue;
6356 auto k_key=other_key.extract_complement_key(v_other);
6362 contraction_map.insert(std::make_pair(ik_key,std::list<
Key<CDIM>>{j_this_key}));
6364 return contraction_map;
6367 bool continue_recursion = (j_other_list.count(j_this_key)==1);
6368 if (not continue_recursion)
return contraction_map;
6372 continue_recursion = (node.
has_children() or sd_norm_product_large);
6374 if (continue_recursion) {
6376 bool compute_child_s_coeffs=
true;
6381 keyT child=kit.key();
6386 bool need_s_coeffs= childnode_exists ? (acc->second.get_snorm()<=0.0) :
true;
6389 if (need_s_coeffs and compute_child_s_coeffs) {
6390 if (
d.dim(0)==
cdata.vk[0]) {
6398 compute_child_s_coeffs=
false;
6401 if (not childnode_exists) {
6404 }
else if (childnode_exists and need_s_coeffs) {
6405 acc->second.coeff()=child_s_coeffs;
6409 nodeT& childnode = acc->second;
6413 ij_other_list, j_other_list, this_first,
thresh));
6419 return contraction_map;
6431 template<
typename Q, std::size_t LDIM,
typename R, std::size_t KDIM,
6432 std::size_t CDIM = (KDIM + LDIM -
NDIM) / 2>
6434 const std::array<int, CDIM> v1,
const std::array<int, CDIM> v2,
6437 Key<LDIM - CDIM> i_key;
6438 Key<KDIM - CDIM> k_key;
6442 for (
const auto& j_key: j_key_list) {
6444 auto v_complement = [](
const auto&
v,
const auto& vc) {
6445 constexpr std::size_t VDIM = std::tuple_size<std::decay_t<
decltype(
v)>>::value;
6446 constexpr std::size_t VCDIM = std::tuple_size<std::decay_t<
decltype(vc)>>::value;
6447 std::array<int, VCDIM> result;
6448 for (std::size_t i = 0; i < VCDIM; i++) result[i] = (
v.back() + i + 1) % (VDIM + VCDIM);
6451 auto make_ij_key = [&v_complement](
const auto i_key,
const auto j_key,
const auto&
v) {
6452 constexpr std::size_t IDIM = std::decay_t<
decltype(i_key)>::static_size;
6453 constexpr std::size_t JDIM = std::decay_t<
decltype(j_key)>::static_size;
6454 static_assert(JDIM == std::tuple_size<std::decay_t<
decltype(
v)>>::value);
6457 for (std::size_t i = 0; i <
v.size(); ++i) l[
v[i]] = j_key.translation()[i];
6458 std::array<int, IDIM> vc1;
6459 auto vc = v_complement(
v, vc1);
6460 for (std::size_t i = 0; i < vc.size(); ++i) l[vc[i]] = i_key.translation()[i];
6465 Key<LDIM> ij_key = make_ij_key(i_key, j_key, v1);
6466 Key<KDIM> jk_key = make_ij_key(k_key, j_key, v2);
6470 const coeffT& gcoeff =
g->get_coeffs().find(ij_key).get()->second.coeff();
6471 const coeffT& hcoeff =
h->get_coeffs().find(jk_key).get()->second.coeff();
6473 if (gcoeff.
dim(0) ==
g->get_cdata().k) {
6474 gcoeff1 =
coeffT(
g->get_cdata().v2k,
g->get_tensor_args());
6475 gcoeff1(
g->get_cdata().s0) += gcoeff;
6479 if (hcoeff.
dim(0) ==
g->get_cdata().k) {
6480 hcoeff1 =
coeffT(
h->get_cdata().v2k,
h->get_tensor_args());
6481 hcoeff1(
h->get_cdata().s0) += hcoeff;
6487 auto fuse = [](
Tensor<T> tensor,
const std::array<int, CDIM>&
v,
int offset) {
6488 for (std::size_t i = 0; i < CDIM - 1; ++i) {
6498 auto contract2 = [](
const auto& svdcoeff,
const auto& tensor,
const int particle) {
6500 const int spectator_particle=(
particle+1)%2;
6501 Tensor<Q> gtensor = svdcoeff.get_svdtensor().make_vector_with_weights(
particle);
6502 gtensor=gtensor.
reshape(svdcoeff.rank(),gtensor.
size()/svdcoeff.rank());
6504 Tensor<Q> gtensor_other = svdcoeff.get_svdtensor().ref_vector(spectator_particle);
6521 if (key.
level() > 0) {
6524 gtensor = fuse(gtensor, v1,
offset);
6525 htensor = fuse(htensor, v2,
offset);
6538 int gparticle= v1[0]==0 ? 0 : 1;
6539 int hparticle= v2[0]==0 ? 0 : 1;
6551 result_tmp.
get_svdtensor().set_vectors_and_weights(
w,tmp2,htensor_other);
6552 if (key.
level() > 0) {
6565 result_coeff1.
get_svdtensor().set_vectors_and_weights(
w,tmp2,htensor_other);
6568 result_coeff+=result_tmp;
6578 int hparticle= v2[0]==0 ? 0 : 1;
6591 int gparticle= v1[0]==0 ? 0 : 1;
6624 return c.trace_conj(fc);
6637 T new_inner, result = 0.0;
6644 if (old_inner ==
T(0)) {
6648 if (
coeffs.
find(key).get()->second.has_children()) {
6654 const keyT& child = it.key();
6658 new_inner = inner_child.
sum();
6659 }
else if (leaf_refine) {
6676 const keyT& child = it.key();
6680 new_inner = inner_child.
sum();
6684 new_inner = old_inner;
6696 const keyT& child = it.key();
6706 const std::shared_ptr< FunctionFunctorInterface<T, NDIM> >
fref;
6712 const implT * impl,
const bool leaf_refine,
const bool do_leaves)
6713 : fref(
f), impl(impl), leaf_refine(leaf_refine), do_leaves(do_leaves) {};
6716 if (do_leaves and it->second.is_leaf()) {
6717 tensorT cc = it->second.coeff().full_tensor();
6719 }
else if ((not do_leaves) and (it->first.level() == impl->
initial_level)) {
6720 tensorT cc = it->second.coeff().full_tensor();
6731 template <
typename Archive>
void serialize(
const Archive& ar) {
6767 const bool leaf_refine,
T old_inner=
T(0))
const {
6784 const keyT& child = it.key();
6791 if (leaf_refine and (
std::abs(new_inner - old_inner) > tol)) {
6793 const keyT& child = it.key();
6817 template <
typename L>
6841 template <
typename L>
6850 if (not below_leaf) {
6851 bool left_leaf = left->
coeffs.
find(key).get()->second.is_leaf();
6857 const keyT& child = it.key();
6867 if (lc.
size() == 0) {
6870 if (it->second.has_coeff())
6871 lc = it->second.coeff().reconstruct_tensor();
6875 if (
c.size() == 0) {
6896 const keyT& child = it.key();
6908 double dnorm =
d.normf();
6919 const keyT& child = it.key();
6923 child, left, left_coeff, child_coeff,
f,
alpha,
beta, tol, below_leaf);
6928 template <
typename L>
6944 template<
size_t LDIM>
6946 const int dim,
const bool fence) {
6961 coeff_op, apply_op,
cdata.key0);
6970 template<
size_t LDIM>
6977 typedef std::pair<bool,coeffT>
argT;
7019 const int k=fcoeff.
dim(0);
7020 const int k_ldim=std::pow(
k,LDIM);
7021 std::vector<long> shape(LDIM,
k);
7027 final=
inner(gtensor,ftensor,0,
dim).reshape(shape);
7030 if (fcoeff.
rank()>0) {
7033 const int otherdim = (
dim + 1) % 2;
7037 const tensorT gatensor =
inner(gtensor, atensor, 0, 1);
7042 for (
int r = 0; r < fcoeff.
rank(); ++r)
final +=
weights(r) * btensor(r,
_);
7043 final =
final.reshape(shape);
7073 return this_type(fimpl1,result1,iag1,dim1);
7076 template <
typename Archive>
void serialize(
const Archive& ar) {
7090 template<
size_t LDIM>
7093 typedef std::pair< keyT,coeffT > pairT;
7098 fiterator end =
f->get_coeffs().end();
7099 for (fiterator it=
f->get_coeffs().begin(); it!=end; ++it) {
7116 woT::task(
world.
rank(),&implT:: template do_project_out<LDIM>,fcoeff,result,key1,key2,dim);
7118 }
else if (dim==1) {
7126 woT::task(
world.
rank(),&implT:: template do_project_out<LDIM>,fcoeff,result,key2,key1,dim);
7148 template<
size_t LDIM>
7150 const Key<NDIM>& dest,
const int dim)
const {
7163 const int otherdim=(dim+1)%2;
7164 const int k=fcoeff.
dim(0);
7165 std::vector<Slice> s(fcoeff.
config().dim_per_vector()+1,
_);
7168 for (
int r=0; r<fcoeff.
rank(); ++r) {
7170 const tensorT contracted_tensor=fcoeff.
config().ref_vector(dim)(s).reshape(
k,
k,
k);
7171 const tensorT other_tensor=fcoeff.
config().ref_vector(otherdim)(s).reshape(
k,
k,
k);
7172 const double ovlp= gtensor.trace_conj(contracted_tensor);
7173 const double fac=ovlp * fcoeff.
config().weights(r);
7174 result+=fac*other_tensor;
7204 std::size_t
size()
const;
7210 std::size_t
nCoeff()
const;
7225 template <
typename Q,
typename F>
7229 typename fdcT::const_iterator end =
f.coeffs.
end();
7230 for (
typename fdcT::const_iterator it=
f.coeffs.begin(); it!=end; ++it) {
7231 const keyT& key = it->first;
7232 const fnodeT& node = it->second;
7234 if (node.has_coeff()) {
7265 template <
class Archive,
class T, std::
size_t NDIM>
7277 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use a locally uninitialized object",0);
7280 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use an unregistered object",0);
7287 template <
class Archive,
class T, std::
size_t NDIM>
7290 bool exists=(ptr) ?
true :
false;
7292 if (exists) ar & ptr->
id();
7296 template <
class Archive,
class T, std::
size_t NDIM>
7308 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use a locally uninitialized object",0);
7313 MADNESS_EXCEPTION(
"FunctionImpl: remote operation attempting to use an unregistered object",0);
7321 template <
class Archive,
class T, std::
size_t NDIM>
7324 bool exists=(ptr) ?
true :
false;
7326 if (exists) ar & ptr->
id();
7331 template <
class Archive,
class T, std::
size_t NDIM>
7340 template <
class Archive,
class T, std::
size_t NDIM>
7347 template <
class Archive,
class T, std::
size_t NDIM>
7356 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
Definition displacements.h:717
Definition displacements.h:294
std::function< bool(Level, const PointPattern &, std::optional< Displacement > &)> Filter
this callable filters out points and/or displacements; note that the displacement is optional (this u...
Definition displacements.h:300
a class to track where relevant (parent) coeffs are
Definition funcimpl.h:791
const keyT & key() const
const reference to the key
Definition funcimpl.h:839
CoeffTracker(const CoeffTracker &other, const datumT &datum)
ctor with a pair<keyT,nodeT>
Definition funcimpl.h:821
const LeafStatus & is_leaf() const
const reference to is_leaf flag
Definition funcimpl.h:863
const implT * impl
the funcimpl that has the coeffs
Definition funcimpl.h:800
LeafStatus
Definition funcimpl.h:797
@ yes
Definition funcimpl.h:797
@ no
Definition funcimpl.h:797
@ unknown
Definition funcimpl.h:797
CoeffTracker(const CoeffTracker &other)
copy ctor
Definition funcimpl.h:829
double dnorm(const keyT &key) const
return the s and dnorm belonging to the passed-in key
Definition funcimpl.h:856
coeffT coeff_
the coefficients belonging to key
Definition funcimpl.h:806
const implT * get_impl() const
const reference to impl
Definition funcimpl.h:833
const coeffT & coeff() const
const reference to the coeffs
Definition funcimpl.h:836
keyT key_
the current key, which must exists in impl
Definition funcimpl.h:802
double dnorm_
norm of d coefficients corresponding to key
Definition funcimpl.h:808
CoeffTracker(const implT *impl)
the initial ctor making the root key
Definition funcimpl.h:816
void serialize(const Archive &ar)
serialization
Definition funcimpl.h:915
Future< CoeffTracker > activate() const
find the coefficients
Definition funcimpl.h:892
CoeffTracker()
default ctor
Definition funcimpl.h:813
GenTensor< T > coeffT
Definition funcimpl.h:795
CoeffTracker make_child(const keyT &child) const
make a child of this, ignoring the coeffs
Definition funcimpl.h:866
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:793
std::pair< Key< NDIM >, ShallowNode< T, NDIM > > datumT
Definition funcimpl.h:796
CoeffTracker forward_ctor(const CoeffTracker &other, const datumT &datum) const
taskq-compatible forwarding to the ctor
Definition funcimpl.h:909
LeafStatus is_leaf_
flag if key is a leaf node
Definition funcimpl.h:804
coeffT coeff(const keyT &key) const
return the coefficients belonging to the passed-in key
Definition funcimpl.h:847
Key< NDIM > keyT
Definition funcimpl.h:794
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
Holds displacements for applying operators to avoid replicating for all operators.
Definition displacements.h:51
const std::vector< Key< NDIM > > & get_disp(Level n, const array_of_bools< NDIM > &kernel_lattice_sum_axes)
Definition displacements.h:211
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:87
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:100
static const double & get_thresh()
Returns the default threshold.
Definition funcdefaults.h:176
static int get_max_refine_level()
Gets the default maximum adaptive refinement level.
Definition funcdefaults.h:213
static const Tensor< double > & get_cell_width()
Returns the width of each user cell dimension.
Definition funcdefaults.h:369
static bool get_apply_randomize()
Gets the random load balancing for integral operators flag.
Definition funcdefaults.h:289
static const Tensor< double > & get_cell()
Gets the user cell for the simulation.
Definition funcdefaults.h:347
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:5508
double operator()(double a, double b) const
Definition funcimpl.h:5534
const opT * func
Definition funcimpl.h:5510
Tensor< double > qx
Definition funcimpl.h:5512
double operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5525
void serialize(const Archive &ar)
Definition funcimpl.h:5539
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:5518
int npt
Definition funcimpl.h:5511
Tensor< double > quad_phiw
Definition funcimpl.h:5514
const implT * impl
Definition funcimpl.h:5509
Tensor< double > quad_phit
Definition funcimpl.h:5513
do_err_box(const do_err_box &e)
Definition funcimpl.h:5522
FunctionImpl holds all Function state to facilitate shallow copy semantics.
Definition funcimpl.h:945
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:6273
void copy_coeffs(const FunctionImpl< Q, NDIM > &other, bool fence)
Copy coeffs from other into self.
Definition funcimpl.h:1134
bool is_nonstandard() const
Definition mraimpl.h:269
T eval_cube(Level n, coordT &x, const tensorT &c) const
Definition mraimpl.h:2021
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:6433
AtomicInt large
Definition funcimpl.h:1001
Timer timer_target_driven
Definition funcimpl.h:999
void binaryXX(const FunctionImpl< L, NDIM > *left, const FunctionImpl< R, NDIM > *right, const opT &op, bool fence)
Definition funcimpl.h:3245
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:4852
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:2755
void add_keys_to_map(mapT *map, int index) const
Adds keys to union of local keys with specified index.
Definition funcimpl.h:5852
void change_tensor_type1(const TensorArgs &targs, bool fence)
change the tensor type of the coefficients in the FunctionNode
Definition mraimpl.h:1095
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:6842
int initial_level
Initial level for refinement.
Definition funcimpl.h:974
int max_refine_level
Do not refine below this level.
Definition funcimpl.h:977
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:4810
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:3769
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:3739
void do_square_inplace(const keyT &key)
int special_level
Minimium level for refinement on special points.
Definition funcimpl.h:975
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:4744
double errsq_local(const opT &func) const
Returns the sum of squares of errors from local info ... no comms.
Definition funcimpl.h:5546
WorldContainer< keyT, nodeT > dcT
Type of container holding the coefficients.
Definition funcimpl.h:957
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:2936
void scale_inplace(const T q, bool fence)
In-place scale by a constant.
Definition mraimpl.h:3107
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:219
void unary_op_coeff_inplace(const opT &op, bool fence)
Definition funcimpl.h:2089
World & world
Definition funcimpl.h:964
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:3807
bool is_redundant() const
Returns true if the function is redundant.
Definition mraimpl.h:258
FunctionNode< T, NDIM > nodeT
Type of node.
Definition funcimpl.h:955
std::size_t nCoeff_local() const
Returns the number of coefficients in the function for this MPI rank.
Definition mraimpl.h:1918
void print_size(const std::string name) const
print tree size and size
Definition mraimpl.h:1937
FunctionImpl(const FunctionImpl< T, NDIM > &p)
void print_info() const
Prints summary of data distribution.
Definition mraimpl.h:829
void abs_inplace(bool fence)
Definition mraimpl.h:3119
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:3114
void print_timer() const
Definition mraimpl.h:353
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:2978
const FunctionCommonData< T, NDIM > & cdata
Definition funcimpl.h:983
void do_print_grid(const std::string filename, const std::vector< keyT > &keys) const
print the grid in xyz format
Definition mraimpl.h:580
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:3028
int get_truncate_mode() const
Definition funcimpl.h:1727
const std::vector< Vector< double, NDIM > > & get_special_points() const
Definition funcimpl.h:969
std::size_t nCoeff() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1928
double vol_nsphere(int n, double R)
Definition funcimpl.h:4840
keyT neighbor_in_volume(const keyT &key, const keyT &disp) const
Returns key of general neighbor that resides in-volume.
Definition mraimpl.h:3226
void compress(const TreeState newstate, bool fence)
compress the wave function
Definition mraimpl.h:1496
void do_dirac_convolution(FunctionImpl< T, LDIM > *f, bool fence) const
Definition funcimpl.h:2172
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:1664
Future< bool > truncate_spawn(const keyT &key, double tol)
Returns true if after truncation this node has coefficients.
Definition mraimpl.h:2600
void print_type_in_compilation_error(R &&)
Definition funcimpl.h:6155
Future< double > norm_tree_spawn(const keyT &key)
Definition mraimpl.h:1566
std::vector< keyT > local_leaf_keys() const
return the keys of the local leaf boxes
Definition mraimpl.h:554
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:2673
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:2889
void unset_functor()
Definition mraimpl.h:308
void refine_spawn(const opT &op, const keyT &key)
Definition funcimpl.h:4572
void apply_1d_realspace_push(const opT &op, const FunctionImpl< R, NDIM > *f, int axis, bool fence)
Definition funcimpl.h:3858
static double conj(float x)
Definition funcimpl.h:6041
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:495
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:961
void set_functor(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor1)
Definition mraimpl.h:289
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:1621
bool verify_tree_state_local() const
check that the tree state and the coeffs are consistent
Definition mraimpl.h:165
const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > & get_pmap() const
Definition mraimpl.h:203
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:1936
Timer timer_filter
Definition funcimpl.h:997
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:2813
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:5365
double get_thresh() const
Definition mraimpl.h:324
void trickle_down(bool fence)
sum all the contributions from all scales after applying an operator in mod-NS form
Definition mraimpl.h:1350
bool autorefine
If true, autorefine where appropriate.
Definition funcimpl.h:979
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:1724
void set_autorefine(bool value)
Definition mraimpl.h:333
tensorT filter(const tensorT &s) const
Transform sum coefficients at level n to sums+differences at level n-1.
Definition mraimpl.h:1148
void chop_at_level(const int n, const bool fence=true)
remove all nodes with level higher than n
Definition mraimpl.h:1111
void unaryXXvalues(const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)
Definition funcimpl.h:3272
static std::complex< double > conj(const std::complex< double > x)
Definition funcimpl.h:6045
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:6171
TreeState tree_state
Definition funcimpl.h:986
void print_tree_json(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2693
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:703
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:1053
bool is_compressed() const
Returns true if the function is compressed.
Definition mraimpl.h:246
Vector< double, NDIM > coordT
Type of vector holding coordinates.
Definition funcimpl.h:959
void apply(opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
apply an operator on f to return this
Definition funcimpl.h:5042
Tensor< T > tensorT
Type of tensor for anything but to hold coeffs.
Definition funcimpl.h:952
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:1062
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:6765
void store(Archive &ar)
Definition funcimpl.h:1296
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:2038
void gaxpy_ext(const FunctionImpl< L, NDIM > *left, T(*f)(const coordT &), T alpha, T beta, double tol, bool fence)
Definition funcimpl.h:6929
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:1217
void print_stats() const
print the number of configurations per node
Definition mraimpl.h:1965
void broaden(const array_of_bools< NDIM > &is_periodic, bool fence)
Definition mraimpl.h:1299
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:1613
void refine_op(const opT &op, const keyT &key)
Definition funcimpl.h:4547
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:6051
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:2438
Timer timer_change_tensor_type
Definition funcimpl.h:995
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:919
std::vector< Slice > child_patch(const keyT &child) const
Returns patch referring to coeffs of child in parent box.
Definition mraimpl.h:692
void print_tree_graphviz(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2746
void set_tree_state(const TreeState &state)
Definition funcimpl.h:1327
std::size_t min_nodes() const
Returns the min number of nodes on a processor.
Definition mraimpl.h:1869
void copy_coeffs_same_world(const FunctionImpl< Q, NDIM > &other, bool fence)
Copy coeffs from other into self.
Definition funcimpl.h:1171
std::shared_ptr< FunctionFunctorInterface< T, NDIM > > functor
Definition funcimpl.h:985
Timer timer_compress_svd
Definition funcimpl.h:998
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:2011
void make_redundant(const bool fence)
convert this to redundant, i.e. have sum coefficients on all levels
Definition mraimpl.h:1524
void load(Archive &ar)
Definition funcimpl.h:1278
std::size_t max_nodes() const
Returns the max number of nodes on a processor.
Definition mraimpl.h:1860
T inner_ext_local(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const
Definition funcimpl.h:6740
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:1227
TensorArgs targs
type of tensor to be used in the FunctionNodes
Definition funcimpl.h:981
void flo_unary_op_node_inplace(const opT &op, bool fence)
Definition funcimpl.h:2201
std::size_t size_local() const
Returns the number of coefficients in the function for each rank.
Definition mraimpl.h:1887
GenTensor< Q > values2coeffs(const keyT &key, const GenTensor< Q > &values) const
Definition funcimpl.h:1915
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:3317
T trace_local() const
Returns int(f(x),x) in local volume.
Definition mraimpl.h:3161
void print_grid(const std::string filename) const
Definition mraimpl.h:538
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:3254
bool get_autorefine() const
Definition mraimpl.h:330
int k
Wavelet order.
Definition funcimpl.h:972
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:2733
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:3129
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:3241
TensorType get_tensor_type() const
Definition mraimpl.h:315
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:7149
void remove_leaf_coefficients(const bool fence)
Definition mraimpl.h:1518
void insert_zero_down_to_initial_level(const keyT &key)
Initialize nodes to zero function at initial_level of refinement.
Definition mraimpl.h:2569
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:930
typedef TENSOR_RESULT_TYPE(T, R) resultT
void unary_op_node_inplace(const opT &op, bool fence)
Definition funcimpl.h:2110
T inner_adaptive_local(const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > f, const bool leaf_refine) const
Definition funcimpl.h:6751
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:2724
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:6326
std::shared_ptr< FunctionImpl< T, NDIM > > pimplT
pointer to this class
Definition funcimpl.h:951
TENSOR_RESULT_TYPE(T, R) dot_local(const FunctionImpl< R
Returns the dot product ASSUMING same distribution.
void finalize_sum()
after summing up we need to do some cleanup;
Definition mraimpl.h:1817
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:1514
dcT coeffs
The coefficients.
Definition funcimpl.h:988
bool exists_and_is_leaf(const keyT &key) const
Definition mraimpl.h:1271
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:4339
void unaryXX(const FunctionImpl< Q, NDIM > *func, const opT &op, bool fence)
Definition funcimpl.h:3259
std::vector< std::pair< int, const coeffT * > > mapvecT
Type of the entry in the map returned by make_key_vec_map.
Definition funcimpl.h:5846
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:6945
void verify_tree() const
Verify tree is properly constructed ... global synchronization involved.
Definition mraimpl.h:107
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:1185
void copy_remote_coeffs_from_pid(const ProcessID pid, const FunctionImpl< Q, NDIM > &other, bool fence)
Definition funcimpl.h:1153
void set_tensor_args(const TensorArgs &t)
Definition mraimpl.h:321
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:1964
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:5637
std::size_t real_size() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1905
bool exists_and_has_children(const keyT &key) const
Definition mraimpl.h:1266
void sum_down_spawn(const keyT &key, const coeffT &s)
is this the same as trickle_down() ?
Definition mraimpl.h:872
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:2860
long box_interior[1000]
Definition funcimpl.h:3303
keyT neighbor(const keyT &key, const keyT &disp, const array_of_bools< NDIM > &is_periodic) const
Returns key of general neighbor enforcing BC.
Definition mraimpl.h:3211
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:1834
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:1543
void gaxpy_inplace(const T &alpha, const FunctionImpl< Q, NDIM > &other, const R &beta, bool fence)
Inplace general bilinear operation.
Definition funcimpl.h:1265
bool has_leaves() const
Definition mraimpl.h:284
bool verify_parents_and_children() const
check that parents and children are consistent
Definition mraimpl.h:115
void apply_source_driven(opT &op, const FunctionImpl< R, NDIM > &f, bool fence)
similar to apply, but for low rank coeffs
Definition funcimpl.h:5190
void distribute(std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > newmap) const
Definition funcimpl.h:1125
int get_special_level() const
Definition funcimpl.h:968
void reconstruct_op(const keyT &key, const coeffT &s, const bool accumulate_NS=true)
Definition mraimpl.h:2075
tensorT gaxpy_ext_node(keyT key, Tensor< L > lc, T(*f)(const coordT &), T alpha, T beta) const
Definition funcimpl.h:6818
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:3144
WorldObject< FunctionImpl< T, NDIM > > woT
Base class world object type.
Definition funcimpl.h:947
void undo_redundant(const bool fence)
convert this from redundant to standard reconstructed form
Definition mraimpl.h:1534
GenTensor< T > coeffT
Type of tensor used to hold coeffs.
Definition funcimpl.h:956
const keyT & key0() const
Returns cdata.key0.
Definition mraimpl.h:390
double finalize_apply()
after apply we need to do some cleanup;
Definition mraimpl.h:1774
bool leaves_only
Definition funcimpl.h:5642
friend hashT hash_value(const FunctionImpl< T, NDIM > *pimpl)
Hash a pointer to FunctionImpl.
Definition funcimpl.h:7249
const dcT & get_coeffs() const
Definition mraimpl.h:339
FunctionImpl(World &world, const FunctionImpl< Q, NDIM > &other, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool dozero)
Copy constructor.
Definition funcimpl.h:1087
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:6617
double norm2sq_local() const
Returns the square of the local norm ... no comms.
Definition mraimpl.h:1826
const FunctionCommonData< T, NDIM > & get_cdata() const
Definition mraimpl.h:345
void sum_down(bool fence)
After 1d push operator must sum coeffs down the tree to restore correct scaling function coefficients...
Definition mraimpl.h:911
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:6634
bool noautorefine(const keyT &key, const tensorT &t) const
Always returns false (for when autorefine is not wanted)
Definition mraimpl.h:855
double truncate_tol(double tol, const keyT &key) const
Returns the truncation threshold according to truncate_method.
Definition mraimpl.h:645
void flo_unary_op_node_inplace(const opT &op, bool fence) const
Definition funcimpl.h:2211
bool autorefine_square_test(const keyT &key, const nodeT &t) const
Returns true if this block of coeffs needs autorefining.
Definition mraimpl.h:861
void erase(const Level &max_level)
truncate tree at a certain level
Definition mraimpl.h:735
void mulXX(const FunctionImpl< L, NDIM > *left, const FunctionImpl< R, NDIM > *right, double tol, bool fence)
Definition funcimpl.h:3231
void reconstruct(bool fence)
reconstruct this tree – respects fence
Definition mraimpl.h:1464
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:3631
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:1009
static void tnorm(const tensorT &t, double *lo, double *hi)
Computes norm of low/high-order polyn. coeffs for autorefinement test.
Definition mraimpl.h:3021
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:2907
std::size_t max_depth() const
Returns the maximum depth of the tree ... collective ... global sum/broadcast.
Definition mraimpl.h:1852
std::size_t size() const
Returns the number of coefficients in the function ... collective global sum.
Definition mraimpl.h:1897
void reduce_rank(const double thresh, bool fence)
reduce the rank of the coefficients tensors
Definition mraimpl.h:1103
TreeState get_tree_state() const
Definition funcimpl.h:1331
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:1205
std::shared_ptr< FunctionFunctorInterface< T, NDIM > > get_functor()
Definition mraimpl.h:296
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:5079
tensorT unfilter(const tensorT &s) const
Transform sums+differences at level n to sum coefficients at level n+1.
Definition mraimpl.h:1177
int get_initial_level() const
getter
Definition funcimpl.h:967
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:3410
virtual ~FunctionImpl()
Definition funcimpl.h:1117
Vector< Translation, NDIM > tranT
Type of array holding translation.
Definition funcimpl.h:953
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:1403
Future< coeffT > truncate_reconstructed_spawn(const keyT &key, const double tol)
truncate using a tree in reconstructed form
Definition mraimpl.h:1589
GenTensor< Q > coeffs2values(const keyT &key, const GenTensor< Q > &coeff) const
Definition funcimpl.h:1782
FunctionImpl(const FunctionFactory< T, NDIM > &factory)
Initialize function impl from data in factory.
Definition funcimpl.h:1004
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:1072
Timer timer_lr_result
Definition funcimpl.h:996
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:2061
void truncate(double tol, bool fence)
Truncate according to the threshold with optional global fence.
Definition mraimpl.h:374
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:1986
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:7091
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:4772
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:6103
Tensor< Q > coeffs2values(const keyT &key, const Tensor< Q > &coeff) const
Definition funcimpl.h:1908
Tensor< Q > values2coeffs(const keyT &key, const Tensor< Q > &values) const
Definition funcimpl.h:1922
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:2837
bool is_reconstructed() const
Returns true if the function is compressed.
Definition mraimpl.h:252
void replicate(bool fence=true)
Definition funcimpl.h:1121
double norm_tree_op(const keyT &key, const std::vector< Future< double > > &v)
Definition mraimpl.h:1551
void reset_timer()
Definition mraimpl.h:362
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:765
int get_k() const
Definition mraimpl.h:336
void dirac_convolution_op(const keyT &key, const nodeT &node, FunctionImpl< T, LDIM > *f) const
The operator.
Definition funcimpl.h:2127
FunctionImpl< T, NDIM > implT
Type of this class (implementation)
Definition funcimpl.h:950
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:2863
bool truncate_op(const keyT &key, double tol, const std::vector< Future< bool > > &v)
Definition mraimpl.h:2636
void zero_norm_tree()
Definition mraimpl.h:1288
std::size_t max_local_depth() const
Returns the maximum local depth of the tree ... no communications.
Definition mraimpl.h:1838
tensorT project(const keyT &key) const
Definition mraimpl.h:2781
double thresh
Screening threshold.
Definition funcimpl.h:973
double check_symmetry_local() const
Returns some asymmetry measure ... no comms.
Definition mraimpl.h:751
Future< double > get_norm_tree_recursive(const keyT &key) const
Definition mraimpl.h:2802
bool is_redundant_after_merge() const
Returns true if the function is redundant_after_merge.
Definition mraimpl.h:264
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:3288
Key< NDIM > keyT
Type of key.
Definition funcimpl.h:954
friend hashT hash_value(const std::shared_ptr< FunctionImpl< T, NDIM > > impl)
Hash a shared_ptr to FunctionImpl.
Definition funcimpl.h:7259
std::vector< Vector< double, NDIM > > special_points
special points for further refinement (needed for composite functions or multiplication)
Definition funcimpl.h:976
bool truncate_on_project
If true projection inserts at level n-1 not n.
Definition funcimpl.h:980
AtomicInt small
Definition funcimpl.h:1000
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:6002
bool is_on_demand() const
Definition mraimpl.h:279
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:5478
void accumulate_timer(const double time) const
Definition mraimpl.h:348
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:1361
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:5921
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:2924
void set_thresh(double value)
Definition mraimpl.h:327
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:419
void sock_it_to_me_too(const keyT &key, const RemoteReference< FutureImpl< std::pair< keyT, coeffT > > > &ref) const
Definition mraimpl.h:2841
void broaden_op(const keyT &key, const std::vector< Future< bool > > &v)
Definition mraimpl.h:1277
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:399
void print_tree(std::ostream &os=std::cout, Level maxlevel=10000) const
Definition mraimpl.h:2664
void project_refine_op(const keyT &key, bool do_refine, const std::vector< Vector< double, NDIM > > &specialpts)
Definition mraimpl.h:2450
void scale_oop(const Q q, const FunctionImpl< F, NDIM > &f, bool fence)
Out-of-place scale by a constant.
Definition funcimpl.h:7226
T typeT
Definition funcimpl.h:949
std::size_t tree_size() const
Returns the size of the tree structure of the function ... collective global sum.
Definition mraimpl.h:1878
ConcurrentHashMap< keyT, mapvecT > mapT
Type of the map returned by make_key_vec_map.
Definition funcimpl.h:5849
void add_scalar_inplace(T t, bool fence)
Adds a constant to the function. Local operation, optional fence.
Definition mraimpl.h:2528
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:3725
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:1197
void abs_square_inplace(bool fence)
Definition mraimpl.h:3124
FunctionImpl(const FunctionImpl< Q, NDIM > &other, const std::shared_ptr< WorldDCPmapInterface< Key< NDIM > > > &pmap, bool dozero)
Copy constructor.
Definition funcimpl.h:1073
void refine(const opT &op, bool fence)
Definition funcimpl.h:4585
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:5870
void copy_coeffs_different_world(const FunctionImpl< Q, NDIM > &other, bool fence)
Copy coefficients from other funcimpl with possibly different world and on a different node.
Definition funcimpl.h:1144
void put_in_box(ProcessID from, long nl, long ni) const
Definition mraimpl.h:820
void unary_op_value_inplace(const opT &op, bool fence)
Definition funcimpl.h:2904
std::pair< const keyT, nodeT > datumT
Type of entry in container.
Definition funcimpl.h:958
Timer timer_accumulate
Definition funcimpl.h:994
TensorArgs get_tensor_args() const
Definition mraimpl.h:318
void unaryXXa(const keyT &key, const FunctionImpl< Q, NDIM > *func, const opT &op)
Definition funcimpl.h:3206
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:4400
void average(const implT &rhs)
take the average of two functions, similar to: this=0.5*(this+rhs)
Definition mraimpl.h:1084
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:5231
void diff(const DerivativeBase< T, NDIM > *D, const implT *f, bool fence)
Definition mraimpl.h:942
void square_inplace(bool fence)
Pointwise squaring of function with optional global fence.
Definition mraimpl.h:3113
void remove_internal_coefficients(const bool fence)
Definition mraimpl.h:1513
void compute_snorm_and_dnorm(bool fence=true)
compute norm of s and d coefficients for all nodes
Definition mraimpl.h:1127
std::vector< unsigned char > serialize_remote_coeffs()
invoked by copy_remote_coeffs_from_pid to serialize local coeffs
Definition funcimpl.h:1162
long box_leaf[1000]
Definition funcimpl.h:3302
void standard(bool fence)
Changes non-standard compressed form to standard compressed form.
Definition mraimpl.h:1761
void multiop_values_doit(const keyT &key, const opT &op, const std::vector< implT * > &v)
Definition funcimpl.h:2795
bool is_nonstandard_with_leaves() const
Definition mraimpl.h:274
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:1883
int truncate_mode
0=default=(|d|<thresh), 1=(|d|<thresh/2^n), 2=(|d|<thresh/4^n);
Definition funcimpl.h:978
void multiop_values(const opT &op, const std::vector< implT * > &v)
Definition funcimpl.h:2812
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:1798
FunctionNode holds the coefficients, etc., at each node of the 2^NDIM-tree.
Definition funcimpl.h:127
FunctionNode< Q, NDIM > convert() const
Copy with possible type conversion of coefficients, copying all other state.
Definition funcimpl.h:194
GenTensor< T > coeffT
Definition funcimpl.h:129
bool has_coeff() const
Returns true if there are coefficients in this node.
Definition funcimpl.h:200
void recompute_snorm_and_dnorm(const FunctionCommonData< T, NDIM > &cdata)
Definition funcimpl.h:335
FunctionNode(const coeffT &coeff, bool has_children=false)
Constructor from given coefficients with optional children.
Definition funcimpl.h:156
FunctionNode()
Default constructor makes node without coeff or children.
Definition funcimpl.h:146
void serialize(Archive &ar)
Definition funcimpl.h:458
void consolidate_buffer(const TensorArgs &args)
Definition funcimpl.h:444
double get_dnorm() const
return the precomputed norm of the (virtual) d coefficients
Definition funcimpl.h:316
size_t size() const
Returns the number of coefficients in this node.
Definition funcimpl.h:242
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:259
FunctionNode< T, NDIM > & operator=(const FunctionNode< T, NDIM > &other)
Definition funcimpl.h:176
double snorm
norm of the s coefficients
Definition funcimpl.h:141
void clear_coeff()
Clears the coefficients (has_coeff() will subsequently return false)
Definition funcimpl.h:295
Tensor< T > tensorT
Definition funcimpl.h:130
coeffT buffer
The coefficients, if any.
Definition funcimpl.h:139
T trace_conj(const FunctionNode< T, NDIM > &rhs) const
Definition funcimpl.h:453
void scale(Q a)
Scale the coefficients of this node.
Definition funcimpl.h:301
bool is_leaf() const
Returns true if this does not have children.
Definition funcimpl.h:213
void set_has_children(bool flag)
Sets has_children attribute to value of flag.
Definition funcimpl.h:254
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:416
double get_norm_tree() const
Gets the value of norm_tree.
Definition funcimpl.h:311
bool _has_children
True if there are children.
Definition funcimpl.h:138
FunctionNode(const coeffT &coeff, double norm_tree, double snorm, double dnorm, bool has_children)
Definition funcimpl.h:166
void set_snorm(const double sn)
set the precomputed norm of the (virtual) s coefficients
Definition funcimpl.h:321
coeffT _coeffs
The coefficients, if any.
Definition funcimpl.h:136
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:383
void reduceRank(const double &eps)
reduces the rank of the coefficients (if applicable)
Definition funcimpl.h:249
WorldContainer< Key< NDIM >, FunctionNode< T, NDIM > > dcT
Definition funcimpl.h:144
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:365
double _norm_tree
After norm_tree will contain norm of coefficients summed up tree.
Definition funcimpl.h:137
void set_is_leaf(bool flag)
Sets has_children attribute to value of !flag.
Definition funcimpl.h:280
void print_json(std::ostream &s) const
Definition funcimpl.h:466
double get_snorm() const
get the precomputed norm of the (virtual) s coefficients
Definition funcimpl.h:331
const coeffT & coeff() const
Returns a const reference to the tensor containing the coeffs.
Definition funcimpl.h:237
FunctionNode(const coeffT &coeff, double norm_tree, bool has_children)
Definition funcimpl.h:161
bool has_children() const
Returns true if this node has children.
Definition funcimpl.h:207
void set_coeff(const coeffT &coeffs)
Takes a shallow copy of the coeff — same as this->coeff()=coeff.
Definition funcimpl.h:285
void set_dnorm(const double dn)
set the precomputed norm of the (virtual) d coefficients
Definition funcimpl.h:326
double dnorm
norm of the d coefficients, also defined if there are no d coefficients
Definition funcimpl.h:140
bool is_invalid() const
Returns true if this node is invalid (no coeffs and no children)
Definition funcimpl.h:219
FunctionNode(const FunctionNode< T, NDIM > &other)
Definition funcimpl.h:170
coeffT & coeff()
Returns a non-const reference to the tensor containing the coeffs.
Definition funcimpl.h:227
void set_norm_tree(double norm_tree)
Sets the value of norm_tree.
Definition funcimpl.h:306
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:466
Key is the index for a node of the 2^NDIM-tree.
Definition key.h:69
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:405
Level level() const
Definition key.h:168
bool is_valid() const
Checks if a key is valid.
Definition key.h:123
hashT hash() const
Definition key.h:157
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:391
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:383
Key parent(int generation=1) const
Returns the key of the parent.
Definition key.h:252
const Vector< Translation, NDIM > & translation() const
Definition key.h:173
void break_apart(Key< LDIM > &key1, Key< KDIM > &key2) const
break key into two low-dimensional keys
Definition key.h:343
A pmap that locates children on odd levels with their even level parents.
Definition funcimpl.h:105
LevelPmap(World &world)
Definition funcimpl.h:111
const int nproc
Definition funcimpl.h:107
LevelPmap()
Definition funcimpl.h:109
ProcessID owner(const keyT &key) const
Find the owner of a given key.
Definition funcimpl.h:114
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:86
SimplePmap(World &world)
Definition funcimpl.h:92
const int nproc
Definition funcimpl.h:88
const ProcessID me
Definition funcimpl.h:89
ProcessID owner(const keyT &key) const
Maps key to processor.
Definition funcimpl.h:95
A slice defines a sub-range or patch of a dimension.
Definition slice.h:103
static TaskAttributes hipri()
Definition thread.h:456
Traits class to specify support of numeric types.
Definition type_data.h:56
A tensor is a multidimensional 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:1825
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
Tensor< T > & emul(const Tensor< T > &t)
Inplace multiply by corresponding elements of argument Tensor.
Definition tensor.h:1799
bool has_data() const
Definition tensor.h:1887
const TensorIterator< T > & end() const
End point for forward iteration.
Definition tensor.h:1877
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:1805
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:492
WorldTaskQueue & taskq
Task queue.
Definition world.h:206
std::vector< uniqueidT > get_object_ids() const
Returns a vector of all unique IDs in this World.
Definition world.h:468
ProcessID rank() const
Returns the process rank in this World (same as MPI_Comm_rank()).
Definition world.h:320
static std::vector< unsigned long > get_world_ids()
return a vector containing all world ids
Definition world.h:476
ProcessID size() const
Returns the number of processes in this World (same as MPI_Comm_size()).
Definition world.h:330
unsigned long id() const
Definition world.h:315
WorldGopInterface & gop
Global operations.
Definition world.h:207
std::optional< T * > ptr_from_id(uniqueidT id) const
Look up a local pointer from a world-wide unique ID.
Definition world.h:416
ProcessID random_proc()
Returns a random process number; that is, an integer in [0,world.size()).
Definition world.h:591
Wraps an archive around an STL vector for output.
Definition vector_archive.h:55
Wrapper for an opaque pointer for serialization purposes.
Definition archive.h:851
syntactic sugar for std::array<bool, N>
Definition array_of_bools.h:19
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:28
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:926
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:2503
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:2444
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.
constexpr 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:401
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:1181
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:707
TreeState
Definition funcdefaults.h:59
@ nonstandard_after_apply
s and d coeffs, state after operator application
Definition funcdefaults.h:64
@ redundant_after_merge
s coeffs everywhere, must be summed up to yield the result
Definition funcdefaults.h:66
@ reconstructed
s coeffs at the leaves only
Definition funcdefaults.h:60
@ nonstandard
s and d coeffs in internal nodes
Definition funcdefaults.h:62
@ redundant
s coeffs everywhere
Definition funcdefaults.h:65
static Tensor< double > weights[max_npt+1]
Definition legendre.cc:99
int64_t Translation
Definition key.h:57
Key< NDIM > displacement(const Key< NDIM > &source, const Key< NDIM > &target)
given a source and a target, return the displacement in translation
Definition key.h:451
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:58
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:115
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:226
Tensor< T > fcube(const Key< NDIM > &, T(*f)(const Vector< double, NDIM > &), const Tensor< double > &)
Definition mraimpl.h:2129
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:2498
void error(const char *msg)
Definition world.cc:139
NDIM const Function< R, NDIM > & g
Definition mra.h:2498
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:640
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:2066
static const int MAXK
The maximum wavelet order presently supported.
Definition funcdefaults.h:54
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
Key parent() const
Definition test_tree.cc:68
hashT hash() const
Definition test_dc.cc:54
Definition test_ccpairfunction.cc:22
given a ket and the 1- and 2-electron potentials, construct the function V phi
Definition funcimpl.h:4060
implT * result
where to construct Vphi, no need to track parents
Definition funcimpl.h:4068
bool have_v2() const
Definition funcimpl.h:4077
ctL iav1
Definition funcimpl.h:4072
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:4086
ctL iap1
Definition funcimpl.h:4071
bool have_v1() const
Definition funcimpl.h:4076
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:4152
opT leaf_op
deciding if a given FunctionNode will be a leaf node
Definition funcimpl.h:4069
std::pair< coeffT, double > make_sum_coeffs(const keyT &key) const
make the sum coeffs for key
Definition funcimpl.h:4245
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:4065
ctL iap2
the particles 1 and 2 (exclusive with ket)
Definition funcimpl.h:4071
bool have_ket() const
Definition funcimpl.h:4075
const implT * eri
2-particle potential, must be on-demand
Definition funcimpl.h:4073
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:4066
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
make and insert the coefficients into result's tree
Definition funcimpl.h:4097
void serialize(const Archive &ar)
serialize this (needed for use in recursive_op)
Definition funcimpl.h:4326
Vphi_op_NS< opT, LDIM > this_type
Definition funcimpl.h:4064
ctT iaket
the ket of a pair function (exclusive with p1, p2)
Definition funcimpl.h:4070
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:4198
void accumulate_into_result(const Key< NDIM > &key, const coeffT &coeff) const
Definition funcimpl.h:4080
this_type make_child(const keyT &child) const
Definition funcimpl.h:4297
tensorT eri_coeffs(const keyT &key) const
Definition funcimpl.h:4178
ctL iav2
potentials for particles 1 and 2
Definition funcimpl.h:4072
bool have_eri() const
Definition funcimpl.h:4078
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:4319
Vphi_op_NS()
Definition funcimpl.h:4085
Future< this_type > activate() const
Definition funcimpl.h:4308
bool randomize() const
Definition funcimpl.h:4062
add two functions f and g: result=alpha * f + beta * g
Definition funcimpl.h:3570
bool randomize() const
Definition funcimpl.h:3575
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:3605
add_op(const ctT &f, const ctT &g, const double alpha, const double beta)
Definition funcimpl.h:3583
ctT f
tracking coeffs of first and second addend
Definition funcimpl.h:3578
double alpha
prefactor for f, g
Definition funcimpl.h:3580
add_op this_type
Definition funcimpl.h:3573
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:3572
void serialize(const Archive &ar)
Definition funcimpl.h:3617
ctT g
Definition funcimpl.h:3578
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:3587
double beta
Definition funcimpl.h:3580
this_type make_child(const keyT &child) const
Definition funcimpl.h:3600
this_type forward_ctor(const ctT &f1, const ctT &g1, const double alpha, const double beta)
taskq-compatible ctor
Definition funcimpl.h:3613
Definition funcimpl.h:3173
opT op
Definition funcimpl.h:3176
opT::resultT resultT
Definition funcimpl.h:3174
Tensor< resultT > operator()(const Key< NDIM > &key, const Tensor< Q > &t) const
Definition funcimpl.h:3183
coeff_value_adaptor(const FunctionImpl< Q, NDIM > *impl_func, const opT &op)
Definition funcimpl.h:3179
const FunctionImpl< Q, NDIM > * impl_func
Definition funcimpl.h:3175
coeff_value_adaptor()=default
void serialize(Archive &ar)
Definition funcimpl.h:3192
merge the coefficent boxes of this into result's tree
Definition funcimpl.h:2415
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2416
do_accumulate_trees()=default
void serialize(const Archive &ar)
Definition funcimpl.h:2433
FunctionImpl< Q, NDIM > * result
Definition funcimpl.h:2417
do_accumulate_trees(FunctionImpl< Q, NDIM > &result, const T alpha)
Definition funcimpl.h:2420
T alpha
Definition funcimpl.h:2418
bool operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2424
"put" this on g
Definition funcimpl.h:2626
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2627
void serialize(const Archive &ar)
Definition funcimpl.h:2655
implT * g
Definition funcimpl.h:2629
do_average()
Definition funcimpl.h:2631
bool operator()(typename rangeT::iterator &it) const
iterator it points to this
Definition funcimpl.h:2635
do_average(implT &g)
Definition funcimpl.h:2632
change representation of nodes' coeffs to low rank, optional fence
Definition funcimpl.h:2659
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2660
void serialize(const Archive &ar)
Definition funcimpl.h:2683
TensorArgs targs
Definition funcimpl.h:2663
do_change_tensor_type(const TensorArgs &targs, implT &g)
Definition funcimpl.h:2669
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2672
implT * f
Definition funcimpl.h:2664
do_change_tensor_type()=default
check symmetry wrt particle exchange
Definition funcimpl.h:2332
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2333
double operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2339
do_check_symmetry_local()
Definition funcimpl.h:2335
void serialize(const Archive &ar)
Definition funcimpl.h:2402
double operator()(double a, double b) const
Definition funcimpl.h:2398
do_check_symmetry_local(const implT &f)
Definition funcimpl.h:2336
const implT * f
Definition funcimpl.h:2334
compute the norm of the wavelet coefficients
Definition funcimpl.h:4467
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:4468
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:4474
do_compute_snorm_and_dnorm(const FunctionCommonData< T, NDIM > &cdata)
Definition funcimpl.h:4471
const FunctionCommonData< T, NDIM > & cdata
Definition funcimpl.h:4470
Definition funcimpl.h:2686
TensorArgs targs
Definition funcimpl.h:2690
do_consolidate_buffer()=default
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2695
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2687
do_consolidate_buffer(const TensorArgs &targs)
Definition funcimpl.h:2694
void serialize(const Archive &ar)
Definition funcimpl.h:2699
Definition funcimpl.h:1446
double operator()(double val) const
Definition funcimpl.h:1452
double limit
Definition funcimpl.h:1447
do_convert_to_color(const double limit, const bool log)
Definition funcimpl.h:1451
bool log
Definition funcimpl.h:1448
do_convert_to_color()=default
static double lower()
Definition funcimpl.h:1449
compute the inner product of this range with other
Definition funcimpl.h:5787
do_dot_local(const FunctionImpl< R, NDIM > *other, const bool leaves_only)
Definition funcimpl.h:5792
bool leaves_only
Definition funcimpl.h:5789
typedef TENSOR_RESULT_TYPE(T, R) resultT
resultT operator()(resultT a, resultT b) const
Definition funcimpl.h:5820
const FunctionImpl< R, NDIM > * other
Definition funcimpl.h:5788
void serialize(const Archive &ar)
Definition funcimpl.h:5824
resultT operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5794
functor for the gaxpy_inplace method
Definition funcimpl.h:1237
FunctionImpl< T, NDIM > * f
prefactor for current function impl
Definition funcimpl.h:1239
do_gaxpy_inplace(FunctionImpl< T, NDIM > *f, T alpha, R beta)
Definition funcimpl.h:1243
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:1244
R beta
prefactor for other function impl
Definition funcimpl.h:1241
void serialize(Archive &ar)
Definition funcimpl.h:1252
Range< typename FunctionImpl< Q, NDIM >::dcT::const_iterator > rangeT
Definition funcimpl.h:1238
T alpha
the current function impl
Definition funcimpl.h:1240
do_gaxpy_inplace()=default
Definition funcimpl.h:6705
const bool do_leaves
start with leaf nodes instead of initial_level
Definition funcimpl.h:6709
T operator()(T a, T b) const
Definition funcimpl.h:6727
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:6711
void serialize(const Archive &ar)
Definition funcimpl.h:6731
const bool leaf_refine
Definition funcimpl.h:6708
const std::shared_ptr< FunctionFunctorInterface< T, NDIM > > fref
Definition funcimpl.h:6706
T operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:6715
const implT * impl
Definition funcimpl.h:6707
compute the inner product of this range with other
Definition funcimpl.h:5650
const FunctionImpl< T, NDIM > * bra
Definition funcimpl.h:5651
void serialize(const Archive &ar)
Definition funcimpl.h:5766
const FunctionImpl< R, NDIM > * ket
Definition funcimpl.h:5652
typedef TENSOR_RESULT_TYPE(T, R) resultT
bool leaves_only
Definition funcimpl.h:5653
do_inner_local_on_demand(const FunctionImpl< T, NDIM > *bra, const FunctionImpl< R, NDIM > *ket, const bool leaves_only=true)
Definition funcimpl.h:5656
resultT operator()(resultT a, resultT b) const
Definition funcimpl.h:5762
resultT operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5659
compute the inner product of this range with other
Definition funcimpl.h:5589
resultT operator()(resultT a, resultT b) const
Definition funcimpl.h:5622
bool leaves_only
Definition funcimpl.h:5591
void serialize(const Archive &ar)
Definition funcimpl.h:5626
do_inner_local(const FunctionImpl< R, NDIM > *other, const bool leaves_only)
Definition funcimpl.h:5594
const FunctionImpl< R, NDIM > * other
Definition funcimpl.h:5590
resultT operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5596
typedef TENSOR_RESULT_TYPE(T, R) resultT
keep only the sum coefficients in each node
Definition funcimpl.h:2286
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2287
do_keep_sum_coeffs(implT *impl)
constructor need impl for cdata
Definition funcimpl.h:2291
implT * impl
Definition funcimpl.h:2288
void serialize(const Archive &ar)
Definition funcimpl.h:2300
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2293
mirror dimensions of this, write result on f
Definition funcimpl.h:2560
do_map_and_mirror()=default
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2570
implT * f
Definition funcimpl.h:2564
std::vector< long > mirror
Definition funcimpl.h:2563
void serialize(const Archive &ar)
Definition funcimpl.h:2617
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2561
std::vector< long > map
Definition funcimpl.h:2563
do_map_and_mirror(const std::vector< long > map, const std::vector< long > mirror, implT &f)
Definition funcimpl.h:2567
map this on f
Definition funcimpl.h:2480
do_mapdim(const std::vector< long > map, implT &f)
Definition funcimpl.h:2487
void serialize(const Archive &ar)
Definition funcimpl.h:2503
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2481
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2489
std::vector< long > map
Definition funcimpl.h:2483
do_mapdim()
Definition funcimpl.h:2486
implT * f
Definition funcimpl.h:2484
merge the coefficient boxes of this into other's tree
Definition funcimpl.h:2444
bool operator()(typename rangeT::iterator &it) const
return the norm of the difference of this node and its "mirror" node
Definition funcimpl.h:2454
Range< typename dcT::const_iterator > rangeT
Definition funcimpl.h:2445
FunctionImpl< Q, NDIM > * other
Definition funcimpl.h:2446
do_merge_trees(const T alpha, const R beta, FunctionImpl< Q, NDIM > &other)
Definition funcimpl.h:2450
T alpha
Definition funcimpl.h:2447
do_merge_trees()
Definition funcimpl.h:2449
R beta
Definition funcimpl.h:2448
void serialize(const Archive &ar)
Definition funcimpl.h:2473
mirror dimensions of this, write result on f
Definition funcimpl.h:2510
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2519
implT * f
Definition funcimpl.h:2514
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2511
do_mirror()
Definition funcimpl.h:2516
do_mirror(const std::vector< long > mirror, implT &f)
Definition funcimpl.h:2517
void serialize(const Archive &ar)
Definition funcimpl.h:2553
std::vector< long > mirror
Definition funcimpl.h:2513
Definition funcimpl.h:5562
double operator()(typename dcT::const_iterator &it) const
Definition funcimpl.h:5563
void serialize(const Archive &ar)
Definition funcimpl.h:5578
double operator()(double a, double b) const
Definition funcimpl.h:5574
laziness
Definition funcimpl.h:4724
void serialize(Archive &ar)
Definition funcimpl.h:4733
Key< OPDIM > d
Definition funcimpl.h:4725
Key< OPDIM > key
Definition funcimpl.h:4725
keyT dest
Definition funcimpl.h:4726
double fac
Definition funcimpl.h:4727
do_op_args(const Key< OPDIM > &key, const Key< OPDIM > &d, const keyT &dest, double tol, double fac, double cnorm)
Definition funcimpl.h:4730
double cnorm
Definition funcimpl.h:4727
double tol
Definition funcimpl.h:4727
reduce the rank of the nodes, optional fence
Definition funcimpl.h:2306
do_reduce_rank(const TensorArgs &targs)
Definition funcimpl.h:2314
TensorArgs args
Definition funcimpl.h:2310
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2320
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2307
do_reduce_rank(const double &thresh)
Definition funcimpl.h:2315
void serialize(const Archive &ar)
Definition funcimpl.h:2326
Changes non-standard compressed form to standard compressed form.
Definition funcimpl.h:4688
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:4699
do_standard(implT *impl)
Definition funcimpl.h:4696
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:4689
void serialize(const Archive &ar)
Definition funcimpl.h:4716
implT * impl
Definition funcimpl.h:4692
given an NS tree resulting from a convolution, truncate leafs if appropriate
Definition funcimpl.h:2227
void serialize(const Archive &ar)
Definition funcimpl.h:2247
const implT * f
Definition funcimpl.h:2229
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2233
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2228
do_truncate_NS_leafs(const implT *f)
Definition funcimpl.h:2231
Definition funcimpl.h:2705
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2706
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2710
implT * impl
Definition funcimpl.h:2707
void serialize(const Archive &ar)
Definition funcimpl.h:2728
opT op
Definition funcimpl.h:2708
do_unary_op_value_inplace(implT *impl, const opT &op)
Definition funcimpl.h:2709
Hartree product of two LDIM functions to yield a NDIM = 2*LDIM function.
Definition funcimpl.h:3653
this_type forward_ctor(implT *result1, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
Definition funcimpl.h:3709
bool randomize() const
Definition funcimpl.h:3654
void serialize(const Archive &ar)
Definition funcimpl.h:3713
hartree_op(implT *result, const ctL &p11, const ctL &p22, const leaf_opT &leaf_op)
Definition funcimpl.h:3665
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:3657
ctL p2
tracking coeffs of the two lo-dim functions
Definition funcimpl.h:3660
leaf_opT leaf_op
determine if a given node will be a leaf node
Definition funcimpl.h:3661
hartree_op()
Definition funcimpl.h:3664
implT * result
where to construct the pair function
Definition funcimpl.h:3659
hartree_op< LDIM, leaf_opT > this_type
Definition funcimpl.h:3656
std::pair< bool, coeffT > operator()(const Key< NDIM > &key) const
Definition funcimpl.h:3670
ctL p1
Definition funcimpl.h:3660
this_type make_child(const keyT &child) const
Definition funcimpl.h:3693
Future< this_type > activate() const
Definition funcimpl.h:3702
perform this multiplication: h(1,2) = f(1,2) * g(1)
Definition funcimpl.h:3461
multiply_op()
Definition funcimpl.h:3473
ctL g
Definition funcimpl.h:3470
Future< this_type > activate() const
Definition funcimpl.h:3552
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:3465
implT * h
the result function h(1,2) = f(1,2) * g(1)
Definition funcimpl.h:3468
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:3464
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:3500
this_type forward_ctor(implT *h1, const ctT &f1, const ctL &g1, const int particle)
Definition funcimpl.h:3559
static bool randomize()
Definition funcimpl.h:3463
int particle
if g is g(1) or g(2)
Definition funcimpl.h:3471
ctT f
Definition funcimpl.h:3469
multiply_op< LDIM > this_type
Definition funcimpl.h:3466
multiply_op(implT *h1, const ctT &f1, const ctL &g1, const int particle1)
Definition funcimpl.h:3475
bool screen(const coeffT &fcoeff, const coeffT &gcoeff, const keyT &key) const
return true if this will be a leaf node
Definition funcimpl.h:3481
this_type make_child(const keyT &child) const
Definition funcimpl.h:3542
void serialize(const Archive &ar)
Definition funcimpl.h:3563
Definition funcimpl.h:3939
coeffT val_lhs
Definition funcimpl.h:3940
double lo
Definition funcimpl.h:3943
double lo1
Definition funcimpl.h:3943
long oversampling
Definition funcimpl.h:3941
pointwise_multiplier()=default
double error
Definition funcimpl.h:3942
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:3958
coeffT coeff_lhs
Definition funcimpl.h:3940
void serialize(const Archive &ar)
Definition funcimpl.h:4046
double lo2
Definition funcimpl.h:3943
double hi1
Definition funcimpl.h:3943
pointwise_multiplier(const Key< NDIM > key, const coeffT &clhs)
Definition funcimpl.h:3946
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:4003
double hi2
Definition funcimpl.h:3943
double hi
Definition funcimpl.h:3943
project the low-dim function g on the hi-dim function f: result(x) = <f(x,y) | g(y)>
Definition funcimpl.h:6971
project_out_op(const implT *fimpl, implL1 *result, const ctL &iag, const int dim)
Definition funcimpl.h:6986
ctL iag
the low dim function g
Definition funcimpl.h:6981
FunctionImpl< T, NDIM-LDIM > implL1
Definition funcimpl.h:6976
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:7065
std::pair< bool, coeffT > argT
Definition funcimpl.h:6977
const implT * fimpl
the hi dim function f
Definition funcimpl.h:6979
this_type forward_ctor(const implT *fimpl1, implL1 *result1, const ctL &iag1, const int dim1)
taskq-compatible ctor
Definition funcimpl.h:7072
this_type make_child(const keyT &child) const
Definition funcimpl.h:7056
project_out_op< LDIM > this_type
Definition funcimpl.h:6974
implL1 * result
the low dim result function
Definition funcimpl.h:6980
Future< argT > operator()(const Key< NDIM > &key) const
do the actual contraction
Definition funcimpl.h:6993
void serialize(const Archive &ar)
Definition funcimpl.h:7076
project_out_op(const project_out_op &other)
Definition funcimpl.h:6988
int dim
0: project 0..LDIM-1, 1: project LDIM..NDIM-1
Definition funcimpl.h:6982
bool randomize() const
Definition funcimpl.h:6972
CoeffTracker< T, LDIM > ctL
Definition funcimpl.h:6975
recursive part of recursive_apply
Definition funcimpl.h:5389
ctT iaf
Definition funcimpl.h:5397
recursive_apply_op2< opT > this_type
Definition funcimpl.h:5392
Future< this_type > activate() const
retrieve the coefficients (parent coeffs might be remote)
Definition funcimpl.h:5452
const opT * apply_op
need this for randomization
Definition funcimpl.h:5398
bool randomize() const
Definition funcimpl.h:5390
recursive_apply_op2(const recursive_apply_op2 &other)
Definition funcimpl.h:5405
void serialize(const Archive &ar)
Definition funcimpl.h:5468
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:5438
this_type make_child(const keyT &child) const
Definition funcimpl.h:5447
recursive_apply_op2()=default
recursive_apply_op2(implT *result, const ctT &iaf, const opT *apply_op)
Definition funcimpl.h:5402
std::pair< bool, coeffT > argT
Definition funcimpl.h:5394
implT * result
Definition funcimpl.h:5396
CoeffTracker< T, NDIM > ctT
Definition funcimpl.h:5393
argT operator()(const Key< NDIM > &key) const
send off the application of the operator
Definition funcimpl.h:5414
this_type forward_ctor(implT *result1, const ctT &iaf1, const opT *apply_op1)
taskq-compatible ctor
Definition funcimpl.h:5464
recursive part of recursive_apply
Definition funcimpl.h:5258
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:5283
this_type forward_ctor(implT *r, const CoeffTracker< T, LDIM > &f1, const CoeffTracker< T, LDIM > &g1, const opT *apply_op1)
Definition funcimpl.h:5348
opT * apply_op
Definition funcimpl.h:5266
recursive_apply_op(const recursive_apply_op &other)
Definition funcimpl.h:5276
recursive_apply_op< opT, LDIM > this_type
Definition funcimpl.h:5261
Future< this_type > activate() const
Definition funcimpl.h:5341
bool randomize() const
Definition funcimpl.h:5259
implT * result
Definition funcimpl.h:5263
CoeffTracker< T, LDIM > iaf
Definition funcimpl.h:5264
void serialize(const Archive &ar)
Definition funcimpl.h:5353
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:5323
recursive_apply_op(implT *result, const CoeffTracker< T, LDIM > &iaf, const CoeffTracker< T, LDIM > &iag, const opT *apply_op)
Definition funcimpl.h:5270
this_type make_child(const keyT &child) const
Definition funcimpl.h:5332
CoeffTracker< T, LDIM > iag
Definition funcimpl.h:5265
remove all coefficients of internal nodes
Definition funcimpl.h:2252
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2253
remove_internal_coeffs()=default
constructor need impl for cdata
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2258
void serialize(const Archive &ar)
Definition funcimpl.h:2264
remove all coefficients of leaf nodes
Definition funcimpl.h:2269
bool operator()(typename rangeT::iterator &it) const
Definition funcimpl.h:2275
remove_leaf_coeffs()=default
constructor need impl for cdata
void serialize(const Archive &ar)
Definition funcimpl.h:2280
Range< typename dcT::iterator > rangeT
Definition funcimpl.h:2270
Definition funcimpl.h:4539
void serialize(Archive &ar)
Definition funcimpl.h:4543
bool operator()(const implT *f, const keyT &key, const nodeT &t) const
Definition funcimpl.h:4540
shallow-copy, pared-down version of FunctionNode, for special purpose only
Definition funcimpl.h:749
coeffT & coeff()
Definition funcimpl.h:763
GenTensor< T > coeffT
Definition funcimpl.h:750
bool is_leaf() const
Definition funcimpl.h:765
void serialize(Archive &ar)
Definition funcimpl.h:767
ShallowNode(const ShallowNode< T, NDIM > &node)
Definition funcimpl.h:758
ShallowNode(const FunctionNode< T, NDIM > &node)
Definition funcimpl.h:755
bool has_children() const
Definition funcimpl.h:764
ShallowNode()
Definition funcimpl.h:754
bool _has_children
Definition funcimpl.h:752
double dnorm
Definition funcimpl.h:753
const coeffT & coeff() const
Definition funcimpl.h:762
coeffT _coeffs
Definition funcimpl.h:751
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:716
FunctionImpl< T, NDIM > * impl
Definition funcimpl.h:720
FunctionNode< T, NDIM > nodeT
Definition funcimpl.h:718
accumulate_op(const accumulate_op &other)=default
void operator()(const Key< NDIM > &key, const coeffT &coeff, const bool &is_leaf) const
Definition funcimpl.h:724
void serialize(Archive &ar)
Definition funcimpl.h:728
GenTensor< T > coeffT
Definition funcimpl.h:717
accumulate_op(FunctionImpl< T, NDIM > *f)
Definition funcimpl.h:722
static void load(const Archive &ar, FunctionImpl< T, NDIM > *&ptr)
Definition funcimpl.h:7298
static void load(const Archive &ar, const FunctionImpl< T, NDIM > *&ptr)
Definition funcimpl.h:7267
static void load(const Archive &ar, std::shared_ptr< FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7349
static void load(const Archive &ar, std::shared_ptr< const FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7333
Default load of an object via serialize(ar, t).
Definition archive.h:667
static void load(const A &ar, const U &t)
Load an object.
Definition archive.h:679
static void store(const Archive &ar, FunctionImpl< T, NDIM > *const &ptr)
Definition funcimpl.h:7323
static void store(const Archive &ar, const FunctionImpl< T, NDIM > *const &ptr)
Definition funcimpl.h:7289
static void store(const Archive &ar, const std::shared_ptr< FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7358
static void store(const Archive &ar, const std::shared_ptr< const FunctionImpl< T, NDIM > > &ptr)
Definition funcimpl.h:7342
Default store of an object via serialize(ar, t).
Definition archive.h:612
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:622
Definition funcimpl.h:610
void serialize(Archive &ar)
Definition funcimpl.h:674
const opT * op
Definition funcimpl.h:617
hartree_convolute_leaf_op(const implT *f, const implL *g, const opT *op)
Definition funcimpl.h:621
bool operator()(const Key< NDIM > &key) const
no pre-determination
Definition funcimpl.h:625
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:638
const implL * g
Definition funcimpl.h:616
const FunctionImpl< T, NDIM > * f
Definition funcimpl.h:615
FunctionImpl< T, LDIM > implL
Definition funcimpl.h:613
bool do_error_leaf_op() const
Definition funcimpl.h:618
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:612
bool operator()(const Key< NDIM > &key, const GenTensor< T > &coeff) const
no post-determination
Definition funcimpl.h:628
returns true if the result of a hartree_product is a leaf node (compute norm & error)
Definition funcimpl.h:500
hartree_leaf_op()=default
bool do_error_leaf_op() const
Definition funcimpl.h:505
const FunctionImpl< T, NDIM > * f
Definition funcimpl.h:503
hartree_leaf_op(const implT *f, const long &k)
Definition funcimpl.h:508
long k
Definition funcimpl.h:504
void serialize(Archive &ar)
Definition funcimpl.h:556
bool operator()(const Key< NDIM > &key, const GenTensor< T > &coeff) const
no post-determination
Definition funcimpl.h:514
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:524
bool operator()(const Key< NDIM > &key) const
no pre-determination
Definition funcimpl.h:511
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:502
insert/replaces the coefficients into the function
Definition funcimpl.h:692
insert_op()
Definition funcimpl.h:699
implT * impl
Definition funcimpl.h:698
void operator()(const keyT &key, const coeffT &coeff, const bool &is_leaf) const
Definition funcimpl.h:702
FunctionNode< T, NDIM > nodeT
Definition funcimpl.h:696
Key< NDIM > keyT
Definition funcimpl.h:694
insert_op(const insert_op &other)
Definition funcimpl.h:701
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:693
GenTensor< T > coeffT
Definition funcimpl.h:695
insert_op(implT *f)
Definition funcimpl.h:700
void serialize(Archive &ar)
Definition funcimpl.h:706
Definition funcimpl.h:680
bool operator()(const Key< NDIM > &key, const GenTensor< T > &fcoeff, const GenTensor< T > &gcoeff) const
Definition funcimpl.h:682
void serialize(Archive &ar)
Definition funcimpl.h:686
void operator()(const Key< NDIM > &key, const GenTensor< T > &coeff, const bool &is_leaf) const
Definition funcimpl.h:681
Definition funcimpl.h:564
bool operator()(const Key< NDIM > &key, const double &cnorm) const
post-determination: return true if operator and coefficient norms are small
Definition funcimpl.h:585
void serialize(Archive &ar)
Definition funcimpl.h:600
const implT * f
the source or result function, needed for truncate_tol
Definition funcimpl.h:568
op_leaf_op(const opT *op, const implT *f)
Definition funcimpl.h:572
FunctionImpl< T, NDIM > implT
Definition funcimpl.h:565
const opT * op
the convolution operator
Definition funcimpl.h:567
bool do_error_leaf_op() const
Definition funcimpl.h:569
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:575
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:578
Definition lowrankfunction.h:336
Definition funcimpl.h:736
void serialize(Archive &ar)
Definition funcimpl.h:743
bool operator()(const Key< NDIM > &key, const T &t, const R &r) const
Definition funcimpl.h:742
bool operator()(const Key< NDIM > &key, const T &t) const
Definition funcimpl.h:739
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:85
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
constexpr std::size_t NDIM
Definition testgconv.cc:54
double h(const coord_1d &r)
Definition testgconv.cc:175
double g1(const coord_t &r)
Definition testgconv.cc:122
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