cache.cpp

Go to the documentation of this file.

/*
 * cache.h - cache classes
 *
 * this file is part of PJFry library
 * Copyright 2011 Valery Yundin
 */
 
#include "cache.h"
#include "integral.h"
 
/* ------------------------------------------------------------
 * ------------------------------------------------------------
 *                      ICache section
 * ------------------------------------------------------------
 * ------------------------------------------------------------
*/
 
double ICache::mu2=1;
 
double ICache::getMu2()
{
  return mu2;
}
 
double ICache::setMu2(const double newmu2)
{
  if (newmu2 > 0 && newmu2 != mu2) {
    MinorBase::Rescale(newmu2/mu2);
    mu2=newmu2;
#ifdef USE_ONELOOP
    double mu=sqrt(mu2);
    F77_FUNC_(avh_olo_mu_set,AVH_OLO_MU_SET)(&mu);
#endif
    ICache::Clear();
    MCache::Clear();
  }
  return mu2;
}
 
void ICache::Clear()
{
  ClearCC();
  ClearIC();
}
 
/* clear coefficient cache */
void ICache::ClearCC()
{
  ic5[0].reset();
  ic5[1].reset();
  ic4[0].reset();
  ic4[1].reset();
  ic3[0].reset();
  ic3[1].reset();
  ic2[0].reset();
  ic2[1].reset();
}
 
/* clear scalar integral cache */
void ICache::ClearIC()
{
  ics4.reset();
  ics3.reset();
  ics2.reset();
  ics1.reset();
}
 
/* clear minor cache */
void MCache::Clear()
{
  cm5.reset();
  cm4.reset();
  cm3.reset();
  cm2.reset();
}
 
// const double ICache::sNan=std::numeric_limits<double>::signaling_NaN();
// const int64_t ICache::sNAN=0x7ffc0000BA13BA13LL;
// const double ICache::sNAN.d64=reinterpret_cast<const double&>(sNAN); // Bad because breaks strict aliasing
// const double ICache::sNAN.d64=((const ICache::ID64&)sNAN).dbl;
 
const ICache::ID64 ICache::sNAN={ 0x7ffc0000BA13BA13LL };
 
ICache::Array5 ICache::ic5[3];
ICache::Array4 ICache::ic4[3];
ICache::Array3 ICache::ic3[3];
ICache::Array2 ICache::ic2[3];
 
ICache::ArrayS4 ICache::ics4;
ICache::ArrayS3 ICache::ics3;
ICache::ArrayS2 ICache::ics2;
ICache::ArrayS1 ICache::ics1;
 
/* ===========================================================
 *
 *           PENTAGON:  5 point coefficients
 *
 * ===========================================================
 */
 
/* --------------------------------------------------------
    Rank-5 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, int i, int j, int k, int l, int m, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  assert( (i==0 && j==0 && ( (k==0 && l==0 && m!=0) || (k!=0 && l!=0 && m!=0) ))
         || (i!=0 && j!=0 && k!=0 && l!=0 && m!=0) );
  int coefn=0;
  if (i==0 && j==0) {
    if (k==0 && l==0)
      coefn=(m-1)+ee00001;
    else
      coefn=Minor5::is(k-1,l-1,m-1)+ee00111;
  }
  else {
    coefn=Minor5::iss(i-1,j-1,k-1,l-1,m-1)+ee11111;
  }
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k, l, m);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k, l, m);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-4 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, int i, int j, int k, int l, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  assert( (i==0 && j==0 && ( (k==0 && l==0) || (k!=0 && l!=0) )) || (i!=0 && j!=0 && k!=0 && l!=0) );
  int coefn=0;
  if (i==0 && j==0) {
    if (k==0 && l==0)
      coefn=ee0000;
    else
      coefn=Minor5::is(k-1,l-1)+ee0011;
  }
  else {
    coefn=Minor5::is(i-1,j-1,k-1,l-1)+ee1111;
  }
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k, l);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k, l);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-3 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, int i, int j, int k, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  assert( (i==0 && j==0 && k!=0) || (i!=0 && j!=0 && k!=0) );
  int coefn=(i==0 && j==0) ? (k-1)+ee001 : Minor5::is(i-1,j-1,k-1)+ee111;
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep, i, j, k);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-2 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, int i, int j, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  assert( (i==0 && j==0) || (i!=0 && j!=0) );
  int coefn=(i==0 && j==0) ? ee00 : Minor5::is(i-1,j-1)+ee11;
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep, i, j);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep, i, j);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-1 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, int i, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  int coefn=(i-1)+ee1;
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep, i);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep, i);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-0 PENTAGON
 * --------------------------------------------------------
 */
ncomplex ICache::getE(int ep, const Kinem5 &kin)
{
#ifdef USE_CACHE_HIGH
  int coefn=ee0;
  Save5 *s5=getS5(ep, kin, coefn);
 
  ncomplex ivalue=(*s5)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor5(kin)->evalE(ep);
    (*s5)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor5(kin)->evalE(ep);
#endif /* USE_CACHE_HIGH */
  return ivalue;
}
 
/* ===========================================================
 *
 *                BOX:    4 point coefficients
 *
 * ===========================================================
 */
 
/* --------------------------------------------------------
    Rank-4 BOX
 * --------------------------------------------------------
 */
ncomplex ICache::getD(int ep, int i, int j, int k, int l, const Kinem4 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0 && ( (k==0 && l==0) || (k!=0 && l!=0) )) || (i!=0 && j!=0 && k!=0 && l!=0) );
  int coefn=0;
  if (i==0 && j==0) {
    if (k==0 && l==0)
      coefn=dd0000;
    else
      coefn=Minor4::is(k-1,l-1)+dd0011;
  }
  else {
    coefn=Minor5::is(i-1,j-1,k-1,l-1)+dd1111;
  }
  Save4 *s4=getS4(ep, kin, coefn);
 
  ncomplex ivalue=(*s4)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor4(kin)->evalD(ep, i, j, k, l);
    (*s4)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor4(kin)->evalD(ep, i, j, k, l);
#endif /* USE_CACHE_LOW */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-3 BOX
 * --------------------------------------------------------
 */
ncomplex ICache::getD(int ep, int i, int j, int k, const Kinem4 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0 && k!=0) || (i!=0 && j!=0 && k!=0) );
  int coefn=(i==0 && j==0) ? (k-1)+dd001 : Minor4::is(i-1,j-1,k-1)+dd111;
  Save4 *s4=getS4(ep, kin, coefn);
 
  ncomplex ivalue=(*s4)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor4(kin)->evalD(ep, i, j, k);
    (*s4)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor4(kin)->evalD(ep, i, j, k);
#endif /* USE_CACHE_LOW */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-2 BOX
 * --------------------------------------------------------
 */
ncomplex ICache::getD(int ep, int i, int j, const Kinem4 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0) || (i!=0 && j!=0) );
  int coefn=(i==0 && j==0) ? dd00 : Minor4::is(i-1,j-1)+dd11;
  Save4 *s4=getS4(ep, kin, coefn);
 
  ncomplex ivalue=(*s4)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor4(kin)->evalD(ep, i, j);
    (*s4)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor4(kin)->evalD(ep, i, j);
#endif /* USE_CACHE_LOW */
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-1 BOX
 * --------------------------------------------------------
 */
ncomplex ICache::getD(int ep, int i, const Kinem4 &kin)
{
#ifdef USE_CACHE_LOW
  int coefn=(i-1)+dd1;
  Save4 *s4=getS4(ep, kin, coefn);
 
  ncomplex ivalue=(*s4)[coefn];
  if (ivalue.real() == sNAN) {
    ivalue=MCache::getMinor4(kin)->evalD(ep, i);
    (*s4)[coefn]=ivalue;
  }
#else
  ncomplex ivalue=MCache::getMinor4(kin)->evalD(ep, i);
#endif /* USE_CACHE_LOW */
  return ivalue;
}
 
/* ===========================================================
 *
 *            TRIANGLE:    3 point coefficients
 *
 * ===========================================================
 */
 
 
/* --------------------------------------------------------
    Rank-3 TRIANGLE
 * --------------------------------------------------------
 */
ncomplex ICache::getC(int ep, int i, int j, int k, const Kinem3 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0 && k!=0) || (i!=0 && j!=0 && k!=0) );
  int coefn=(i==0 && j==0) ? (k-1)+cc001 : Minor3::is(i-1,j-1,k-1)+cc111;
  Save3 *s3=getS3(ep, kin, coefn);
 
  ncomplex ivalue=(*s3)[coefn];
  Minor3::Ptr pm3;
  if (ivalue.real() == sNAN && (pm3=MCache::getMinor3(kin))!=0) {
    ivalue=pm3->evalC(ep, i, j, k);
    (*s3)[coefn]=ivalue;
  }
#else
  Minor3::Ptr pm3=MCache::getMinor3(kin);
  ncomplex ivalue= ( pm3!=0 ? pm3->evalC(ep, i, j, k) : sNAN.d64 );
#endif /* USE_CACHE_LOW */
#ifndef NDEBUG
  if (pm3==0) printf("C%d%d%d(%.18e,%.18e,%.18e,%e,%e,%e)=%f\n",i,j,k,kin.p1(),kin.p2(),kin.p3(),kin.m1(),kin.m2(),kin.m3(),ivalue.real());
#endif
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-2 TRIANGLE
 * --------------------------------------------------------
 */
ncomplex ICache::getC(int ep, int i, int j, const Kinem3 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0) || (i!=0 && j!=0) );
  int coefn=(i==0 && j==0) ? cc00 : Minor3::is(i-1,j-1)+cc11;
  Save3 *s3=getS3(ep, kin, coefn);
 
  ncomplex ivalue=(*s3)[coefn];
  Minor3::Ptr pm3;
  if (ivalue.real() == sNAN && (pm3=MCache::getMinor3(kin))!=0) {
    ivalue=pm3->evalC(ep, i, j);
    (*s3)[coefn]=ivalue;
  }
#else
  Minor3::Ptr pm3=MCache::getMinor3(kin);
  ncomplex ivalue= ( pm3!=0 ? pm3->evalC(ep, i, j) : sNAN.d64 );
#endif /* USE_CACHE_LOW */
#ifndef NDEBUG
  if (pm3==0) printf("C%d%d(%.18e,%.18e,%.18e,%e,%e,%e)=%f\n",i,j,kin.p1(),kin.p2(),kin.p3(),kin.m1(),kin.m2(),kin.m3(),ivalue.real());
#endif
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-1 TRIANGLE
 * --------------------------------------------------------
 */
ncomplex ICache::getC(int ep, int i, const Kinem3 &kin)
{
#ifdef USE_CACHE_LOW
  int coefn=(i-1)+cc1;
  Save3 *s3=getS3(ep, kin, coefn);
 
  ncomplex ivalue=(*s3)[coefn];
  Minor3::Ptr pm3;
  if (ivalue.real() == sNAN && (pm3=MCache::getMinor3(kin))!=0) {
    ivalue=pm3->evalC(ep, i);
    (*s3)[coefn]=ivalue;
  }
#else
  Minor3::Ptr pm3=MCache::getMinor3(kin);
  ncomplex ivalue= ( pm3!=0 ? pm3->evalC(ep, i) : sNAN.d64 );
#endif /* USE_CACHE_LOW */
#ifndef NDEBUG
  if (pm3==0) printf("C%d(%.18e,%.18e,%.18e,%e,%e,%e)=%f\n",i,kin.p1(),kin.p2(),kin.p3(),kin.m1(),kin.m2(),kin.m3(),ivalue.real());
#endif
  return ivalue;
}
 
/* ===========================================================
 *
 *            BUBBLE:    2 point coefficients
 *
 * ===========================================================
 */
 
/* --------------------------------------------------------
    Rank-2 BUBBLE
 * --------------------------------------------------------
 */
ncomplex ICache::getB(int ep, int i, int j, const Kinem2 &kin)
{
#ifdef USE_CACHE_LOW
  assert( (i==0 && j==0) || (i!=0 && j!=0) );
  int coefn=(i==0 && j==0) ? bb00 : Minor2::is(i-1,j-1)+bb11;
  Save2 *s2=getS2(ep, kin, coefn);
 
  ncomplex ivalue=(*s2)[coefn];
  Minor2::Ptr pm2;
  if (ivalue.real() == sNAN && (pm2=MCache::getMinor2(kin))!=0) {
    ivalue=pm2->evalB(ep, i, j);
    (*s2)[coefn]=ivalue;
  }
#else
  Minor2::Ptr pm2=MCache::getMinor2(kin);
  ncomplex ivalue= ( pm2!=0 ? pm2->evalB(ep, i, j) : sNAN.d64 );
#endif /* USE_CACHE_LOW */
#ifndef NDEBUG
  if (pm2==0) printf("B%d%d(%.18e,%.18e,%.18e)=%f\n",i,j,kin.p1(),kin.m1(),kin.m2(),ivalue.real());
#endif
  return ivalue;
}
 
/* --------------------------------------------------------
    Rank-1 BUBBLE
 * --------------------------------------------------------
 */
ncomplex ICache::getB(int ep, int i, const Kinem2 &kin)
{
#ifdef USE_CACHE_LOW
  int coefn=(i-1)+bb1;
  Save2 *s2=getS2(ep, kin, coefn);
 
  ncomplex ivalue=(*s2)[coefn];
  Minor2::Ptr pm2;
  if (ivalue.real() == sNAN && (pm2=MCache::getMinor2(kin))!=0) {
    ivalue=pm2->evalB(ep, i);
    (*s2)[coefn]=ivalue;
  }
#else
  Minor2::Ptr pm2=MCache::getMinor2(kin);
  ncomplex ivalue= ( pm2!=0 ? pm2->evalB(ep, i) : sNAN.d64 );
#endif /* USE_CACHE_LOW */
#ifndef NDEBUG
  if (pm2==0) printf("B%d(%.18e,%.18e,%.18e)=%f\n",i,kin.p1(),kin.m1(),kin.m2(),ivalue.real());
#endif
  return ivalue;
}
 
/* ===========================================================
 *
 *               Get saved value
 *
 * ===========================================================
 */
 
// ICache::Save5* ICache::getS5(int ep, const Kinem5 &kin, int coefn)
// {
//   Save5 *s5=0;
//   for (Array5::iterator it5=ic5[ep].begin(); it5 != ic5[ep].end(); ++it5) {
//     if (it5->key == kin) {
//       s5=it5->val.get();
//       break;
//     }
//   }
//   if (s5 == 0) {
//     Save5::Ptr sptr(new Save5(ncomplex(sNAN.d64, 0)));
//     s5=sptr.get();
//     ic5[ep].insert(Entry5(kin, sptr));
//   }
//   return s5;
// }
 
#define getSave(n) \
ICache::Save##n * ICache::getS##n(int ep, const Kinem##n &kin, int coefn) \
{ \
  Save##n *s##n=0; \
  for (Array##n::iterator it##n=ic##n[ep].begin(); it##n != ic##n[ep].end(); ++it##n) { \
    if (it##n->key == kin) { \
      s##n=it##n->val.get(); \
      break; \
    } \
  } \
  if (s##n == 0) { \
    Save##n::Ptr sptr(new Save##n(ncomplex(sNAN.d64, 0))); \
    s##n=sptr.get(); \
    ic##n[ep].insert(Entry##n(kin, sptr)); \
  } \
  return s##n; \
} \
 
getSave(5)
getSave(4)
getSave(3)
getSave(2)
 
#undef getSave
 
// ncomplex ICache::getI2(int ep, const Kinem2 &k)
// {
//   ncomplex ivalue(sNAN.d64, 0);
//   for (ArrayS2::iterator it2=ics2[ep].begin(); it2 != ics2[ep].end(); ++it2) {
//     if (it2->key == k) {
//       ivalue=it2->val;
//       break;
//     }
//   }
//   if (ivalue.real() == sNAN) {
//     ivalue=qlI2(k.p1(),
//                 k.m1(), k.m2(),
//                 -ep);
//     ics2[ep].insert(EntryS2(k,ivalue));
//   }
//   return ivalue;
// }
 
#define getIN(n) \
ncomplex ICache::getI##n(int ep, const Kinem##n &k) \
{ \
  Ival ivalue; \
  bool found=false; \
  for (ArrayS##n::iterator it##n=ics##n.begin(); it##n != ics##n.end(); ++it##n) { \
    if (it##n->key == k) { \
      ivalue=it##n->val; \
      found=true; \
      break; \
    } \
  } \
  if ( ! found ) { \
    ivalue=qlI##n(k); \
    ics##n.insert(EntryS##n(k,ivalue)); \
  } \
  return ivalue.val[ep]; \
}
 
getIN(1)
getIN(2)
getIN(3)
getIN(4)
 
#undef getIN
 
/* ------------------------------------------------------------
 * ------------------------------------------------------------
 *                       MCache section
 * ------------------------------------------------------------
 * ------------------------------------------------------------
*/
 
MCache::Array5 MCache::cm5;
MCache::Array4 MCache::cm4;
MCache::Array3 MCache::cm3;
MCache::Array2 MCache::cm2;
 
// Minor5::Ptr MCache::getMinor5(const Kinem5 &k)
// {
//   Minor5::Ptr minor;
//   for (Array5::iterator it5=cm5.begin(); it5!=cm5.end(); ++it5) {
//     if (it5->key == k) {
//       minor=it5->val;
//       break;
//     }
//   }
//   if (minor==0) {
//     minor=Minor5::create(k);
//     cm5.insert(Entry5(k,minor));
//   }
//   return minor;
// }
 
#define getMinorN(n) \
Minor##n::Ptr MCache::getMinor##n(const Kinem##n &k) \
{ \
  Minor##n::Ptr minor; \
  for (Array##n::iterator it##n=cm##n.begin(); it##n!=cm##n.end(); ++it##n) { \
    if (it##n->key == k) { \
      minor=it##n->val; \
      break; \
    } \
  } \
  /* if (minor==0) { \
    minor=Minor##n::create(k); \
    cm##n.insert(Entry##n(k,minor)); \
  } \
  assert(minor!=0); */ \
  return minor; \
}
 
getMinorN(3)
getMinorN(2)
 
#undef getMinorN
 
Minor5::Ptr MCache::getMinor5(const Kinem5 &k)
{
  Minor5::Ptr minor;
  for (Array5::iterator it5=cm5.begin(); it5!=cm5.end(); ++it5) {
    if (it5->key == k) {
      minor=it5->val;
      break;
    }
  }
  if (minor==0) {
    minor=Minor5::create(k);
    cm5.insert(Entry5(k,minor));
  }
  assert(minor!=0);
  return minor;
}
 
Minor4::Ptr MCache::getMinor4(const Kinem4 &k)
{
  Minor4::Ptr minor;
  for (Array4::iterator it4=cm4.begin(); it4!=cm4.end(); ++it4) {
    if (it4->key == k) {
      minor=it4->val;
      break;
    }
  }
  if (minor==0) {
    Minor5::create(k);
    minor=cm4.begin()->val;
    cm4.insert(Entry4(k,minor));
  }
  assert(minor!=0);
  return minor;
}
 
 
#ifdef USE_SMART_INSERT
 
void MCache::smartinsertMinor3(const Kinem3 &k, Minor3::Ptr &m)
{
  for (Array3::iterator it3=cm3.begin(); it3!=cm3.end(); ++it3) {
    if (it3->key == k) {
      cm3.remove(it3);
      break;
    }
  }
  insertMinor3(k,m);
}
 
void MCache::smartinsertMinor2(const Kinem2 &k, Minor2::Ptr &m)
{
  for (Array2::iterator it2=cm2.begin(); it2!=cm2.end(); ++it2) {
    if (it2->key == k) {
      cm2.remove(it2);
      break;
    }
  }
  insertMinor2(k,m);
}
 
#endif
 
// -------------------------------------------------------