Belle II Software  release-06-02-00
cache.h
1 /*
2  * cache.h - cache classes header
3  *
4  * this file is part of PJFry library
5  * Copyright 2011 Valery Yundin
6  */
7 
8 #ifndef QUL_CACHE_H
9 #define QUL_CACHE_H
10 
11 #include "common.h"
12 #include "kinem.h"
13 #include "minor.h"
14 #ifdef USE_GOLEM_MODE
15 #include "golem.h"
16 #endif
17 
18 template <typename TK, typename TV>
19 class MEntry {
20 public:
21  MEntry() : key(), val() {}
22  MEntry(const TK& k, TV& v) : key(k), val(v) {}
23 
24  MEntry& operator= (const MEntry& entry)
25  {
26  key = entry.key;
27  val = entry.val;
28  return *this;
29  }
30 
31  TK key;
32  mutable TV val; // TODO: remove auto_ptr in the future
33 
34  MEntry(const MEntry& entry);
35 };
36 
37 class Cache {
38 protected:
39  static const int size6 = 2;
40 
41  static const int size5 = size6 * 6;
42  static const int size4 = size6 * 15;
43  static const int size3 = size6 * 20;
44  static const int size2 = size6 * 15;
45  static const int size1 = size6 * 6;
46 
47 };
48 
49 class ICache : public Cache {
50 #ifdef USE_GOLEM_MODE
51  friend class Golem;
52 #endif
53 public:
54  typedef struct { ncomplex val[3]; } Ival;
55 
56  enum Ecoefs {ee0 = 1, ee1, ee2, ee3, ee4,
57  ee00, ee11, ee12, ee13, ee14, ee22, ee23, ee24, ee33, ee34, ee44,
58  ee001, ee002, ee003, ee004,
59  ee111, ee112, ee113, ee114, ee122, ee123, ee124, ee133, ee134, ee144,
60  ee222, ee223, ee224, ee233, ee234, ee244, ee333, ee334, ee344, ee444,
61  ee0000, ee0011, ee0012, ee0013, ee0014, ee0022, ee0023, ee0024, ee0033, ee0034, ee0044,
62  ee1111, ee1112, ee1113, ee1114, ee1122, ee1123, ee1124, ee1133, ee1134, ee1144,
63  ee1222, ee1223, ee1224, ee1233, ee1234, ee1244, ee1333, ee1334, ee1344, ee1444,
64  ee2222, ee2223, ee2224, ee2233, ee2234, ee2244, ee2333, ee2334, ee2344, ee2444,
65  ee3333, ee3334, ee3344, ee3444, ee4444,
66  ee00001, ee00002, ee00003, ee00004, ee00111, ee00112, ee00113, ee00114,
67  ee00122, ee00123, ee00124, ee00133, ee00134, ee00144, ee00222, ee00223, ee00224,
68  ee00233, ee00234, ee00244, ee00333, ee00334, ee00344, ee00444,
69  ee11111, ee11112, ee11113, ee11114, ee11122, ee11123, ee11124, ee11133, ee11134, ee11144,
70  ee11222, ee11223, ee11224, ee11233, ee11234, ee11244, ee11333, ee11334, ee11344, ee11444,
71  ee12222, ee12223, ee12224, ee12233, ee12234, ee12244, ee12333, ee12334, ee12344, ee12444,
72  ee13333, ee13334, ee13344, ee13444, ee14444,
73  ee22222, ee22223, ee22224, ee22233, ee22234, ee22244, ee22333, ee22334, ee22344, ee22444,
74  ee23333, ee23334, ee23344, ee23444, ee24444, ee33333, ee33334, ee33344, ee33444, ee34444,
75  ee44444, eeLAST
76  };
77 
78  enum Dcoefs {dd0 = 1, dd1, dd2, dd3,
79  dd00, dd11, dd12, dd13, dd22, dd23, dd33,
80  dd001, dd002, dd003,
81  dd111, dd112, dd113, dd122, dd123, dd133, dd222, dd223, dd233, dd333,
82  dd0000, dd0011, dd0012, dd0013, dd0022, dd0023, dd0033,
83  dd1111, dd1112, dd1113, dd1122, dd1123, dd1133,
84  dd1222, dd1223, dd1233, dd1333,
85  dd2222, dd2223, dd2233, dd2333,
86  dd3333, ddLAST
87  };
88 
89  enum Ccoefs {cc0 = 1, cc1, cc2,
90  cc00, cc11, cc12, cc22,
91  cc001, cc002,
92  cc111, cc112, cc122, cc222, ccLAST
93  };
94 
95  enum Bcoefs {bb0 = 1, bb1,
96  bb00, bb11,
97  bb001,
98  bb111, bbLAST
99  };
100 
101  // Scalars
102  static ncomplex getI4(int ep, const Kinem4& k);
103  static ncomplex getI3(int ep, const Kinem3& k);
104  static ncomplex getI2(int ep, const Kinem2& k);
105  static ncomplex getI1(int ep, const Kinem1& k);
106 
107  // Tensor PENTAGON
108  static ncomplex getE(int ep, const Kinem5& kin);
109  static ncomplex getE(int ep, int i, const Kinem5& kin);
110  static ncomplex getE(int ep, int i, int j, const Kinem5& kin);
111  static ncomplex getE(int ep, int i, int j, int k, const Kinem5& kin);
112  static ncomplex getE(int ep, int i, int j, int k, int l, const Kinem5& kin);
113  static ncomplex getE(int ep, int i, int j, int k, int l, int m, const Kinem5& kin);
114 
115  // Tensor BOX
116  static ncomplex getD(int ep, const Kinem4& kin) { return getI4(ep, kin); }
117  static ncomplex getD(int ep, int i, const Kinem4& kin);
118  static ncomplex getD(int ep, int i, int j, const Kinem4& kin);
119  static ncomplex getD(int ep, int i, int j, int k, const Kinem4& kin);
120  static ncomplex getD(int ep, int i, int j, int k, int l, const Kinem4& kin);
121 
122  // Tensor TRIANGLE
123  static ncomplex getC(int ep, const Kinem3& kin) { return getI3(ep, kin); }
124  static ncomplex getC(int ep, int i, const Kinem3& kin);
125  static ncomplex getC(int ep, int i, int j, const Kinem3& kin);
126  static ncomplex getC(int ep, int i, int j, int k, const Kinem3& kin);
127 
128  // Tensor BUBBLE
129  static ncomplex getB(int ep, const Kinem2& kin) { return getI2(ep, kin); }
130  static ncomplex getB(int ep, int i, const Kinem2& kin);
131  static ncomplex getB(int ep, int i, int j, const Kinem2& kin);
132 
133  // Tadpole
134  static ncomplex getA(int ep, const Kinem1& kin) { return getI1(ep, kin); }
135 
136  static void Clear();
137  static void ClearCC();
138  static void ClearIC();
139 
140  static double getMu2();
141  static double setMu2(const double newmu2);
142 
143 private:
144  static double mu2;
145  typedef union { int64_t i64; double d64; } ID64;
146  typedef union { double d64; int64_t i64; } DI64;
147  static const ID64 sNAN;
148  friend bool operator==(const double& x, const ICache::ID64& y);
149 
150  // ------------------------------
151  // Tensor integral coefficients
152  // ------------------------------
153  // TODO: rethink and optimize layout later
154  typedef CArray< ncomplex, eeLAST > Save5;
155  typedef MEntry< Kinem5, Save5::Ptr > Entry5;
156  typedef DArray< Entry5, size5 > Array5;
157  static Array5 ic5[3];
158  static Save5* getS5(int ep, const Kinem5& kin, int coefn);
159 
160  typedef CArray< ncomplex, ddLAST > Save4;
161  typedef MEntry< Kinem4, Save4::Ptr > Entry4;
162  typedef DArray< Entry4, size4 > Array4;
163  static Array4 ic4[3];
164  static Save4* getS4(int ep, const Kinem4& kin, int coefn);
165 
166  typedef CArray< ncomplex, ccLAST > Save3;
167  typedef MEntry< Kinem3, Save3::Ptr > Entry3;
168  typedef DArray< Entry3, size3 > Array3;
169  static Array3 ic3[3];
170  static Save3* getS3(int ep, const Kinem3& kin, int coefn);
171 
172  typedef CArray< ncomplex, bbLAST > Save2;
173  typedef MEntry< Kinem2, Save2::Ptr > Entry2;
174  typedef DArray< Entry2, size2 > Array2;
175  static Array2 ic2[3];
176  static Save2* getS2(int ep, const Kinem2& kin, int coefn);
177 
178  // ------------------------------
179  // Scalar integrals
180  // ------------------------------
181  typedef MEntry< Kinem4, Ival > EntryS4;
182  typedef DArray< EntryS4, size4 > ArrayS4;
183  static ArrayS4 ics4;
184 
185  typedef MEntry< Kinem3, Ival > EntryS3;
186  typedef DArray< EntryS3, size3 > ArrayS3;
187  static ArrayS3 ics3;
188 
189  typedef MEntry< Kinem2, Ival > EntryS2;
190  typedef DArray< EntryS2, size2 > ArrayS2;
191  static ArrayS2 ics2;
192 
193  typedef MEntry< Kinem1, Ival > EntryS1;
194  typedef DArray< EntryS1, size1 > ArrayS1;
195  static ArrayS1 ics1;
196 };
197 
198 inline
199 bool operator==(const double& x, const ICache::ID64& y)
200 {
201  const ICache::DI64 ix = {x};
202  return ix.i64 == y.i64;
203 }
204 
205 
206 class MCache : public Cache {
207 #ifdef USE_GOLEM_MODE
208  friend class Golem;
209 #endif
210 public:
211  // TODO: may be return by reference here?
212  static Minor5::Ptr getMinor5(const Kinem5& k);
213  static Minor4::Ptr getMinor4(const Kinem4& k);
214  static Minor3::Ptr getMinor3(const Kinem3& k);
215  static Minor2::Ptr getMinor2(const Kinem2& k);
216 
217  static void insertMinor5(const Kinem5& k, Minor5::Ptr& m);
218  static void insertMinor4(const Kinem4& k, Minor4::Ptr& m);
219  static void insertMinor3(const Kinem3& k, Minor3::Ptr& m);
220  static void insertMinor2(const Kinem2& k, Minor2::Ptr& m);
221 
222 #ifdef USE_SMART_INSERT
223 # define INSERTMINOR3 smartinsertMinor3
224 # define INSERTMINOR2 smartinsertMinor2
225  static void smartinsertMinor3(const Kinem3& k, Minor3::Ptr& m);
226  static void smartinsertMinor2(const Kinem2& k, Minor2::Ptr& m);
227 #else
228 # define INSERTMINOR3 insertMinor3
229 # define INSERTMINOR2 insertMinor2
230 #endif
231 
232  static void Clear();
233 
234 private:
235 
236  typedef MEntry< Kinem5, Minor5::Ptr > Entry5;
237  typedef DArray< Entry5, size5 > Array5;
238  static Array5 cm5;
239 
240  typedef MEntry< Kinem4, Minor4::Ptr > Entry4;
241  typedef DArray< Entry4, size4 > Array4;
242  static Array4 cm4;
243 
244  typedef MEntry< Kinem3, Minor3::Ptr > Entry3;
245  typedef DArray< Entry3, size3 > Array3;
246  static Array3 cm3;
247 
248  typedef MEntry< Kinem2, Minor2::Ptr > Entry2;
249  typedef DArray< Entry2, size2 > Array2;
250  static Array2 cm2;
251 
252 };
253 
254 /* =============================================
255  *
256  * inline functions
257  *
258  * =============================================
259  */
260 
261 #define insertMinorN(n) \
262  inline \
263  void MCache::insertMinor##n(const Kinem##n &k, Minor##n::Ptr &m) \
264  { \
265  cm##n.insert(Entry##n(k,m)); \
266  }
267 
268 insertMinorN(5)
269 insertMinorN(4)
270 insertMinorN(3)
271 insertMinorN(2)
272 
273 #undef insertMinorN
274 
275 #endif /* _QUL_CACHE_H */
Cache
Definition: cache.h:37
DArray
Definition: pointer.h:80
Golem
Definition: golem.h:13
ICache
Definition: cache.h:49
Kinem1
Definition: kinem.h:92
Kinem2
Definition: kinem.h:104
Kinem3
Definition: kinem.h:121
Kinem4
Definition: kinem.h:144
Kinem5
Definition: kinem.h:176
MCache
Definition: cache.h:206
MEntry
Definition: cache.h:19
SPtr
Definition: pointer.h:23
Belle2::operator==
bool operator==(const DecayNode &node1, const DecayNode &node2)
Compare two Decay Nodes: They are equal if All daughter decay nodes are equal or one of the daughter ...
Definition: DecayNode.cc:48