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