Belle II Software  release-08-01-10
trgrawdataModule.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 #include <trg/gdl/modules/trggdlUnpacker/trggdlUnpackerModule.h>
10 #include <trg/trg/modules/trgrawdata/trgrawdataModule.h>
11 
12 #include <rawdata/modules/PrintDataTemplate.h>
13 #include <framework/datastore/StoreObjPtr.h>
14 #include <framework/datastore/StoreArray.h>
15 #include <framework/dbobjects/RunInfo.h>
16 #include <framework/datastore/DataStore.h>
17 
18 #include <string.h>
19 #include <unistd.h>
20 
21 #include <TPostScript.h>
22 #include <TCanvas.h>
23 #include <TStyle.h>
24 
25 using namespace std;
26 using namespace Belle2;
27 using namespace GDL;
28 
29 
30 REG_MODULE(TRGRAWDATA);
31 
32 // TRGRAWDATAModule::TRGRAWDATAModule() : Module()
33 TRGRAWDATAModule::TRGRAWDATAModule() : HistoModule()
34 {
35 
36  setDescription("TRG rawdata analyer");
37  setPropertyFlags(c_ParallelProcessingCertified);
38 
39  addParam("histRecord", m_histRecord,
40  "Recording event by event timing distribution histogram or not",
41  false);
42  addParam("mydebug", m_mydebug, "debug flag", 0);
43  addParam("cc_check", m_cc_check, "cc mode", true);
44  addParam("print_cc", m_print_cc, "Print Disordered clocks", true);
45  addParam("print_clkcyc_err", m_print_clkcyc_err, "Print Errs of Disordered clocks", false);
46  addParam("print_dbmap", m_print_dbmap, "Print Database Bit Map", false);
47 
48  addParam("hdr_nwd_2d0", m_hdr_nwd_2d0, "Number of word for 2D0 Header", 3);
49  addParam("hdr_nwd_2d1", m_hdr_nwd_2d1, "Number of word for 2D1 Header", 3);
50  addParam("hdr_nwd_2d2", m_hdr_nwd_2d2, "Number of word for 2D2 Header", 3);
51  addParam("hdr_nwd_2d3", m_hdr_nwd_2d3, "Number of word for 2D3 Header", 3);
52  addParam("hdr_nwd_3d0", m_hdr_nwd_3d0, "Number of word for 3D0 Header", 3);
53  addParam("hdr_nwd_3d1", m_hdr_nwd_3d1, "Number of word for 3D1 Header", 3);
54  addParam("hdr_nwd_3d2", m_hdr_nwd_3d2, "Number of word for 3D2 Header", 3);
55  addParam("hdr_nwd_3d3", m_hdr_nwd_3d3, "Number of word for 3D3 Header", 3);
56  addParam("hdr_nwd_nn0", m_hdr_nwd_nn0, "Number of word for NN0 Header", 3);
57  addParam("hdr_nwd_nn1", m_hdr_nwd_nn1, "Number of word for NN1 Header", 3);
58  addParam("hdr_nwd_nn2", m_hdr_nwd_nn2, "Number of word for NN2 Header", 3);
59  addParam("hdr_nwd_nn3", m_hdr_nwd_nn3, "Number of word for NN3 Header", 3);
60  addParam("hdr_nwd_sl0", m_hdr_nwd_sl0, "Number of word for TSF0 Header", 3);
61  addParam("hdr_nwd_sl1", m_hdr_nwd_sl1, "Number of word for TSF1 Header", 3);
62  addParam("hdr_nwd_sl2", m_hdr_nwd_sl2, "Number of word for TSF2 Header", 3);
63  addParam("hdr_nwd_sl3", m_hdr_nwd_sl3, "Number of word for TSF3 Header", 3);
64  addParam("hdr_nwd_sl4", m_hdr_nwd_sl4, "Number of word for TSF4 Header", 3);
65  addParam("hdr_nwd_sl5", m_hdr_nwd_sl5, "Number of word for TSF5 Header", 3);
66  addParam("hdr_nwd_sl6", m_hdr_nwd_sl6, "Number of word for TSF6 Header", 3);
67  addParam("hdr_nwd_sl8", m_hdr_nwd_sl8, "Number of word for TSF8 Header", 3);
68  addParam("hdr_nwd_etf", m_hdr_nwd_etf, "Number of word for ETF Header", 3);
69  addParam("hdr_nwd_grl", m_hdr_nwd_grl, "Number of word for GRL Header", 3);
70  addParam("hdr_nwd_top", m_hdr_nwd_top, "Number of word for TOP Header", 3);
71  addParam("hdr_nwd_gdl", m_hdr_nwd_gdl, "Number of word for GDL Header", 6);
72 
73  addParam("cpr_2d0", m_cpr_2d0, "Copper number of 2D0", 0x11000001U);
74  addParam("cpr_2d1", m_cpr_2d1, "Copper number of 2D1", 0x11000001U);
75  addParam("cpr_2d2", m_cpr_2d2, "Copper number of 2D2", 0x11000002U);
76  addParam("cpr_2d3", m_cpr_2d3, "Copper number of 2D3", 0x11000002U);
77  addParam("cpr_3d0", m_cpr_3d0, "Copper number of 3D0", 0x11000003U);
78  addParam("cpr_3d1", m_cpr_3d1, "Copper number of 3D1", 0x11000003U);
79  addParam("cpr_3d2", m_cpr_3d2, "Copper number of 3D2", 0x11000004U);
80  addParam("cpr_3d3", m_cpr_3d3, "Copper number of 3D3", 0x11000004U);
81  addParam("cpr_nn0", m_cpr_nn0, "Copper number of NN0", 0x11000005U);
82  addParam("cpr_nn1", m_cpr_nn1, "Copper number of NN1", 0x11000005U);
83  addParam("cpr_nn2", m_cpr_nn2, "Copper number of NN2", 0x11000006U);
84  addParam("cpr_nn3", m_cpr_nn3, "Copper number of NN3", 0x11000006U);
85  addParam("cpr_sl0", m_cpr_sl0, "Copper number of SL0", 0x11000007U);
86  addParam("cpr_sl1", m_cpr_sl1, "Copper number of SL1", 0x11000009U);//*
87  addParam("cpr_sl2", m_cpr_sl2, "Copper number of SL2", 0x11000008U);
88  addParam("cpr_sl3", m_cpr_sl3, "Copper number of SL3", 0x11000008U);
89  addParam("cpr_sl4", m_cpr_sl4, "Copper number of SL4", 0x11000007U);//*
90  addParam("cpr_sl5", m_cpr_sl5, "Copper number of SL5", 0x11000009U);
91  addParam("cpr_sl6", m_cpr_sl6, "Copper number of SL6", 0x1100000aU);
92  addParam("cpr_sl7", m_cpr_sl7, "Copper number of SL7", 0x1100000a);
93  addParam("cpr_sl8", m_cpr_sl8, "Copper number of SL8", 0x1100000aU);
94  addParam("cpr_gdl", m_cpr_gdl, "Copper number of GDL", 0x15000001U);
95  addParam("cpr_etf", m_cpr_etf, "Copper number of ETF", 0x15000001U);
96  addParam("cpr_grl", m_cpr_grl, "Copper number of GRL", 0x15000002);
97  addParam("cpr_top", m_cpr_top, "Copper number of TOP", 0x12000001U);
98 
99  addParam("on_2d0", m_on_2d0, "ON/OFF of 2D0", true);
100  addParam("on_2d1", m_on_2d1, "ON/OFF of 2D1", true);
101  addParam("on_2d2", m_on_2d2, "ON/OFF of 2D2", true);
102  addParam("on_2d3", m_on_2d3, "ON/OFF of 2D3", true);
103  addParam("on_3d0", m_on_3d0, "ON/OFF of 3D0", true);
104  addParam("on_3d1", m_on_3d1, "ON/OFF of 3D1", true);
105  addParam("on_3d2", m_on_3d2, "ON/OFF of 3D2", true);
106  addParam("on_3d3", m_on_3d3, "ON/OFF of 3D3", true);
107  addParam("on_nn0", m_on_nn0, "ON/OFF of NN0", true);
108  addParam("on_nn1", m_on_nn1, "ON/OFF of NN1", true);
109  addParam("on_nn2", m_on_nn2, "ON/OFF of NN2", true);
110  addParam("on_nn3", m_on_nn3, "ON/OFF of NN3", true);
111  addParam("on_sl0", m_on_sl0, "ON/OFF of SL0", true);
112  addParam("on_sl1", m_on_sl1, "ON/OFF of SL1", true);
113  addParam("on_sl2", m_on_sl2, "ON/OFF of SL2", true);
114  addParam("on_sl3", m_on_sl3, "ON/OFF of SL3", true);
115  addParam("on_sl4", m_on_sl4, "ON/OFF of SL4", true);
116  addParam("on_sl5", m_on_sl5, "ON/OFF of SL5", true);
117  addParam("on_sl6", m_on_sl6, "ON/OFF of SL6", true);
118  addParam("on_sl7", m_on_sl7, "ON/OFF of SL7", true);
119  addParam("on_sl8", m_on_sl8, "ON/OFF of SL8", true);
120  addParam("on_gdl", m_on_gdl, "ON/OFF of GDL", true);
121  addParam("on_etf", m_on_etf, "ON/OFF of ETF", true);
122  addParam("on_grl", m_on_grl, "ON/OFF of GRL", true);
123  addParam("on_top", m_on_top, "ON/OFF of TOP", true);
124 
125  addParam("nwd_2ds", m_nwd_2ds, "N word of 2Ds", 3939); // 2624x48
126  addParam("nwd_3ds", m_nwd_3ds, "N word of 3Ds", 3939); // 2624x48
127  addParam("nwd_nns", m_nwd_nns, "N word of NNs", 0xc03); // 2048x48
128  addParam("nwd_sl0", m_nwd_sl0, "N word of SL0", 0xc03); // 2048x48
129  addParam("nwd_sl1", m_nwd_sl1, "N word of SL1", 0x1803); // 4096x48
130  addParam("nwd_sl2", m_nwd_sl2, "N word of SL2", 0x1803); // 4096x48
131  addParam("nwd_sl3", m_nwd_sl3, "N word of SL3", 0x1803); // 4096x48
132  addParam("nwd_sl4", m_nwd_sl4, "N word of SL4", 0xc03); // 2048x48
133  addParam("nwd_sl5", m_nwd_sl5, "N word of SL5", 0x1803); // 4096x48
134  addParam("nwd_sl6", m_nwd_sl6, "N word of SL6", 0xc03); // 2048x48
135  addParam("nwd_sl7", m_nwd_sl7, "N word of SL7", 0x603); // 1024x48
136  addParam("nwd_sl8", m_nwd_sl8, "N word of SL8", 0x603); // 1024x48
137  addParam("nwd_gdl", m_nwd_gdl, "N word of GDL", 646); // 640x32
138  addParam("nwd_etf", m_nwd_etf, "N word of ETF", 1539); // 1024x48
139  addParam("nwd_grl", m_nwd_grl, "N word of GRL", 0xc03); // 1024x48
140  addParam("nwd_top", m_nwd_top, "N word of TOP", 0x303); // 1024*24
141 
142  addParam("nclk_2ds", m_nclk_2ds, "N clk of 2Ds", 48);
143  addParam("nclk_3ds", m_nclk_3ds, "N clk of 3Ds", 48);
144  addParam("nclk_nns", m_nclk_nns, "N clk of NNs", 48);
145  addParam("nclk_sl0", m_nclk_sl0, "N clk of SL0", 48);
146  addParam("nclk_sl1", m_nclk_sl1, "N clk of SL1", 48);
147  addParam("nclk_sl2", m_nclk_sl2, "N clk of SL2", 48);
148  addParam("nclk_sl3", m_nclk_sl3, "N clk of SL3", 48);
149  addParam("nclk_sl4", m_nclk_sl4, "N clk of SL4", 48);
150  addParam("nclk_sl5", m_nclk_sl5, "N clk of SL5", 48);
151  addParam("nclk_sl6", m_nclk_sl6, "N clk of SL6", 48);
152  addParam("nclk_sl7", m_nclk_sl7, "N clk of SL7", 48);
153  addParam("nclk_sl8", m_nclk_sl8, "N clk of SL8", 48);
154  addParam("nclk_gdl", m_nclk_gdl, "N clk of GDL", 32);
155  addParam("nclk_etf", m_nclk_etf, "N clk of ETF", 48);
156  addParam("nclk_grl", m_nclk_grl, "N clk of GRL", 48);
157  addParam("nclk_top", m_nclk_top, "N clk of TOP", 24);
158 
159  addParam("nclk_cdctrg", m_nclk_cdctrg, "N clock of CDCTRG", 48);
160 
161  addParam("scale_2ds", m_scale_2ds, "Scale factor of 2Ds", 256);
162  addParam("scale_3ds", m_scale_3ds, "Scale factor of 3Ds", 256);
163  addParam("scale_nns", m_scale_nns, "Scale factor of NNs", 256);
164  addParam("scale_sl0", m_scale_sl0, "Scale factor of SL0", 256);
165  addParam("scale_sl1", m_scale_sl1, "Scale factor of SL1", 256);
166  addParam("scale_sl2", m_scale_sl2, "Scale factor of SL2", 256);
167  addParam("scale_sl3", m_scale_sl3, "Scale factor of SL3", 256);
168  addParam("scale_sl4", m_scale_sl4, "Scale factor of SL4", 256);
169  addParam("scale_sl5", m_scale_sl5, "Scale factor of SL5", 256);
170  addParam("scale_sl6", m_scale_sl6, "Scale factor of SL6", 256);
171  addParam("scale_sl7", m_scale_sl7, "Scale factor of SL7", 256);
172  addParam("scale_sl8", m_scale_sl8, "Scale factor of SL8", 256);
173  addParam("scale_gdl", m_scale_gdl, "Scale factor of GDL", 1);
174  addParam("scale_etf", m_scale_etf, "Scale factor of ETF", 512);
175  addParam("scale_grl", m_scale_grl, "Scale factor of GRL", 1);
176  addParam("scale_top", m_scale_top, "Scale factor of TOP", 32);
177 
178  addParam("fmid_2d0", m_fmid_2d0, "Firmware ID of 2D0", 0x32442020);
179  addParam("fmid_2d1", m_fmid_2d1, "Firmware ID of 2D1", 0x32442020);
180  addParam("fmid_2d2", m_fmid_2d2, "Firmware ID of 2D2", 0x32442020);
181  addParam("fmid_2d3", m_fmid_2d3, "Firmware ID of 2D3", 0x32442020);
182  addParam("fmid_3d0", m_fmid_3d0, "Firmware ID of 3D0", 0x33440001);
183  addParam("fmid_3d1", m_fmid_3d1, "Firmware ID of 3D1", 0x33440001);
184  addParam("fmid_3d2", m_fmid_3d2, "Firmware ID of 3D2", 0x33440001);
185  addParam("fmid_3d3", m_fmid_3d3, "Firmware ID of 3D3", 0x33440001);
186  addParam("fmid_nn0", m_fmid_nn0, "Firmware ID of NN0", 0x4e4e5402);
187  addParam("fmid_nn1", m_fmid_nn1, "Firmware ID of NN1", 0x4e4e5402);
188  addParam("fmid_nn2", m_fmid_nn2, "Firmware ID of NN2", 0x4e4e5402);
189  addParam("fmid_nn3", m_fmid_nn3, "Firmware ID of NN3", 0x4e4e5402);
190  addParam("fmid_sl0", m_fmid_sl0, "Firmware ID of SL0", 0x54534630);
191  addParam("fmid_sl1", m_fmid_sl1, "Firmware ID of SL1", 0x54534631);
192  addParam("fmid_sl2", m_fmid_sl2, "Firmware ID of SL2", 0x54534632);
193  addParam("fmid_sl3", m_fmid_sl3, "Firmware ID of SL3", 0x54534633);
194  addParam("fmid_sl4", m_fmid_sl4, "Firmware ID of SL4", 0x54534634);
195  addParam("fmid_sl5", m_fmid_sl5, "Firmware ID of SL5", 0x54534635);
196  addParam("fmid_sl6", m_fmid_sl6, "Firmware ID of SL6", 0x54534636);
197  addParam("fmid_sl7", m_fmid_sl7, "Firmware ID of SL7", 0x54534637);
198  addParam("fmid_sl8", m_fmid_sl8, "Firmware ID of SL8", 0x54534d38);
199  addParam("fmid_gdl", m_fmid_gdl, "Firmware ID of GDL", 0x47444c20U);
200  addParam("fmid_etf", m_fmid_etf, "Firmware ID of ETF", 0x45544620);
201  addParam("fmid_grl", m_fmid_grl, "Firmware ID of GRL", 0x47824c20);
202  addParam("fmid_top", m_fmid_top, "Firmware ID of TOP", 0);
203 
204 }
205 
206 void TRGRAWDATAModule::initialize()
207 {
208  B2INFO("trgrawdata: initialize() started.");
209  if (! m_unpacker) {
210  B2INFO("no database of gdl unpacker");
211  }
212  if (m_print_dbmap) {
213 
214  //const int nword_header = m_unpacker->get_nword_header(); //not used for now
215  //const int n_clocks = m_unpacker->getnClks(); //not used for now
216  //const int nBits = m_unpacker->getnBits(); //not used for now
217  const int n_leafs = m_unpacker->getnLeafs();
218  const int n_leafsExtra = m_unpacker->getnLeafsExtra();
219  //const int conf = m_unpacker->getconf(); //not used for now
220 
221  int aBitMap[320][2] = {{0}};
222  int aBitMap_extra[100][3] = {{ -1}};
223  for (int i = 0; i < n_leafsExtra; i++) {
224  aBitMap_extra[i][0] = m_unpacker->getBitMap_extra(i, 0);
225  aBitMap_extra[i][1] = m_unpacker->getBitMap_extra(i, 1);
226  aBitMap_extra[i][2] = m_unpacker->getBitMap_extra(i, 2);
227  }
228 
229  for (int i = 0; i < 200; i++) {
230  LeafBitMap[i] = m_unpacker->getLeafMap(i);
231  std::cout << "LeafBitMap[" << i << "] = " << m_unpacker->getLeafMap(i) << std::endl;
232  strcpy(LeafNames[i], m_unpacker->getLeafnames(i));
233  std::cout << "LeafNames[" << i << "] = " << m_unpacker->getLeafnames(i) << std::endl;
234  }
235  for (int i = 0; i < n_leafs; i++) {
236  aBitMap[i][0] = m_unpacker->getBitMap(i, 0);
237  aBitMap[i][1] = m_unpacker->getBitMap(i, 1);
238  }
239  for (int i = 0; i < 200; i++) {
240  int bin = m_unpacker->getLeafMap(i) + 1;
241  if (0 < bin && bin <= n_leafs) {
242  std::cout << "leaf(" << i
243  << "), bin(" << bin
244  << "), LeafNames[leaf](" << LeafNames[i]
245  << "), BitMap[bin-1][0](" << aBitMap[bin - 1][0]
246  << "), BitMap[bin-1][1](" << aBitMap[bin - 1][1]
247  << ")" << std::endl;
248  }
249  }
250  // for leafsExtra
251  for (int i = 0; i < 200; i++) {
252  int bin = m_unpacker->getLeafMap(i) + 1;
253  int j = bin - n_leafs - 1;
254  if (n_leafs < bin && bin <= n_leafs + n_leafsExtra) {
255  std::cout << "i(" << i
256  << "), bin(" << bin
257  << "), LeafNames[leaf](" << LeafNames[i]
258  << "), BitMap_extra[j][0](buf[" << aBitMap_extra[j][0]
259  << "]), BitMap_extra[j][1](downto " << aBitMap_extra[j][1]
260  << "), BitMap_extra[j][2](" << aBitMap_extra[j][2]
261  << " bit length)" << std::endl;
262  }
263  }
264 
265  }
266  for (int i = 0; i < 50; i++) {
267  cntr_bad_odr[i] = 0;
268  cntr_bad_ddd[i] = 0;
269  cntr_bad_nwd[i] = 0;
270 
271  cntr_nw3[i] = 0;
272  cntr_nw3_badvet[i] = 0;
273  cntr_nw3_badtrg[i] = 0;
274  cntr_nw3_badrvc[i] = 0;
275 
276  cntr_nwn[i] = 0;
277  cntr_nwn_badvet[i] = 0;
278  cntr_nwn_badtrg[i] = 0;
279  cntr_nwn_badrvc[i] = 0;
280 
281  cntr_nwn_badbbb[i] = 0;
282  cntr_nwn_badddd[i] = 0;
283 
284  cntr_nwe_badnwd[i] = 0;
285 
286  }
287 
288 }
289 
290 void TRGRAWDATAModule::event()
291 {
292 
293  B2INFO("trgrawdata: event() started.");
294  StoreArray<RawTRG> raw_trgarray;
295 
296  StoreObjPtr<EventMetaData> bevt;
297  int _exp = bevt->getExperiment();
298  int _run = bevt->getRun();
299  unsigned _eve = bevt->getEvent();
300  if (0)
301  std::cout << "**************_eve(" << _eve
302  << "), c_nModules(" << c_nModules
303  << "), m_nclk_cdctrg(" << m_nclk_cdctrg
304  << "), _exp(" << _exp
305  << "), _run(" << _run
306  << "), _eve(" << _eve
307  << "), _Form(" << Form("he%010d", (int)_eve)
308  << ")" << std::endl;
309 
310  TH2D* h_0 = new TH2D(Form("he%010d", (int)_eve),
311  Form("e%02dr%04d ev %08d", _exp, _run, (int)_eve),
312  c_nModules * 4, 0, c_nModules * 4,
313  m_nclk_cdctrg, 0, m_nclk_cdctrg);
314 
315  for (unsigned i = 0; i < c_nModules; ++i) {
316  h_0->GetXaxis()->SetBinLabel(4 * i + 1, Form("%s hdevt", moduleNames[i]));
317  h_0->GetXaxis()->SetBinLabel(4 * i + 2, Form("%s dtevt", moduleNames[i]));
318  h_0->GetXaxis()->SetBinLabel(4 * i + 3, Form("%s L1rvc", moduleNames[i]));
319  h_0->GetXaxis()->SetBinLabel(4 * i + 4, Form("%s cc", moduleNames[i]));
320  }
321 
322  /*
323  GDL only. To get gdlrvc12
324  */
325  unsigned gdlrvc12 = -1;
326  for (int i = 0; i < raw_trgarray.getEntries(); i++) {
327  for (int j = 0; j < raw_trgarray[i]->GetNumEntries(); j++) {
328  int cprid = (int)raw_trgarray[i]->GetNodeID(j);
329  unsigned eve20 = (_eve & 0xfffff);
330  for (int hslb = 0; hslb < 2; hslb++) {
331  int nword = raw_trgarray[i]->GetDetectorNwords(j, hslb);
332  int* buf = raw_trgarray[i]->GetDetectorBuffer(j, hslb);
333  if (0x15000001 == cprid && hslb == 0) {
334 
335  if (m_mydebug) {
336  printf("aa:GDL start: 0x%x%c exp(%d), run(%d), eve(%u), eve(0x%x), nword(%d)\n",
337  cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword);
338  }
339 
340  unsigned buf0 = 0;
341  if (nword > 0) buf0 = (unsigned)buf[0];
342  unsigned buf1 = 0;
343  if (nword > 1) buf1 = (unsigned)buf[1];
344  unsigned buf2 = 0;
345  if (nword > 2) buf2 = (unsigned)buf[2];
346  //unsigned buf2cnttrg20 = (buf2 >> 12) & 0xfffff;
347  //unsigned buf2rvc12 = (buf2 & 0xfff);
348 
349  if (nword < 3) {
350  cntr_nwe_badnwd[e_gdl]++;
351  printf("ab:GDL(0x%x%c) exp(%d), run(%d), eve(%u), eve(0x%x), nword(%d), ",
352  cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword);
353  printf("buf0(0x%x), buf1(0x%x), buf2(0x%x)\n", buf0, buf1, buf2);
354  continue;
355  }
356 
357  if (nword < 8) {
358  printf("ad:GDL(0x%x%c) exp(%d), run(%d), eve(%u), eve(0x%x), nword(%d)\n",
359  cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword);
360  cntr_nwe_badnwd[e_gdl]++;
361  } else {
362  unsigned buf5 = (unsigned)buf[m_hdr_nwd_gdl - 1];
363  // 626 = 646 -
364  unsigned buf6 = (unsigned)buf[626]; // 1st wd in the last clock cycle
365  unsigned buf7 = (unsigned)buf[627]; // 2nd wd in the last clock cycle
366  unsigned lastdd = (buf6 >> 24) & 0xff;
367  unsigned last_rvc = (buf6 >> 4) & 0xfff;
368  unsigned cnttrg_data_15to12 = buf6 & (0xf);
369  unsigned cnttrg_data_12 = (buf7 >> 20) & (0xfff);
370  gdlrvc12 = (buf5 & 0xfff);
371  unsigned gdlhdrcnttrg20 = (buf5 >> 12) & 0xfffff;
372 
373  //unsigned wdperclk = (m_nwd_gdl - m_hdr_nwd_gdl) / m_nclk_gdl;
374  //unsigned ibuf_lastclk_msw = m_nwd_gdl - wdperclk;
375  //unsigned buf_lastclk_msw = (unsigned)buf[ibuf_lastclk_msw];
376  //unsigned buf_lastclk_msw2 = (unsigned)buf[ibuf_lastclk_msw + 1];
377  //unsigned buf_lastclk_msw3 = (unsigned)buf[ibuf_lastclk_msw + 2];
378  unsigned cnttrg_data_16 = (cnttrg_data_15to12 << 12) + cnttrg_data_12;
379  unsigned eve16 = (_eve & 0xffff);
380 
381  h_0->SetBinContent(4 * (int)e_gdl + 1, m_nclk_gdl, gdlhdrcnttrg20);
382  h_0->SetBinContent(4 * (int)e_gdl + 2, m_nclk_gdl, cnttrg_data_16);
383  h_0->SetBinContent(4 * (int)e_gdl + 3, m_nclk_gdl, gdlrvc12);
384 
385  if (nword != m_nwd_gdl || buf0 != m_fmid_gdl || lastdd != 0xdd ||
386  gdlhdrcnttrg20 != eve20 ||
387  !(eve16 == cnttrg_data_16 + 1 || (eve16 == 0 && cnttrg_data_16 == 0xffff))
388  ) {
389 
390  unsigned diag = 0;
391  diag |= (nword != m_nwd_gdl) ? 1 : 0;
392  diag |= (buf0 != m_fmid_gdl) ? 2 : 0;
393  diag |= (lastdd != 0xdd) ? 4 : 0;
394  diag |= (gdlhdrcnttrg20 != eve20) ? 8 : 0;
395  diag |= !(eve16 == cnttrg_data_16 + 1 || (eve16 == 0 && cnttrg_data_16 == 0xffff)) ? 16 : 0;
396  printf("ae:GDL(0x%x%c) exp(%d), run(%d), evedaq(%u=0x%x), gdlhdrcnttrg20(%u,0x%x), "
397  "cnttrg_data16(%u=0x%x), l1rvc(%u)-lastrvc(%u)=%u, nword(%d), diag(%u)\n",
398  cprid, 'a' + hslb, _exp, _run, _eve, _eve, gdlhdrcnttrg20, gdlhdrcnttrg20,
399  cnttrg_data_16, cnttrg_data_16, gdlrvc12, last_rvc, gdlrvc12 - last_rvc, nword, diag); //TODO can the difference be negative?
400  printf("\n");
401  cntr_nwn_badtrg[e_gdl]++;
402  } else {
403  cntr_nwn[e_gdl]++;
404  }
405  }
406  }
407  }
408  }
409  }
410 
411  /* Other than GDL */
412  for (int i = 0; i < raw_trgarray.getEntries(); i++) {
413  for (int j = 0; j < raw_trgarray[i]->GetNumEntries(); j++) {
414  unsigned cprid = raw_trgarray[i]->GetNodeID(j);
415  //unsigned eve16 = (_eve & 0xffff);
416  unsigned eve20 = (_eve & 0xfffff);
417  for (int hslb = 0; hslb < 2; hslb++) {
418  unsigned e_mdl = -1;
419  unsigned _nwd = -1;
420  unsigned _scale = -1;
421  unsigned _nclk = -1;
422  unsigned _hdr_nwd = 3;
423  if (m_cpr_2d0 == cprid && hslb == 0 && m_on_2d0) {
424  e_mdl = e_2d0; _nwd = m_nwd_2ds; _scale = m_scale_2ds; _nclk = m_nclk_2ds; _hdr_nwd = m_hdr_nwd_2d0;
425  } else if (m_cpr_2d1 == cprid && hslb == 1 && m_on_2d1) {
426  e_mdl = e_2d1; _nwd = m_nwd_2ds; _scale = m_scale_2ds; _nclk = m_nclk_2ds; _hdr_nwd = m_hdr_nwd_2d1;
427  } else if (m_cpr_2d2 == cprid && hslb == 0 && m_on_2d2) {
428  e_mdl = e_2d2; _nwd = m_nwd_2ds; _scale = m_scale_2ds; _nclk = m_nclk_2ds; _hdr_nwd = m_hdr_nwd_2d2;
429  } else if (m_cpr_2d3 == cprid && hslb == 1 && m_on_2d3) {
430  e_mdl = e_2d3; _nwd = m_nwd_2ds; _scale = m_scale_2ds; _nclk = m_nclk_2ds; _hdr_nwd = m_hdr_nwd_2d3;
431  } else if (m_cpr_3d0 == cprid && hslb == 0 && m_on_3d0) {
432  e_mdl = e_3d0; _nwd = m_nwd_3ds; _scale = m_scale_3ds; _nclk = m_nclk_3ds; _hdr_nwd = m_hdr_nwd_3d0;
433  } else if (m_cpr_3d1 == cprid && hslb == 1 && m_on_3d1) {
434  e_mdl = e_3d1; _nwd = m_nwd_3ds; _scale = m_scale_3ds; _nclk = m_nclk_3ds; _hdr_nwd = m_hdr_nwd_3d1;
435  } else if (m_cpr_3d2 == cprid && hslb == 0 && m_on_3d2) {
436  e_mdl = e_3d2; _nwd = m_nwd_3ds; _scale = m_scale_3ds; _nclk = m_nclk_3ds; _hdr_nwd = m_hdr_nwd_3d2;
437  } else if (m_cpr_3d3 == cprid && hslb == 1 && m_on_3d3) {
438  e_mdl = e_3d3; _nwd = m_nwd_3ds; _scale = m_scale_3ds; _nclk = m_nclk_3ds; _hdr_nwd = m_hdr_nwd_3d3;
439  } else if (m_cpr_nn0 == cprid && hslb == 0 && m_on_nn0) {
440  e_mdl = e_nn0; _nwd = m_nwd_nns; _scale = m_scale_nns; _nclk = m_nclk_nns; _hdr_nwd = m_hdr_nwd_nn0;
441  } else if (m_cpr_nn1 == cprid && hslb == 1 && m_on_nn1) {
442  e_mdl = e_nn1; _nwd = m_nwd_nns; _scale = m_scale_nns; _nclk = m_nclk_nns; _hdr_nwd = m_hdr_nwd_nn1;
443  } else if (m_cpr_nn2 == cprid && hslb == 0 && m_on_nn2) {
444  e_mdl = e_nn2; _nwd = m_nwd_nns; _scale = m_scale_nns; _nclk = m_nclk_nns; _hdr_nwd = m_hdr_nwd_nn2;
445  } else if (m_cpr_nn3 == cprid && hslb == 1 && m_on_nn3) {
446  e_mdl = e_nn3; _nwd = m_nwd_nns; _scale = m_scale_nns; _nclk = m_nclk_nns; _hdr_nwd = m_hdr_nwd_nn3;
447  } else if (m_cpr_sl0 == cprid && hslb == 0 && m_on_sl0) {
448  e_mdl = e_sl0; _nwd = m_nwd_sl0; _scale = m_scale_sl0; _nclk = m_nclk_sl0; _hdr_nwd = m_hdr_nwd_sl0;
449  } else if (m_cpr_sl1 == cprid && hslb == 0 && m_on_sl1) { //ex w/ 1
450  e_mdl = e_sl1; _nwd = m_nwd_sl1; _scale = m_scale_sl1; _nclk = m_nclk_sl1; _hdr_nwd = m_hdr_nwd_sl1;
451  } else if (m_cpr_sl2 == cprid && hslb == 0 && m_on_sl2) {
452  e_mdl = e_sl2; _nwd = m_nwd_sl2; _scale = m_scale_sl2; _nclk = m_nclk_sl2; _hdr_nwd = m_hdr_nwd_sl2;
453  } else if (m_cpr_sl3 == cprid && hslb == 1 && m_on_sl3) {
454  e_mdl = e_sl3; _nwd = m_nwd_sl3; _scale = m_scale_sl3; _nclk = m_nclk_sl3; _hdr_nwd = m_hdr_nwd_sl3;
455  } else if (m_cpr_sl4 == cprid && hslb == 1 && m_on_sl4) { //ex w/ 4
456  e_mdl = e_sl4; _nwd = m_nwd_sl4; _scale = m_scale_sl4; _nclk = m_nclk_sl4; _hdr_nwd = m_hdr_nwd_sl4;
457  } else if (m_cpr_sl5 == cprid && hslb == 1 && m_on_sl5) {
458  e_mdl = e_sl5; _nwd = m_nwd_sl5; _scale = m_scale_sl5; _nclk = m_nclk_sl5; _hdr_nwd = m_hdr_nwd_sl5;
459  } else if (m_cpr_sl6 == cprid && hslb == 0 && m_on_sl6) {
460  e_mdl = e_sl6; _nwd = m_nwd_sl6; _scale = m_scale_sl6; _nclk = m_nclk_sl6; _hdr_nwd = m_hdr_nwd_sl6;
461  } else if (m_cpr_sl8 == cprid && hslb == 0 && m_on_sl8) {
462  e_mdl = e_sl8; _nwd = m_nwd_sl8; _scale = m_scale_sl8; _nclk = m_nclk_sl8; _hdr_nwd = m_hdr_nwd_sl8;
463  } else if (m_cpr_etf == cprid && hslb == 1 && m_on_etf) {
464  e_mdl = e_etf; _nwd = m_nwd_etf; _scale = m_scale_etf; _nclk = m_nclk_etf; _hdr_nwd = m_hdr_nwd_etf;
465  } else if (m_cpr_top == cprid && hslb == 0 && m_on_top) {
466  e_mdl = e_top; _nwd = m_nwd_top; _scale = m_scale_top; _nclk = m_nclk_top; _hdr_nwd = m_hdr_nwd_top;
467  } else {
468  continue;
469  }
470 
471  unsigned nword = raw_trgarray[i]->GetDetectorNwords(j, hslb);
472  int* buf = raw_trgarray[i]->GetDetectorBuffer(j, hslb);
473  unsigned buf0 = 0;
474  if (nword > 0) buf0 = (unsigned)buf[0];
475  unsigned buf1 = 0;
476  if (nword > 1) buf1 = (unsigned)buf[1];
477  unsigned buf2 = 0;
478  if (nword > 2) buf2 = (unsigned)buf[2];
479  unsigned buf2cnttrg20 = (buf2 >> 12) & 0xfffff;
480  unsigned buf2rvc12 = (buf2 & 0xfff);
481 
482  if (nword < 3) {
483  // err
484  cntr_nwe_badnwd[e_mdl]++;
485  printf("ah:%s(0x%x%c) exp(%d), run(%d), eve(%u), eve(0x%x), nword(%u), ",
486  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword);
487  printf("buf0(0x%x), buf1(0x%x), buf2(0x%x)\n", buf0, buf1, buf2);
488  continue;
489  } else if (nword == _hdr_nwd) {
490  // header-only event
491  if (gdlrvc12 != buf2rvc12) {
492  printf("ai:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), gdlrvc12(0x%x), buf2rvc12(0x%x)\n",
493  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, gdlrvc12, buf2rvc12);
494  cntr_nw3_badrvc[e_mdl]++;
495  } else if (eve20 != buf2cnttrg20) {
496  printf("aj:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), cnttrg20(0x%x)\n",
497  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, buf2cnttrg20);
498  cntr_nw3_badtrg[e_mdl]++;
499  } else if ((_eve % _scale) == 0) {
500  cntr_nw3_badvet[e_mdl]++;
501  } else {
502  cntr_nw3[e_mdl]++;
503  }
504  continue;
505  } else if (nword != _nwd) {
506  // err
507  printf("bo:wrong nword: %s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), buf0(0x%x), buf2(0x%x)\n",
508  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, buf0, buf2);
509  cntr_nwe_badnwd[e_mdl]++;
510  continue;
511  }
512 
513  unsigned buf3 = (unsigned)buf[_hdr_nwd];
514  unsigned buf3dddd = ((buf3 >> 16) & 0xffff);
515  unsigned buf4 = (unsigned)buf[_hdr_nwd + 1];
516  unsigned buf5 = (unsigned)buf[_hdr_nwd + 2];
517  unsigned wdperclk = (_nwd - _hdr_nwd) / _nclk;
518  //unsigned ibuf_lsw = _nwd - 1;
519  unsigned ibuf_lastclk_msw = _nwd - wdperclk;
520  //unsigned buf_lastclk_msw = (unsigned)buf[ibuf_lastclk_msw];
521  unsigned buf_lastclk_msw2 = (unsigned)buf[ibuf_lastclk_msw + 1];
522  unsigned buf_lastclk_msw3 = (unsigned)buf[ibuf_lastclk_msw + 2];
523  //unsigned dddd_lastclk = ((buf_lastclk_msw >> 16) & 0xffff);
524  unsigned datacnttrg32 = 0;
525  unsigned buf4_msb16 = (buf4 & 0xffff);
526  unsigned buf5_lsb16 = ((buf5 >> 16) & 0xffff);
527 
528  if (m_mydebug) {
529  printf("af:Debug0: %s(0x%x%c) exp(%d), run(%d), eve(%u), eve(0x%x), nword(%u)\n",
530  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword);
531  }
532 
533  /*
534  *
535  * Module Start
536  *
537  *
538  */
539 
540  if ((0x11000009 == cprid && hslb == 0) || // SL1
541  (0x11000008 == cprid && hslb == 1) || // SL1
542  (0x11000009 == cprid && hslb == 1) // SL5
543  ) {
544  /* SL1 SL3 SL5 4096x48
545  data_b2l_r(4095 downto 4048) <= x"dddd" & "00000" & revoclk & cntr125M(15 downto 0);--i=0..5
546  data_b2l_r(4031 downto 4000) <= cnttrg;--i=6..9
547  buf[3] = dddd * revoclk
548  buf[4] = cntr125M & x"0000"
549  buf[5] = cnttrg
550  */
551  datacnttrg32 = buf5;
552 
553  } else if ((0x11000007 == cprid && hslb == 0) || // SL0
554  (0x11000007 == cprid && hslb == 1) || // SL4
555  (0x1100000a == cprid && hslb == 0) // SL6
556  ) {
557  /* SL0 SL4 SL6 2048*48
558  data_b2l_r(2047 downto 2000) <= x"dddd" &"00000"& revoclk & cntr125M(15 downto 0);
559  data_b2l_r(1999 downto 1968) <= cnttrg;
560 
561  data_b2l(2047, 2016) <= buf[3]
562  data_b2l(2015, 1984) <= buf[4]
563  data_b2l(1983, 1952) <= buf[5]
564  data_b2l(1999, 1968) <= cnttrg;
565  */
566  datacnttrg32 = (buf4_msb16 << 16) + buf5_lsb16;
567 
568  } else if ((m_cpr_2d0 == cprid && hslb == 0 && m_on_2d0) ||
569  (m_cpr_2d1 == cprid && hslb == 1 && m_on_2d1) ||
570  (m_cpr_2d2 == cprid && hslb == 0 && m_on_2d2) ||
571  (m_cpr_2d3 == cprid && hslb == 1 && m_on_2d3)) {
572  /*
573  2D2D2D: 2048 bit x 48 clock = 64 word x 48 clock
574  */
575 
576  unsigned buf_lastclk_lsb = (unsigned)buf[_nwd - 1];
577  unsigned buf_lastclk_lsb2 = (unsigned)buf[_nwd - 2];
578  //unsigned nworking = (buf_lastclk_lsb2 >> 24) & 0xff;
579  //unsigned idbuf = (buf_lastclk_lsb2 >> 16) & 0xff;
580  //unsigned ihdr = (buf_lastclk_lsb2 >> 8) & 0xff;
581  datacnttrg32 = ((buf_lastclk_lsb2 & 0xff) << 24) + (buf_lastclk_lsb >> 8);
582 
583  } else if ((m_cpr_3d0 == cprid && hslb == 0 && m_on_3d0) ||
584  (m_cpr_3d1 == cprid && hslb == 1 && m_on_3d1) ||
585  (m_cpr_3d2 == cprid && hslb == 0 && m_on_3d2) ||
586  (m_cpr_3d3 == cprid && hslb == 1 && m_on_3d3)) {
587  /*
588  3D3D3D: 2048 bit x 48 clock = 64 word x 48 clock
589  */
590 
591  // data_b2l_r(2623 downto 2576) <= x"dddd" &"00000"& revoclk & cntr125M(15 downto 0);
592  // data_b2l_r(2575 downto 2544) <= cnttrg;
593  // [3] (2623, 2592)
594  // [4] (2591, 2560)
595  // [5] (2559, 2528)
596  unsigned datacnttrg_msb16 = (buf_lastclk_msw2 & 0xffff);
597  unsigned datacnttrg_lsb16 = ((buf_lastclk_msw3 >> 16) & 0xffff);
598  datacnttrg32 = (datacnttrg_msb16 << 16) + datacnttrg_lsb16;
599 
600  } else if ((m_cpr_nn0 == cprid && hslb == 0 && m_on_nn0) ||
601  (m_cpr_nn1 == cprid && hslb == 1 && m_on_nn1) ||
602  (m_cpr_nn2 == cprid && hslb == 0 && m_on_nn2) ||
603  (m_cpr_nn3 == cprid && hslb == 1 && m_on_nn3)) {
604  /*
605  int e_mdl = -1;
606  if (m_cpr_nn0 == cprid && hslb == 0 && m_on_nn0) e_mdl = e_nn0;
607  if (m_cpr_nn1 == cprid && hslb == 1 && m_on_nn1) e_mdl = e_nn1;
608  if (m_cpr_nn2 == cprid && hslb == 0 && m_on_nn2) e_mdl = e_nn2;
609  if (m_cpr_nn3 == cprid && hslb == 1 && m_on_nn3) e_mdl = e_nn3;
610  */
611  /*
612  NNNNNN: 2048 bit x 48 clock = 64 word x 48 clock
613  data_b2l_r(1999 downto 1968) <= cnttrg;
614  */
615 
616  // [3] 2047 2016
617  // [4] 2015 1984
618  // [5] 1983 1952
619  // [3 + 64] = [m_hdr_nwd + wdperclk]
620  // [3 + 65] = [m_hdr_nwd + wdperclk + 1]
621  // [3 + 66] = [m_hdr_nwd + wdperclk + 2]
622  // [3 + 64 * 47] = [m_hdr_nwd + wdperclk * (_nclk - 1)]
623  // [3 + 65 * 47] = [m_hdr_nwd + wdperclk * (_nclk - 1) + 1]
624  // [3 + 66 * 47] = [m_hdr_nwd + wdperclk * (_nclk - 1) + 2]
625  unsigned datacnttrg_msb16 = (buf_lastclk_msw2 & 0xffff);
626  unsigned datacnttrg_lsb16 = ((buf_lastclk_msw3 >> 16) & 0xffff);
627  datacnttrg32 = (datacnttrg_msb16 << 16) + datacnttrg_lsb16;
628  } else if (m_cpr_top == cprid && hslb == 0 && m_on_top) {
629  // TOPTRG
630  } // Modules
631 
632  bool something_bad = false;
633  h_0->SetBinContent(4 * e_mdl + 1, _nclk, buf2cnttrg20);
634  h_0->SetBinContent(4 * e_mdl + 2, _nclk, datacnttrg32);
635  h_0->SetBinContent(4 * e_mdl + 3, _nclk, buf2rvc12);
636  if (gdlrvc12 != buf2rvc12) {
637  printf("ba:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), gdlrvc12(0x%x), buf2rvc12(0x%x)\n",
638  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, gdlrvc12, buf2rvc12);
639  cntr_nwn_badrvc[e_mdl]++;
640  something_bad = true;
641  }
642  if (buf3dddd == 0xbbbb) {
643  cntr_nwn_badbbb[e_mdl]++;
644  printf("bv:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), cnttrg20(0x%x), dddd(0x%x), datacnttrg32(0x%x)\n",
645  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, buf2cnttrg20, buf3dddd, datacnttrg32);
646  something_bad = true;
647  }
648  if (buf3dddd != 0xdddd) {
649  cntr_nwn_badddd[e_mdl]++;
650  printf("bb:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), cnttrg20(0x%x), dddd(0x%x), datacnttrg32(0x%x)\n",
651  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, buf2cnttrg20, buf3dddd, datacnttrg32);
652  something_bad = true;
653  }
654  if (datacnttrg32 + 1 != _eve) {
655  if (!(
656  (m_cpr_top == cprid) ||
657  (m_cpr_3d0 <= cprid && cprid <= m_cpr_3d3)
658  )
659  ) {
660  printf("bc:%s(0x%x%c) exp(%d), run(%d), eve(%u,0x%x), nword(%u), cnttrg20(0x%x), dddd(0x%x), datacnttrg32(0x%x)\n",
661  moduleNames[e_mdl], cprid, 'a' + hslb, _exp, _run, _eve, _eve, nword, buf2cnttrg20, buf3dddd, datacnttrg32);
662  cntr_nwn_badtrg[e_mdl]++;
663  something_bad = true;
664  }
665  }
666  if (! something_bad) cntr_nwn[e_mdl]++;
667 
668  } // for hslb
669  }
670  }
671 
672  if (m_cc_check) {
673  for (int i = 0; i < raw_trgarray.getEntries(); i++) {
674  for (int j = 0; j < raw_trgarray[i]->GetNumEntries(); j++) {
675  unsigned cprid = raw_trgarray[i]->GetNodeID(j);
676 // int _exp = raw_trgarray[i]->GetExpNo(j);
677 // int _run = raw_trgarray[i]->GetRunNo(j);
678  unsigned _eveRaw = raw_trgarray[i]->GetEveNo(j);
679  if ((0x11000001 <= cprid && cprid <= 0x1100000a) ||
680  (0x15000001 <= cprid && cprid <= 0x15000002) ||
681  (0x12000001 == cprid) // TOPTRG
682  ) {
683  } else {
684  continue;
685  }
686  for (int hslb = 0; hslb < 2; hslb++) {
687  int nclks = m_nclk_cdctrg;
688  unsigned _hdr_nwd = 3;
689  unsigned e_mdl = -1;
690  unsigned _nwd = -1;
691  if (m_cpr_top == cprid && hslb == 0 && m_on_top) {
692  e_mdl = e_top; _nwd = m_nwd_top;
693  nclks = m_nclk_top; _hdr_nwd = m_hdr_nwd_top;
694  } else if (m_cpr_2d0 == cprid && hslb == 0 && m_on_2d0) {
695  e_mdl = e_2d0; _nwd = m_nwd_2ds; _hdr_nwd = m_hdr_nwd_2d0;
696  } else if (m_cpr_2d1 == cprid && hslb == 1 && m_on_2d1) {
697  e_mdl = e_2d1; _nwd = m_nwd_2ds; _hdr_nwd = m_hdr_nwd_2d1;
698  } else if (m_cpr_2d2 == cprid && hslb == 0 && m_on_2d2) {
699  e_mdl = e_2d2; _nwd = m_nwd_2ds; _hdr_nwd = m_hdr_nwd_2d2;
700  } else if (m_cpr_2d3 == cprid && hslb == 1 && m_on_2d3) {
701  e_mdl = e_2d3; _nwd = m_nwd_2ds; _hdr_nwd = m_hdr_nwd_2d3;
702  } else if (m_cpr_3d0 == cprid && hslb == 0 && m_on_3d0) {
703  e_mdl = e_3d0; _nwd = m_nwd_3ds; _hdr_nwd = m_hdr_nwd_3d0;
704  } else if (m_cpr_3d1 == cprid && hslb == 1 && m_on_3d1) {
705  e_mdl = e_3d1; _nwd = m_nwd_3ds; _hdr_nwd = m_hdr_nwd_3d1;
706  } else if (m_cpr_3d2 == cprid && hslb == 0 && m_on_3d2) {
707  e_mdl = e_3d2; _nwd = m_nwd_3ds; _hdr_nwd = m_hdr_nwd_3d2;
708  } else if (m_cpr_3d3 == cprid && hslb == 1 && m_on_3d3) {
709  e_mdl = e_3d3; _nwd = m_nwd_3ds; _hdr_nwd = m_hdr_nwd_3d3;
710  } else if (m_cpr_nn0 == cprid && hslb == 0 && m_on_nn0) {
711  e_mdl = e_nn0; _nwd = m_nwd_nns; _hdr_nwd = m_hdr_nwd_nn0;
712  } else if (m_cpr_nn1 == cprid && hslb == 1 && m_on_nn1) {
713  e_mdl = e_nn1; _nwd = m_nwd_nns; _hdr_nwd = m_hdr_nwd_nn1;
714  } else if (m_cpr_nn2 == cprid && hslb == 0 && m_on_nn2) {
715  e_mdl = e_nn2; _nwd = m_nwd_nns; _hdr_nwd = m_hdr_nwd_nn2;
716  } else if (m_cpr_nn3 == cprid && hslb == 1 && m_on_nn3) {
717  e_mdl = e_nn3; _nwd = m_nwd_nns; _hdr_nwd = m_hdr_nwd_nn3;
718  } else if (m_cpr_sl0 == cprid && hslb == 0 && m_on_sl0) {
719  e_mdl = e_sl0; _nwd = m_nwd_sl0; _hdr_nwd = m_hdr_nwd_sl0;
720  } else if (m_cpr_sl1 == cprid && hslb == 0 && m_on_sl1) {//ex w/ 4
721  e_mdl = e_sl1; _nwd = m_nwd_sl1; _hdr_nwd = m_hdr_nwd_sl1;
722  } else if (m_cpr_sl2 == cprid && hslb == 0 && m_on_sl2) {
723  e_mdl = e_sl2; _nwd = m_nwd_sl2; _hdr_nwd = m_hdr_nwd_sl2;
724  } else if (m_cpr_sl3 == cprid && hslb == 1 && m_on_sl3) {
725  e_mdl = e_sl3; _nwd = m_nwd_sl3; _hdr_nwd = m_hdr_nwd_sl3;
726  } else if (m_cpr_sl4 == cprid && hslb == 1 && m_on_sl4) {//ex w/ 1
727  e_mdl = e_sl4; _nwd = m_nwd_sl4; _hdr_nwd = m_hdr_nwd_sl4;
728  } else if (m_cpr_sl5 == cprid && hslb == 1 && m_on_sl5) {
729  e_mdl = e_sl5; _nwd = m_nwd_sl5; _hdr_nwd = m_hdr_nwd_sl5;
730  } else if (m_cpr_sl6 == cprid && hslb == 0 && m_on_sl6) {
731  e_mdl = e_sl6; _nwd = m_nwd_sl6; _hdr_nwd = m_hdr_nwd_sl6;
732  } else if (m_cpr_sl8 == cprid && hslb == 0 && m_on_sl8) {
733  e_mdl = e_sl8; _nwd = m_nwd_sl8; _hdr_nwd = m_hdr_nwd_sl8;
734  } else if (m_cpr_etf == cprid && hslb == 1 && m_on_etf) {
735  e_mdl = e_etf; _nwd = m_nwd_etf; _hdr_nwd = m_hdr_nwd_etf;
736  } else if (m_cpr_gdl == cprid && hslb == 0 && m_on_gdl) {
737  e_mdl = e_gdl; _nwd = m_nwd_gdl;
738  nclks = m_nclk_gdl; _hdr_nwd = 6;
739  } else {
740  continue;
741  }
742  unsigned nword = raw_trgarray[i]->GetDetectorNwords(j, hslb);
743  if (nword == _hdr_nwd) continue;
744  if (nword != _nwd) {
745  printf("bu:Nword mismatch:nword(%u),expected(%u). eve(%u), %s(0x%x%c), nword(%u)\n",
746  nword, _nwd, _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword);
747  }
748  int* buf = raw_trgarray[i]->GetDetectorBuffer(j, hslb);
749  int i47 = _hdr_nwd + (nclks - 1) * (_nwd - _hdr_nwd) / nclks;
750  if (i47 > int(nword) - 1) {
751  if (m_print_clkcyc_err)
752  printf("bp:data truncation. eve(%u), %s(0x%x%c), nword(%u)\n",
753  _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword);
754  break;
755  }
756  unsigned buf47 = buf[i47];
757  bool break_this_module = false;
758  bool cc_disorder = false;
759 
760  unsigned prev_cc = buf47 & 0xffff;
761  if (e_mdl == e_gdl) {
762  prev_cc = (buf47 >> 4) & 0xfff;
763  }
764  char ccc[400];
765  sprintf(ccc, "i47(%d),buf47(0x%x),%x", i47, buf47, prev_cc);
766  std::string ccs(ccc);
767  for (int clk = 0; clk < nclks; clk++) {
768  unsigned ibuf = _hdr_nwd + clk * (nword - _hdr_nwd) / nclks;
769  if (ibuf > nword - 1) {
770  if (m_print_clkcyc_err)
771  printf("bq:data truncation. eve(%u), %s(0x%x%c), nword(%u)\n",
772  _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword);
773  break_this_module = true;
774  cntr_bad_nwd[e_mdl]++;
775  break;
776  }
777  unsigned ddddcc = buf[ibuf];
778  unsigned dddd = (ddddcc >> 16) & 0xffff;
779  unsigned cc = ddddcc & 0xffff;
780  if (e_mdl == e_gdl) {
781  cc = (ddddcc >> 4) & 0xfff;
782  }
783  h_0->SetBinContent(4 * e_mdl + 4, clk + 1, cc);
784  sprintf(ccc, ",%x", cc);
785  if ((int)e_2d0 <= (int)e_mdl && (int)e_mdl <= (int)e_2d3 &&
786  m_nwd_2ds == 3939/* =2624bit */) {
787  // (downto) = wd i
788  // ( ) = 75 300
789  // ( ) = 76 304
790  // ( ) = 79 316
791  // (79, 72) = 79 318 addr_o
792  // (71, 64) = 79 319 addr_i
793  // (63, 56) = 80 320 nworking
794  // (55, 48) = 80 321 rennum
795  // (47, 40) = 80 322 itarget
796  // (39, 8) = 80 323-326 = cnttrg
797  // ( 7, 0) = 81
798  int i_addr = ibuf + 79; // addr_i and addr_o
799  int val_addr = buf[i_addr];
800  int addr_o = (val_addr >> 8) & 0xff;
801  int addr_i = val_addr & 0xff;
802  sprintf(ccc, ",%x(%d,%d)", cc, addr_i, addr_o);
803  }
804  ccs += ccc;
805  if (e_mdl == e_gdl) {
806  dddd = (ddddcc >> 24);
807  if (dddd != 0xdd) {
808  if (m_print_clkcyc_err)
809  printf("br:dddd not found. eve(%u), %s(0x%x%c), nword(%u)\n",
810  _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword);
811  break_this_module = true;
812  cntr_bad_ddd[e_mdl]++;
813  break;
814  }
815  } else if (dddd != 0xdddd) {
816  if (m_print_clkcyc_err)
817  printf("bs:dddd not found. eve(%u), %s(0x%x%c), nword(%u)\n",
818  _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword);
819  break_this_module = true;
820  cntr_bad_ddd[e_mdl]++;
821  break;
822  }
823  // 0x500 == 1280
824  if (!(cc == prev_cc + 4 || prev_cc == cc + 4 * (nclks - 1) || prev_cc + 0x500 == cc + 4 * (nclks - 1)
825  || cc + 0x500 == prev_cc + 4)) {
826  cc_disorder = true;
827  ccs += "*";
828  }
829  prev_cc = cc;
830  } // clk
831  if (break_this_module) continue; // bad dddd
832  if (cc_disorder) {
833  cntr_bad_odr[e_mdl]++;
834  if (m_print_cc) {
835  printf("bt:ccdisorder: eve(%u), %s(0x%x%c), nword(%u), %s\n",
836  _eveRaw, moduleNames[e_mdl], cprid, 'a' + hslb, nword, ccs.c_str());
837  }
838  } else {
839  cntr_good_odr[e_mdl]++;
840  }
841  } // hslb
842  } // j < raw_trgarray[i]->GetNumEntries()
843  } // i < raw_trgarray.getEntries()
844  }
845 
846  if (! m_histRecord) {
847  h_0->Delete();
848  }
849 }
850 
851 void TRGRAWDATAModule::defineHisto()
852 {
853 }
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:208
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:80
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::TRGRAWDATAModule::c_nModules
static const unsigned int c_nModules
number of modules
Definition: trgrawdataModule.h:177
Belle2::TRGRAWDATAModule::initialize
virtual void initialize() override
initialize
Definition: trgrawdataModule.cc:206
Belle2::TRGRAWDATAModule::event
virtual void event() override
Event.
Definition: trgrawdataModule.cc:290
Belle2::TRGRAWDATAModule::defineHisto
virtual void defineHisto() override
Define Histogram.
Definition: trgrawdataModule.cc:851
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17