cache.h

Go to the documentation of this file.

/*
 * cache.h - cache classes header
 *
 * this file is part of PJFry library
 * Copyright 2011 Valery Yundin
 */
 
#ifndef QUL_CACHE_H
#define QUL_CACHE_H
 
#include "common.h"
#include "kinem.h"
#include "minor.h"
#ifdef USE_GOLEM_MODE
#  include "golem.h"
#endif
 
template <typename TK, typename TV> class MEntry {
public:
  MEntry() : key(), val() {}
  MEntry( const TK& k, TV& v ) : key( k ), val( v ) {}
 
  MEntry& operator=( const MEntry& entry ) {
    key = entry.key;
    val = entry.val;
    return *this;
  }
 
  TK         key;
  mutable TV val; // TODO: remove auto_ptr in the future
 
  MEntry( const MEntry& entry );
};
 
class Cache {
protected:
  static const int size6 = 2;
 
  static const int size5 = size6 * 6;
  static const int size4 = size6 * 15;
  static const int size3 = size6 * 20;
  static const int size2 = size6 * 15;
  static const int size1 = size6 * 6;
};
 
class ICache : public Cache {
#ifdef USE_GOLEM_MODE
  friend class Golem;
#endif
public:
  typedef struct {
    ncomplex val[3];
  } Ival;
 
  enum Ecoefs {
    ee0 = 1,
    ee1,
    ee2,
    ee3,
    ee4,
    ee00,
    ee11,
    ee12,
    ee13,
    ee14,
    ee22,
    ee23,
    ee24,
    ee33,
    ee34,
    ee44,
    ee001,
    ee002,
    ee003,
    ee004,
    ee111,
    ee112,
    ee113,
    ee114,
    ee122,
    ee123,
    ee124,
    ee133,
    ee134,
    ee144,
    ee222,
    ee223,
    ee224,
    ee233,
    ee234,
    ee244,
    ee333,
    ee334,
    ee344,
    ee444,
    ee0000,
    ee0011,
    ee0012,
    ee0013,
    ee0014,
    ee0022,
    ee0023,
    ee0024,
    ee0033,
    ee0034,
    ee0044,
    ee1111,
    ee1112,
    ee1113,
    ee1114,
    ee1122,
    ee1123,
    ee1124,
    ee1133,
    ee1134,
    ee1144,
    ee1222,
    ee1223,
    ee1224,
    ee1233,
    ee1234,
    ee1244,
    ee1333,
    ee1334,
    ee1344,
    ee1444,
    ee2222,
    ee2223,
    ee2224,
    ee2233,
    ee2234,
    ee2244,
    ee2333,
    ee2334,
    ee2344,
    ee2444,
    ee3333,
    ee3334,
    ee3344,
    ee3444,
    ee4444,
    ee00001,
    ee00002,
    ee00003,
    ee00004,
    ee00111,
    ee00112,
    ee00113,
    ee00114,
    ee00122,
    ee00123,
    ee00124,
    ee00133,
    ee00134,
    ee00144,
    ee00222,
    ee00223,
    ee00224,
    ee00233,
    ee00234,
    ee00244,
    ee00333,
    ee00334,
    ee00344,
    ee00444,
    ee11111,
    ee11112,
    ee11113,
    ee11114,
    ee11122,
    ee11123,
    ee11124,
    ee11133,
    ee11134,
    ee11144,
    ee11222,
    ee11223,
    ee11224,
    ee11233,
    ee11234,
    ee11244,
    ee11333,
    ee11334,
    ee11344,
    ee11444,
    ee12222,
    ee12223,
    ee12224,
    ee12233,
    ee12234,
    ee12244,
    ee12333,
    ee12334,
    ee12344,
    ee12444,
    ee13333,
    ee13334,
    ee13344,
    ee13444,
    ee14444,
    ee22222,
    ee22223,
    ee22224,
    ee22233,
    ee22234,
    ee22244,
    ee22333,
    ee22334,
    ee22344,
    ee22444,
    ee23333,
    ee23334,
    ee23344,
    ee23444,
    ee24444,
    ee33333,
    ee33334,
    ee33344,
    ee33444,
    ee34444,
    ee44444,
    eeLAST
  };
 
  enum Dcoefs {
    dd0 = 1,
    dd1,
    dd2,
    dd3,
    dd00,
    dd11,
    dd12,
    dd13,
    dd22,
    dd23,
    dd33,
    dd001,
    dd002,
    dd003,
    dd111,
    dd112,
    dd113,
    dd122,
    dd123,
    dd133,
    dd222,
    dd223,
    dd233,
    dd333,
    dd0000,
    dd0011,
    dd0012,
    dd0013,
    dd0022,
    dd0023,
    dd0033,
    dd1111,
    dd1112,
    dd1113,
    dd1122,
    dd1123,
    dd1133,
    dd1222,
    dd1223,
    dd1233,
    dd1333,
    dd2222,
    dd2223,
    dd2233,
    dd2333,
    dd3333,
    ddLAST
  };
 
  enum Ccoefs {
    cc0 = 1,
    cc1,
    cc2,
    cc00,
    cc11,
    cc12,
    cc22,
    cc001,
    cc002,
    cc111,
    cc112,
    cc122,
    cc222,
    ccLAST
  };
 
  enum Bcoefs { bb0 = 1, bb1, bb00, bb11, bb001, bb111, bbLAST };
 
  // Scalars
  static ncomplex getI4( int ep, const Kinem4& k );
  static ncomplex getI3( int ep, const Kinem3& k );
  static ncomplex getI2( int ep, const Kinem2& k );
  static ncomplex getI1( int ep, const Kinem1& k );
 
  // Tensor PENTAGON
  static ncomplex getE( int ep, const Kinem5& kin );
  static ncomplex getE( int ep, int i, const Kinem5& kin );
  static ncomplex getE( int ep, int i, int j, const Kinem5& kin );
  static ncomplex getE( int ep, int i, int j, int k, const Kinem5& kin );
  static ncomplex getE( int ep, int i, int j, int k, int l, const Kinem5& kin );
  static ncomplex getE( int ep, int i, int j, int k, int l, int m, const Kinem5& kin );
 
  // Tensor BOX
  static ncomplex getD( int ep, const Kinem4& kin ) { return getI4( ep, kin ); }
  static ncomplex getD( int ep, int i, const Kinem4& kin );
  static ncomplex getD( int ep, int i, int j, const Kinem4& kin );
  static ncomplex getD( int ep, int i, int j, int k, const Kinem4& kin );
  static ncomplex getD( int ep, int i, int j, int k, int l, const Kinem4& kin );
 
  // Tensor TRIANGLE
  static ncomplex getC( int ep, const Kinem3& kin ) { return getI3( ep, kin ); }
  static ncomplex getC( int ep, int i, const Kinem3& kin );
  static ncomplex getC( int ep, int i, int j, const Kinem3& kin );
  static ncomplex getC( int ep, int i, int j, int k, const Kinem3& kin );
 
  // Tensor BUBBLE
  static ncomplex getB( int ep, const Kinem2& kin ) { return getI2( ep, kin ); }
  static ncomplex getB( int ep, int i, const Kinem2& kin );
  static ncomplex getB( int ep, int i, int j, const Kinem2& kin );
 
  // Tadpole
  static ncomplex getA( int ep, const Kinem1& kin ) { return getI1( ep, kin ); }
 
  static void Clear();
  static void ClearCC();
  static void ClearIC();
 
  static double getMu2();
  static double setMu2( const double newmu2 );
 
private:
  static double mu2;
  typedef union {
    int64_t i64;
    double  d64;
  } ID64;
  typedef union {
    double  d64;
    int64_t i64;
  } DI64;
  static const ID64 sNAN;
  friend bool       operator==( const double& x, const ICache::ID64& y );
 
  // ------------------------------
  // Tensor integral coefficients
  // ------------------------------
  // TODO: rethink and optimize layout later
  typedef CArray<ncomplex, eeLAST>   Save5;
  typedef MEntry<Kinem5, Save5::Ptr> Entry5;
  typedef DArray<Entry5, size5>      Array5;
  static Array5                      ic5[3];
  static Save5*                      getS5( int ep, const Kinem5& kin, int coefn );
 
  typedef CArray<ncomplex, ddLAST>   Save4;
  typedef MEntry<Kinem4, Save4::Ptr> Entry4;
  typedef DArray<Entry4, size4>      Array4;
  static Array4                      ic4[3];
  static Save4*                      getS4( int ep, const Kinem4& kin, int coefn );
 
  typedef CArray<ncomplex, ccLAST>   Save3;
  typedef MEntry<Kinem3, Save3::Ptr> Entry3;
  typedef DArray<Entry3, size3>      Array3;
  static Array3                      ic3[3];
  static Save3*                      getS3( int ep, const Kinem3& kin, int coefn );
 
  typedef CArray<ncomplex, bbLAST>   Save2;
  typedef MEntry<Kinem2, Save2::Ptr> Entry2;
  typedef DArray<Entry2, size2>      Array2;
  static Array2                      ic2[3];
  static Save2*                      getS2( int ep, const Kinem2& kin, int coefn );
 
  // ------------------------------
  // Scalar integrals
  // ------------------------------
  typedef MEntry<Kinem4, Ival>   EntryS4;
  typedef DArray<EntryS4, size4> ArrayS4;
  static ArrayS4                 ics4;
 
  typedef MEntry<Kinem3, Ival>   EntryS3;
  typedef DArray<EntryS3, size3> ArrayS3;
  static ArrayS3                 ics3;
 
  typedef MEntry<Kinem2, Ival>   EntryS2;
  typedef DArray<EntryS2, size2> ArrayS2;
  static ArrayS2                 ics2;
 
  typedef MEntry<Kinem1, Ival>   EntryS1;
  typedef DArray<EntryS1, size1> ArrayS1;
  static ArrayS1                 ics1;
};
 
inline bool operator==( const double& x, const ICache::ID64& y ) {
  const ICache::DI64 ix = { x };
  return ix.i64 == y.i64;
}
 
class MCache : public Cache {
#ifdef USE_GOLEM_MODE
  friend class Golem;
#endif
public:
  // TODO: may be return by reference here?
  static Minor5::Ptr getMinor5( const Kinem5& k );
  static Minor4::Ptr getMinor4( const Kinem4& k );
  static Minor3::Ptr getMinor3( const Kinem3& k );
  static Minor2::Ptr getMinor2( const Kinem2& k );
 
  static void insertMinor5( const Kinem5& k, Minor5::Ptr& m );
  static void insertMinor4( const Kinem4& k, Minor4::Ptr& m );
  static void insertMinor3( const Kinem3& k, Minor3::Ptr& m );
  static void insertMinor2( const Kinem2& k, Minor2::Ptr& m );
 
#ifdef USE_SMART_INSERT
#  define INSERTMINOR3 smartinsertMinor3
#  define INSERTMINOR2 smartinsertMinor2
  static void smartinsertMinor3( const Kinem3& k, Minor3::Ptr& m );
  static void smartinsertMinor2( const Kinem2& k, Minor2::Ptr& m );
#else
#  define INSERTMINOR3 insertMinor3
#  define INSERTMINOR2 insertMinor2
#endif
 
  static void Clear();
 
private:
  typedef MEntry<Kinem5, Minor5::Ptr> Entry5;
  typedef DArray<Entry5, size5>       Array5;
  static Array5                       cm5;
 
  typedef MEntry<Kinem4, Minor4::Ptr> Entry4;
  typedef DArray<Entry4, size4>       Array4;
  static Array4                       cm4;
 
  typedef MEntry<Kinem3, Minor3::Ptr> Entry3;
  typedef DArray<Entry3, size3>       Array3;
  static Array3                       cm3;
 
  typedef MEntry<Kinem2, Minor2::Ptr> Entry2;
  typedef DArray<Entry2, size2>       Array2;
  static Array2                       cm2;
};
 
/* =============================================
 *
 *            inline functions
 *
 * =============================================
 */
 
#define insertMinorN( n )                                                                     \
  inline void MCache::insertMinor##n( const Kinem##n& k, Minor##n::Ptr& m ) {                 \
    cm##n.insert( Entry##n( k, m ) );                                                         \
  }
 
insertMinorN( 5 ) insertMinorN( 4 ) insertMinorN( 3 ) insertMinorN( 2 )
 
#undef insertMinorN
 
#endif /* _QUL_CACHE_H */