Belle II Software development
CDCUnpackerModule.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 <cdc/modules/cdcUnpacker/CDCUnpackerModule.h>
10// DB objects
11#include <cdc/dbobjects/CDCChannelMap.h>
12
13#include <framework/datastore/DataStore.h>
14#include <framework/datastore/RelationArray.h>
15#include <framework/logging/Logger.h>
16#include <framework/utilities/FileSystem.h>
17// framework - Database
18#include <framework/database/DBArray.h>
19#include <tracking/trackFindingCDC/topology/CDCWireTopology.h>
20
21#include <iostream>
22
23using namespace std;
24using namespace Belle2;
25using namespace CDC;
26
27//-----------------------------------------------------------------
28// Register the Module
29//-----------------------------------------------------------------
30REG_MODULE(CDCUnpacker);
31
32//-----------------------------------------------------------------
33// Implementation
34//-----------------------------------------------------------------
35
37{
38 //Set module properties
39 setDescription("CDCUnpacker generates CDCHit from Raw data.");
41
42 addParam("rawCDCName", m_rawCDCName, "Name of the RawCDC List name..", string(""));
43 addParam("cdcRawHitWaveFormName", m_cdcRawHitWaveFormName, "Name of the CDCRawHit (Raw data mode).", string(""));
44 addParam("cdcRawHitName", m_cdcRawHitName, "Name of the CDCRawHit (Suppressed mode).", string(""));
45 addParam("cdcHitName", m_cdcHitName, "Name of the CDCHit List name..", string(""));
46 addParam("fadcThreshold", m_fadcThreshold, "Threshold count.", 1);
47
48 addParam("xmlMapFileName", m_xmlMapFileName, "path+name of the xml file", string(""));
49 addParam("enableStoreCDCRawHit", m_enableStoreCDCRawHit, "Enable to store to the CDCRawHit object", false);
50 addParam("enablePrintOut", m_enablePrintOut, "Enable to print out the data to the terminal", false);
51 addParam("boardIDTrig", m_boardIDTrig, "Board ID for the trigger.", 7);
52 addParam("channelTrig", m_channelTrig, "Channel for the trigger.", 1);
53 addParam("subtractTrigTiming", m_subtractTrigTiming, "Enable to subtract the trigger timing from TDCs.", false);
54 addParam("tdcOffset", m_tdcOffset, "TDC offset (in TDC count).", 0);
55 addParam("enableDatabase", m_enableDatabase, "Enable database to read the channel map.", true);
56 addParam("enable2ndHit", m_enable2ndHit, "Enable 2nd hit timing as a individual CDCHit object.", false);
57 addParam("tdcAuxOffset", m_tdcAuxOffset, "TDC auxiliary offset (in TDC count).", 0);
58 addParam("pedestalSubtraction", m_pedestalSubtraction, "Enable ADC pedestal subtraction.", m_pedestalSubtraction);
59 addParam("relationRawHits", m_relationRawHits, "Enable relation of CDCHits, CDCRawHits, and CDCRawHitWaveForms.", false);
60 addParam("recoverBoardIdError", m_recoverBoardIdError, "Recover boardID errors", true);
61}
62
66
68{
69 m_dataLengthError = false;
70 m_dataSizeError = false;
72 if ((*m_channelMapFromDB).isValid()) {
73 // B2INFO("Channel map is valid");
74 } else {
75 B2FATAL("Channel map is not valid");
76 }
77
78 if (m_enablePrintOut == true) {
79 B2INFO("CDCUnpacker: initialize() Called.");
80 }
81
82 m_rawCDCs.isRequired(m_rawCDCName);
84 m_CDCRawHits.registerInDataStore(m_cdcRawHitName);
85 m_CDCHits.registerInDataStore(m_cdcHitName);
86
87 if (m_relationRawHits == true) {
88 m_CDCHits.registerRelationTo(m_CDCRawHitWaveForms);
89 m_CDCHits.registerRelationTo(m_CDCRawHits);
90
91 // Set default names for the relations.
95
99 }
100
101 if (m_enablePrintOut == true) {
102 B2INFO("CDCUnpacker: " << LogVar("FADC threshold", m_fadcThreshold));
103 }
104
106}
107
109{
110 if (m_enablePrintOut == true) {
111 B2INFO("CDCUnpacker: beginRun() called.");
112 }
113
114
115 loadMap();
117}
118
120{
121 if (m_enablePrintOut == true) {
122 B2INFO("CDCUnpacker: event() started.");
123 }
124
125 // TDC count for the trigger scinti.
126 int tdcCountTrig = m_tdcOffset;
127
129
130 // Create Data objects.
131 m_CDCHits.clear();
132
133 if (m_relationRawHits == true) {
134 RelationArray rawCDCsToCDCHits(m_CDCRawHits, m_CDCHits, m_relCDCRawHitToCDCHitName); // CDCRawHit <-> CDCHit
135 RelationArray rawCDCWFsToCDCHits(m_CDCRawHitWaveForms, m_CDCHits, m_relCDCRawHitWFToCDCHitName); // CDCRawHitWaveForm <-> CDCHit
136 }
137
138 if (m_enableStoreCDCRawHit == true) {
139 m_CDCRawHits.clear();
140 m_CDCRawHitWaveForms.clear();
141 }
142
143 //
144 // Process RawCDC data block.
145 //
146
147 const int nEntries = m_rawCDCs.getEntries();
148
149 B2DEBUG(99, "nEntries of RawCDCs : " << nEntries);
150
151 for (int i = 0; i < nEntries; ++i) {
152 const int subDetectorId = m_rawCDCs[i]->GetNodeID(0);
153 const int iNode = (subDetectorId & 0xFFFFFF);
154 const int nEntriesRawCDC = m_rawCDCs[i]->GetNumEntries();
155
156 B2DEBUG(99, LogVar("nEntries of rawCDC[i]", nEntriesRawCDC));
157
158 for (int j = 0; j < nEntriesRawCDC; ++j) {
159 int trigType = m_rawCDCs[i]->GetTRGType(j); // Get event type of L1 trigger.
160 int nWords[48];
161 int* data32tab[48];
162 int MaxNumOfCh = m_rawCDCs[i]->GetMaxNumOfCh(j);
163 string readoutName;
164 if (MaxNumOfCh == 4) readoutName = "COPPER";
165 else if (MaxNumOfCh == 48) readoutName = "PCIe40";
166 else
167 B2FATAL("CDC UnpackerModule: Invalid value of GetMaxNumOfCh from raw data: " << LogVar("Number of ch: ",
168 m_rawCDCs[i]->GetMaxNumOfCh(j)));
169
170 for (int k = 0; k < MaxNumOfCh; ++k) {
171 nWords[k] = m_rawCDCs[i]->GetDetectorNwords(j, k);
172 if (MaxNumOfCh == 48 && m_rawCDCs[i]->CheckOnlineRemovedDataBit(j, k) == true) { //for error flag in ff55 trailer
173 if (nWords[k] != 0)
174 B2FATAL("The data is not removed for the bad channel (" << j << "," << k << ") with error flag in ff55 trailer! ");
175 }
176 data32tab[k] = (int*)m_rawCDCs[i]->GetDetectorBuffer(j, k);
177 }
178
179 //
180 // Search Data from Finess 0->MaxNumOfCh (4/48 for COPPER/PCIe40).
181 //
182
183 for (int iFiness = 0; iFiness < MaxNumOfCh; ++iFiness) {
184 int* ibuf = data32tab[iFiness];
185 const int nWord = nWords[iFiness];
186 B2DEBUG(99, LogVar("nWords (from " + readoutName + " header)", nWord));
187
188 if (m_enablePrintOut == true) {
189 B2INFO("CDCUnpacker : Print out CDC data block.");
190 printBuffer(ibuf, nWord);
191 }
192
193 const int c_headearWords = 3;
194 if (nWord < c_headearWords) {
195 if (m_enablePrintOut == true) {
196 B2WARNING("CDCUnpacker : No CDC block header.");
197 }
198 continue;
199 }
200
201 if (m_enablePrintOut == true) {
202 B2INFO("CDCUnpacker : RawDataBlock(CDC) : Block # "
203 << LogVar("Block", i)
204 << LogVar("Node", iNode)
205 << LogVar("Finness", iFiness));
206 }
207
208 setCDCPacketHeader(ibuf);
209
210 // Skip invalid boardsIDs
211 if (m_boardId > 300) {
212 B2WARNING("Unrecoverable board " << std::hex << m_boardId);
213 continue;
214 }
215
216 const int dataType = getDataType();
217 const int dataLength = getDataLength() / 4; // Data length in int word (4bytes).
218 const int swDataLength = dataLength * 2; // Data length in short word (2bytes).
219
220
221 if (dataLength != (nWord - c_headearWords)) {
222 if (m_dataSizeError == false) {
223 B2ERROR("Inconsistent data size between " + readoutName + " and CDC FEE."
224 << LogVar("data length", dataLength) << LogVar("nWord", nWord)
225 << LogVar("Node ID", iNode) << LogVar("Finness ID", iFiness));
226 m_dataSizeError = true;
227 } else {
228 B2WARNING("Inconsistent data size between " + readoutName + " and CDC FEE."
229 << LogVar("data length", dataLength) << LogVar("nWord", nWord)
230 << LogVar("Node ID", iNode) << LogVar("Finness ID", iFiness));
231 }
232 continue;
233 }
234 if (m_enablePrintOut == true) {
235 B2INFO("CDCUnpacker : " << LogVar("Data size", dataLength));
236 }
237
238 const int board = getBoardId();
239 const int trgNumber = getTriggerNumber();
240 const int trgTime = getTriggerTime();
241
242 if (m_enablePrintOut == true) {
243 B2INFO("CDCUnpacker : " << LogVar("Board", board) << LogVar("Trigger number", trgNumber)
244 << LogVar("Trigger time ", trgTime));
245 }
246
247 //
248 // Check the data type (raw or suppressed mode?).
249 //
250
251 if (dataType == 1) { // Raw data mode.
252 if (m_enablePrintOut == true) {
253 B2INFO("CDCUnpacker : Raw data mode.");
254 }
255
256 m_buffer.clear();
257
258 for (int it = 0; it < dataLength; ++it) {
259 int index = it + c_headearWords;
260
261 m_buffer.push_back(static_cast<unsigned short>((ibuf[index] & 0xffff0000) >> 16));
262 m_buffer.push_back(static_cast<unsigned short>(ibuf[index] & 0xffff));
263 }
264
265 const int fadcTdcChannels = 48; // Total channels of FADC or TDC.
266 const int nSamples = swDataLength / (2 * fadcTdcChannels); // Number of samplings.
267
268 std::vector<unsigned short> fadcs;
269 std::vector<unsigned short> tdcs;
270
271 for (int iCh = 0; iCh < fadcTdcChannels; ++iCh) {
272 const int offset = fadcTdcChannels;
273 unsigned short fadcSum = 0; // FADC sum below threshold.
274 unsigned short tdc1 = 0x7fff; // Fastest TDC.
275 unsigned short tdc2 = 0x7fff; // 2nd fastest TDC.
276
277 for (int iSample = 0; iSample < nSamples; ++iSample) {
278 // FADC value for each sample and channel.
279
280 unsigned short fadc = m_buffer.at(iCh + 2 * fadcTdcChannels * iSample);
281
282 if (fadc > m_fadcThreshold) {
283 fadcSum += fadc;
284 }
285 // TDC count for each sample and channel.
286
287 unsigned short tdc = m_buffer.at(iCh + 2 * fadcTdcChannels * iSample + offset) & 0x7fff;
288 unsigned short tdcIsValid = (m_buffer.at(iCh + 2 * fadcTdcChannels * iSample + offset) & 0x8000) >> 15;
289 if (tdcIsValid == 1) { // good tdc data.
290 if (tdc > 0) { // if hit timng is 0, skip.
291 if (tdc < tdc1) {
292 tdc2 = tdc1; // 2nd fastest hit
293 tdc1 = tdc; // fastest hit.
294 }
295 }
296 }
297
298 fadcs.push_back(fadc);
299 tdcs.push_back(tdc);
300 if (m_enableStoreCDCRawHit == true) {
301 // Store to the CDCRawHitWaveForm object.
302 const unsigned short status = 0;
303 m_CDCRawHitWaveForms.appendNew(status, trgNumber, iNode, iFiness, board, iCh, iSample, trgTime, fadc, tdc);
304 }
305
306 }
307
308 if (tdc1 != 0x7fff) {
309 // Store to the CDCHit object.
310 const WireID wireId = getWireID(board, iCh);
311 if (wireTopology.isValidWireID(wireId)) {
312 if (trgTime < tdc1) {
313 tdc1 = (trgTime | 0x8000) - tdc1;
314 } else {
315 tdc1 = trgTime - tdc1;
316 }
317 CDCHit* firstHit = m_CDCHits.appendNew(tdc1, fadcSum, wireId);
318 if (m_enable2ndHit == true) {
319 CDCHit* secondHit = m_CDCHits.appendNew(tdc2, fadcSum, wireId);
320 secondHit->setOtherHitIndices(firstHit);
321 secondHit->set2ndHitFlag();
322 }
323 if (m_enableStoreCDCRawHit == true) {
324 if (m_relationRawHits == true) {
325 for (int iSample = 0; iSample < nSamples; ++iSample) {
326 m_CDCHits[m_CDCHits.getEntries() - 1]->addRelationTo(m_CDCRawHitWaveForms[m_CDCRawHitWaveForms.getEntries() - 1 + iSample -
327 (nSamples - 1) ]);
328 }
329 }
330 }
331 } else {
332 B2WARNING("Skip invalid wire board, channel: " << board << ", " << iCh);
333 }
334 }
335
336
337
338
339 if (m_enablePrintOut == true) {
340 //
341 // Print out (for debug).
342 //
343
344 printf("FADC ch %2d : ", iCh);
345 for (int iSample = 0; iSample < nSamples; ++iSample) {
346 printf("%4x ", fadcs.at(iSample));
347 }
348 printf("\n");
349
350 printf("TDC ch %2d : ", iCh);
351 for (int iSample = 0; iSample < nSamples; ++iSample) {
352 printf("%4x ", tdcs.at(iSample));
353 }
354 printf("\n");
355 }
356
357 }
358
359 } else if (dataType == 2) { // Suppressed mode.
360 if (m_enablePrintOut == true) {
361 B2INFO("CDCUnpacker : Suppressed mode.");
362 }
363
364 // convert int array -> short array.
365 m_buffer.clear();
366 for (int it = 0; it < dataLength; ++it) {
367 int index = it + c_headearWords;
368 m_buffer.push_back(static_cast<unsigned short>((ibuf[index] & 0xffff0000) >> 16));
369 m_buffer.push_back(static_cast<unsigned short>(ibuf[index] & 0xffff));
370 }
371
372 const size_t bufSize = m_buffer.size();
373 for (size_t it = 0; it < bufSize;) {
374 unsigned short header = m_buffer.at(it); // Header.
375 unsigned short ch = (header & 0xff00) >> 8; // Channel ID in FE.
376 unsigned short length = (header & 0xff) / 2; // Data length in short word.
377
378 if (header == 0xff02) {
379 it++;
380 continue;
381 }
382
383 if (!((length == 4) || (length == 5))) {
384 if (m_dataLengthError == false) {
385 B2ERROR("CDCUnpacker : data length should be 4 or 5 words."
386 << LogVar("data length", length)
387 << LogVar("board id", board)
388 << LogVar("channel", ch));
389 m_dataLengthError = true;
390 } else {
391 B2WARNING("CDCUnpacker : data length should be 4 or 5 words."
392 << LogVar("data length", length)
393 << LogVar("board id", board)
394 << LogVar("channel", ch));
395 }
396 break;
397 }
398
399 unsigned short tot = m_buffer.at(it + 1); // Time over threshold.
400 unsigned short fadcSum = m_buffer.at(it + 2); // FADC sum.
401
402 if (m_pedestalSubtraction == true) {
403 int diff = fadcSum - (*m_adcPedestalFromDB)->getPedestal(board, ch);
404 if (diff <= m_fadcThreshold) {
405 fadcSum = 0;
406 } else {
407 fadcSum = static_cast<unsigned short>(diff);
408 }
409 }
410 unsigned short tdc1 = 0; // TDC count.
411 unsigned short tdc2 = 0; // 2nd TDC count.
412 unsigned short tdcFlag = 0; // Multiple hit or not (1 for multi hits, 0 for single hit).
413
414 if (length == 4) {
415 tdc1 = m_buffer.at(it + 3);
416 } else if (length == 5) {
417 tdc1 = m_buffer.at(it + 3);
418 tdc2 = m_buffer.at(it + 4) & 0x7fff;
419 tdcFlag = (m_buffer.at(it + 4) & 0x8000) >> 15;
420 } else {
421 B2ERROR("CDCUnpacker : Undefined data length (should be 4 or 5 short words) ");
422 }
423
424 if (ch >= 48) {
425 B2WARNING("Invalid channel "
426 << LogVar("channel", ch)
427 << LogVar("board", board)
428 << LogVar("buffer total size", m_buffer.size())
429 << LogVar("length", length)
430 << LogVar("tdc", tdc1)
431 << LogVar("adc", fadcSum)
432 << LogVar("tot", tot)
433 );
434 it += length;
435 continue;
436 }
437
438 if (m_enablePrintOut == true) {
439 printf("%4x %4x %4x %4x %4x %4x %4x \n", ch, length, tot, fadcSum, tdc1, tdc2, tdcFlag);
440 }
441 if (length == 4 || length == 5) {
442
443 // const unsigned short status = 0;
444 const unsigned short status = trigType; // temporally trigger type is stored, here.
445 // Store to the CDCHit.
446 const WireID wireId = getWireID(board, ch);
447
448 if (isValidBoardChannel(wireId)) {
449 if (wireTopology.isValidWireID(wireId)) {
450
451 if (board == m_boardIDTrig && ch == m_channelTrig) {
452 tdcCountTrig = tdc1;
453 } else {
454 CDCHit* firstHit = m_CDCHits.appendNew(tdc1, fadcSum, wireId,
455 0, tot);
456 if (length == 5) {
457 if (m_enable2ndHit == true) {
458 CDCHit* secondHit = m_CDCHits.appendNew(tdc2, fadcSum, wireId,
459 0, tot);
460 secondHit->setOtherHitIndices(firstHit);
461 secondHit->set2ndHitFlag();
462 }
463 }
464 }
465
466 if (m_enableStoreCDCRawHit == true) {
467 // Store to the CDCRawHit object.
468 if (m_relationRawHits == true) {
469 CDCRawHit* rawHit = m_CDCRawHits.appendNew(status, trgNumber, iNode, iFiness, board, ch,
470 trgTime, fadcSum, tdc1, tdc2, tot);
471 m_CDCHits[m_CDCHits.getEntries() - 1]->addRelationTo(rawHit);
472 if (m_enable2ndHit == true) {
473 m_CDCHits[m_CDCHits.getEntries() - 2]->addRelationTo(rawHit);
474 }
475 } else {
476 m_CDCRawHits.appendNew(status, trgNumber, iNode, iFiness, board, ch,
477 trgTime, fadcSum, tdc1, tdc2, tot);
478 }
479 }
480 } else {
481 B2WARNING("Skip invalid wire board, channel: " << board << ", " << ch);
482 }
483 } else {
484 B2WARNING("Undefined board id is fired: " << LogVar("board id", board) << " " << LogVar("channel", ch));
485 }
486 }
487 it += length;
488 }
489
490 } else {
491 B2WARNING("CDCUnpacker : Undefined CDC Data Block : Block # " << LogVar("block id", i));
492 }
493 }
494 }
495 }
496
497 //
498 // t0 correction w.r.t. the timing of the trigger counter.
499 //
500 if (m_subtractTrigTiming == true) {
501 for (auto& hit : m_CDCHits) {
502 int tdc = hit.getTDCCount();
503 if (hit.is2ndHit()) {
504 if (tdc != 0) {
505 tdc = tdc - (tdcCountTrig - m_tdcOffset);
506 }
507 } else {
508 tdc = tdc - (tdcCountTrig - m_tdcOffset);
509 }
510
511 tdc -= m_tdcAuxOffset;
512 hit.setTDCCount(static_cast<unsigned short>(tdc));
513 }
514 }
515}
516
518{
519 if (m_enablePrintOut == true) {
520 B2INFO("CDCUnpacker : End run.");
521 }
522}
523
525{
526 if (m_enablePrintOut == true) {
527 B2INFO("CDCUnpacker : Terminated.");
528 }
529
532}
533
534
535WireID CDCUnpackerModule::getWireID(int iBoard, int iCh) const
536{
537 return m_map[iBoard][iCh];
538}
539
541{
542
543 if (m_enableDatabase == false) {
544
545 // Read the channel map from the local text.
546 std::string fileName = FileSystem::findFile(m_xmlMapFileName);
547 std::cout << fileName << std::endl;
548 if (fileName == "") {
549 B2ERROR("CDC unpacker can't find a filename: " << LogVar("file name", fileName));
550 exit(1);
551 }
552
553
554 ifstream ifs;
555 ifs.open(fileName.c_str());
556 int isl;
557 int icl;
558 int iw;
559 int iBoard;
560 int iCh;
561
562 while (!ifs.eof()) {
563 ifs >> isl >> icl >> iw >> iBoard >> iCh;
564 const WireID wireId(isl, icl, iw);
565 m_map[iBoard][iCh] = wireId;
566 }
567 } else {
568 for (const auto& cm : (*m_channelMapFromDB)) {
569 const int isl = cm.getISuperLayer();
570 const int il = cm.getILayer();
571 const int iw = cm.getIWire();
572 const int iBoard = cm.getBoardID();
573 const int iCh = cm.getBoardChannel();
574 const WireID wireId(isl, il, iw);
575 m_map[iBoard][iCh] = wireId;
576 }
577 }
578}
579
581{
582 if (m_pedestalSubtraction == true) {
584 if (!(*m_adcPedestalFromDB).isValid()) {
585 m_pedestalSubtraction = false;
586 }
587 }
588
589}
590
591void CDCUnpackerModule::printBuffer(int* buf, int nwords)
592{
593
594 for (int j = 0; j < nwords; ++j) {
595 printf(" %.8x", buf[j]);
596 if ((j + 1) % 10 == 0) {
597 printf("\n");
598 }
599 }
600 printf("\n");
601
602 return;
603}
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition CDCHit.h:40
void set2ndHitFlag()
Setter for 2nd hit flag.
Definition CDCHit.h:113
void setOtherHitIndices(CDCHit *otherHit)
Setter for the other hit indices.
Definition CDCHit.h:147
The CDCRawHit (suppressed mode) class.
Definition CDCRawHit.h:25
StoreArray< RawCDC > m_rawCDCs
Input array for CDC Raw.
bool m_enableDatabase
Enable/Disable to read the channel map from the database.
int m_boardId
Front end board ID.
std::vector< unsigned short > m_buffer
Short ward buffer of CDC event block.
int m_channelTrig
Channel for the trigger.
bool m_dataSizeError
True if data size error between CDCFE and COPPER has been already reported.
std::string m_relCDCRawHitWFToCDCHitName
Relation name between CDCRawHitWaveForm and CDCHit.
std::string m_rawCDCName
Name of the RawCDC dataobject (suppressed mode).
void initialize() override
Initializes the Module.
DBArray< CDCChannelMap > * m_channelMapFromDB
Channel map retrieved from DB.
StoreArray< CDCRawHitWaveForm > m_CDCRawHitWaveForms
Raw hit waveforms.
std::string m_relCDCRawHitToCDCHitName
Relation name between CDCRawHit and CDCHit.
void printBuffer(int *buf, int nwords)
Print out the CDC data block in hex.
int getTriggerNumber()
Getter for trigger number.
void event() override
Event action (main routine).
StoreArray< CDCRawHit > m_CDCRawHits
Raw hits.
bool m_subtractTrigTiming
Enable/Disable to subtract the trigger timing from TDCs.
bool m_dataLengthError
True if data length error has been already reported.
void endRun() override
End run action.
void terminate() override
Termination action.
int getTriggerTime()
Getter for trigger time in nsec.
int m_tdcOffset
TDC offset (nsec).
std::string m_xmlMapFileName
Name of the assignment map of FE board channel to the cell.
WireID m_map[300][48]
Assignment map of FE board channel to the cell.
int getDataType()
Getter for CDC data mode.
std::string m_cdcRawHitName
Name of the CDCRawHit dataobject (suppressed mode).
bool m_pedestalSubtraction
Whether pedestal is subtracted (true) or not (false).
void beginRun() override
Begin run action.
bool m_relationRawHits
True if add relation of CDCHits, CDCRawHits, and CDCRawHitWaveForms.
bool m_recoverBoardIdError
Recover boardID error if true, skip information otherwise.
DBObjPtr< CDCADCDeltaPedestals > * m_adcPedestalFromDB
ADC delta pedestal.
int m_boardIDTrig
Board ID for the trigger.
bool m_enableStoreCDCRawHit
Enable/Disable to store CDCRawHit.
int m_tdcAuxOffset
TDC auxiliary offset (nsec).
int getDataLength()
Getter for data length in byte.
void loadMap()
Load FE channel to cell ID map.
WireID getWireID(int iBoard, int iCh) const
Getter of Wire ID.
CDCUnpackerModule()
Constructor of the module.
bool m_enablePrintOut
Enable/Disable to print out the data to the terminal.
bool isValidBoardChannel(WireID wireId)
Check if the hit wire is valid or not.
std::string m_cdcRawHitWaveFormName
Name of the CDCRawHit dataobject (raw data mode).
void setCDCPacketHeader(const int *buf)
Set CDC Packet header.
virtual ~CDCUnpackerModule()
Destructor of the module.
bool m_enable2ndHit
Enable/Disable to 2nd hit output.
int getBoardId()
Getter for FE board ID.
std::string m_cdcHitName
Tree name of the CDCHit object.
void setADCPedestal()
Set DBobject of ADC delta pedestal.
StoreArray< CDCHit > m_CDCHits
CDC hits.
Class for accessing arrays of objects in the database.
Definition DBArray.h:26
Class for accessing objects in the database.
Definition DBObjPtr.h:21
static std::string relationName(const std::string &fromName, const std::string &toName, std::string const &namedRelation="")
Return storage name for a relation between two arrays of the given names.
Definition DataStore.h:180
static std::string arrayName(const TClass *t, const std::string &name)
Return the storage name for an object of the given TClass and name.
Definition DataStore.cc:163
static std::string findFile(const std::string &path, bool silent=false)
Search for given file or directory in local or central release directory, and return absolute path if...
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
Module()
Constructor.
Definition Module.cc:30
@ 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
Low-level class to create/modify relations between StoreArrays.
Class representing the sense wire arrangement in the whole of the central drift chamber.
static CDCWireTopology & getInstance()
Getter for the singleton instance of the wire topology.
bool isValidWireID(const WireID &wireID) const
Checks the validity of a wireID convenience object.
Class to identify a wire inside the CDC.
Definition WireID.h:34
Class to store variables with their name which were sent to the logging service.
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:559
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Abstract base class for different kinds of events.
STL namespace.