CbmRoot
CbmDeviceMcbmUnpack.cxx
Go to the documentation of this file.
1 
8 #include "CbmDeviceMcbmUnpack.h"
9 #include "CbmMQDefs.h"
10 
11 #include "CbmFlesCanvasTools.h"
12 #include "CbmMcbm2018UnpackerAlgoMuch.h"
13 #include "CbmMcbm2018UnpackerAlgoPsd.h"
14 #include "CbmMcbm2018UnpackerAlgoRich.h"
15 #include "CbmMcbm2018UnpackerAlgoSts.h"
16 #include "CbmMcbm2018UnpackerAlgoTof.h"
17 #include "CbmMcbm2018UnpackerAlgoTrdR.h"
18 #include "TimesliceMetaData.h"
19 
20 #include "StorableTimeslice.hpp"
21 
22 #include "BoostSerializer.h"
23 #include "FairMQLogger.h"
24 #include "FairMQProgOptions.h" // device->fConfig
25 #include "FairParGenericSet.h"
26 #include "RootSerializer.h"
27 
28 #include "TCanvas.h"
29 #include "TFile.h"
30 #include "TH1.h"
31 #include "TList.h"
32 #include "TNamed.h"
33 
34 #include <array>
35 #include <iomanip>
36 #include <string>
37 
38 #include <boost/archive/binary_iarchive.hpp>
39 #include <boost/serialization/utility.hpp>
40 
41 #include <stdexcept>
42 struct InitTaskError : std::runtime_error {
43  using std::runtime_error::runtime_error;
44 };
45 
46 using namespace std;
47 
48 Bool_t bMcbm2018MonitorTaskT0ResetHistos = kFALSE;
49 
50 CbmDeviceMcbmUnpack::CbmDeviceMcbmUnpack() {
51  fUnpAlgoSts = new CbmMcbm2018UnpackerAlgoSts();
52  fUnpAlgoMuch = new CbmMcbm2018UnpackerAlgoMuch();
53  fUnpAlgoTrd = new CbmMcbm2018UnpackerAlgoTrdR();
54  fUnpAlgoTof = new CbmMcbm2018UnpackerAlgoTof();
55  fUnpAlgoRich = new CbmMcbm2018UnpackerAlgoRich();
56  fUnpAlgoPsd = new CbmMcbm2018UnpackerAlgoPsd();
57 }
58 
59 void CbmDeviceMcbmUnpack::InitTask() try {
61  LOG(info) << "Init options for CbmDeviceMcbmUnpack.";
62  fbIgnoreOverlapMs = fConfig->GetValue<bool>("IgnOverMs");
63  fvsSetTimeOffs = fConfig->GetValue<std::vector<std::string>>("SetTrigWin");
64  fsChannelNameDataInput = fConfig->GetValue<std::string>("TsNameIn");
65  fsChannelNameDataOutput = fConfig->GetValue<std::string>("TsNameOut");
67  fsAllowedChannels[0] = fsChannelNameDataInput;
68 
69  // Get the information about created channels from the device
70  // Check if the defined channels from the topology (by name)
71  // are in the list of channels which are possible/allowed
72  // for the device
73  // The idea is to check at initilization if the devices are
74  // properly connected. For the time beeing this is done with a
75  // nameing convention. It is not avoided that someone sends other
76  // data on this channel.
77  //logger::SetLogLevel("INFO");
78 
79  int noChannel = fChannels.size();
80  LOG(info) << "Number of defined channels: " << noChannel;
81  for (auto const& entry : fChannels) {
82  LOG(info) << "Channel name: " << entry.first;
83  if (std::string::npos != entry.first.find(fsChannelNameDataInput)) {
84  if (!IsChannelNameAllowed(entry.first))
85  throw InitTaskError("Channel name does not match.");
86  OnData(entry.first, &CbmDeviceMcbmUnpack::HandleData);
87  } // if( entry.first.find( "ts" )
88  } // for( auto const &entry : fChannels )
89  InitContainers();
90 } catch (InitTaskError& e) {
91  LOG(error) << e.what();
92  // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
93  cbm::mq::ChangeState(this, cbm::mq::Transition::ErrorFound);
94 }
95 
96 bool CbmDeviceMcbmUnpack::IsChannelNameAllowed(std::string channelName) {
97  for (auto const& entry : fsAllowedChannels) {
98  std::size_t pos1 = channelName.find(entry);
99  if (pos1 != std::string::npos) {
100  const vector<std::string>::const_iterator pos =
101  std::find(fsAllowedChannels.begin(), fsAllowedChannels.end(), entry);
102  const vector<std::string>::size_type idx =
103  pos - fsAllowedChannels.begin();
104  LOG(info) << "Found " << entry << " in " << channelName;
105  LOG(info) << "Channel name " << channelName
106  << " found in list of allowed channel names at position "
107  << idx;
108  return true;
109  } // if (pos1!=std::string::npos)
110  } // for(auto const &entry : fsAllowedChannels)
111  LOG(info) << "Channel name " << channelName
112  << " not found in list of allowed channel names.";
113  LOG(error) << "Stop device.";
114  return false;
115 }
116 
117 Bool_t CbmDeviceMcbmUnpack::InitContainers() {
118  LOG(info) << "Init parameter containers for CbmDeviceMcbmUnpack.";
119 
120  if (kFALSE == InitParameters(fUnpAlgoSts->GetParList())) return kFALSE;
121  if (kFALSE == InitParameters(fUnpAlgoMuch->GetParList())) return kFALSE;
122  if (kFALSE == InitParameters(fUnpAlgoTrd->GetParList())) return kFALSE;
123  if (kFALSE == InitParameters(fUnpAlgoTof->GetParList())) return kFALSE;
124  if (kFALSE == InitParameters(fUnpAlgoRich->GetParList())) return kFALSE;
125  if (kFALSE == InitParameters(fUnpAlgoPsd->GetParList())) return kFALSE;
126 
128  fUnpAlgoSts->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
129  fUnpAlgoMuch->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
130  fUnpAlgoTrd->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
131  fUnpAlgoTof->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
132  fUnpAlgoRich->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
133  fUnpAlgoPsd->SetIgnoreOverlapMs(fbIgnoreOverlapMs);
134 
136  for (std::vector<std::string>::iterator itStrOffs = fvsSetTimeOffs.begin();
137  itStrOffs != fvsSetTimeOffs.end();
138  ++itStrOffs) {
139  size_t charPosDel = (*itStrOffs).find(',');
140  if (std::string::npos == charPosDel) {
141  LOG(info)
142  << "CbmDeviceMcbmUnpack::InitContainers => "
143  << "Trying to set trigger window with invalid option pattern, ignored! "
144  << " (Should be ECbmModuleId,dWinBeg,dWinEnd but instead found "
145  << (*itStrOffs) << " )";
146  } // if( std::string::npos == charPosDel )
147 
149  std::string sSelDet = (*itStrOffs).substr(0, charPosDel);
151  charPosDel++;
152  Double_t dOffset = std::stod((*itStrOffs).substr(charPosDel));
153 
154  if ("kSTS" == sSelDet) {
155  fUnpAlgoSts->SetTimeOffsetNs(dOffset);
156  } // if( "kSTS" == sSelDet )
157  else if ("kMUCH" == sSelDet) {
158  fUnpAlgoMuch->SetTimeOffsetNs(dOffset);
159  } // else if( "kMUCH" == sSelDet )
160  else if ("kTRD" == sSelDet) {
161  fUnpAlgoTrd->SetTimeOffsetNs(dOffset);
162  } // else if( "kTRD" == sSelDet )
163  else if ("kTOF" == sSelDet) {
164  fUnpAlgoTof->SetTimeOffsetNs(dOffset);
165  } // else if( "kTOF" == sSelDet )
166  else if ("kRICH" == sSelDet) {
167  fUnpAlgoRich->SetTimeOffsetNs(dOffset);
168  } // else if( "kRICH" == sSelDet )
169  else if ("kPSD" == sSelDet) {
170  fUnpAlgoPsd->SetTimeOffsetNs(dOffset);
171  } // else if( "kPSD" == sSelDet )
172  else {
173  LOG(info) << "CbmDeviceMcbmUnpack::InitContainers => Trying to set time "
174  "offset for unsupported detector, ignored! "
175  << (sSelDet);
176  continue;
177  } // else of detector enum detection
178  } // for( std::vector< std::string >::iterator itStrAdd = fvsAddDet.begin(); itStrAdd != fvsAddDet.end(); ++itStrAdd )
179 
180 
182  fUnpAlgoSts->SetBinningFwFlag(kTRUE);
184  fUnpAlgoMuch->SetBinningFwFlag(kTRUE);
185 
186  Bool_t initOK = fUnpAlgoSts->InitContainers();
187  initOK &= fUnpAlgoMuch->InitContainers();
188  initOK &= fUnpAlgoTrd->InitContainers();
189  initOK &= fUnpAlgoTof->InitContainers();
190  initOK &= fUnpAlgoRich->InitContainers();
191  initOK &= fUnpAlgoPsd->InitContainers();
192 
195  initOK &= fUnpAlgoTrd->SetDigiOutputPointer(&(fUnpAlgoTrd->GetVector()));
196 
197  // Bool_t initOK = fMonitorAlgo->ReInitContainers();
198 
199  return initOK;
200 }
201 
202 Bool_t CbmDeviceMcbmUnpack::InitParameters(TList* fParCList) {
203  for (int iparC = 0; iparC < fParCList->GetEntries(); iparC++) {
204  FairParGenericSet* tempObj = (FairParGenericSet*) (fParCList->At(iparC));
205  fParCList->Remove(tempObj);
206  std::string paramName {tempObj->GetName()};
207  // NewSimpleMessage creates a copy of the data and takes care of its destruction (after the transfer takes place).
208  // Should only be used for small data because of the cost of an additional copy
209 
210  // Her must come the proper Runid
211  std::string message = paramName + ",111";
212  LOG(info) << "Requesting parameter container " << paramName
213  << ", sending message: " << message;
214 
215  FairMQMessagePtr req(NewSimpleMessage(message));
216  FairMQMessagePtr rep(NewMessage());
217 
218  FairParGenericSet* newObj = nullptr;
219 
220  if (Send(req, "parameters") > 0) {
221  if (Receive(rep, "parameters") >= 0) {
222  if (0 != rep->GetSize()) {
223  CbmMQTMessage tmsg(rep->GetData(), rep->GetSize());
224  newObj =
225  static_cast<FairParGenericSet*>(tmsg.ReadObject(tmsg.GetClass()));
226  LOG(info) << "Received unpack parameter from the server:";
227  newObj->print();
228  } // if( 0 != rep->GetSize() )
229  else {
230  LOG(error) << "Received empty reply. Parameter not available";
231  return kFALSE;
232  } // else of if( 0 != rep->GetSize() )
233  } // if( Receive( rep, "parameters" ) >= 0)
234  } // if( Send(req, "parameters") > 0 )
235  fParCList->AddAt(newObj, iparC);
236  delete tempObj;
237  } // for( int iparC = 0; iparC < fParCList->GetEntries(); iparC++ )
238 
239  return kTRUE;
240 }
241 
242 // handler is called whenever a message arrives on "data", with a reference to the message and a sub-channel index (here 0)
243 bool CbmDeviceMcbmUnpack::HandleData(FairMQMessagePtr& msg, int /*index*/) {
244  fulNumMessages++;
245  LOG(debug) << "Received message number " << fulNumMessages << " with size "
246  << msg->GetSize();
247 
248  if (0 == fulNumMessages % 10000)
249  LOG(info) << "Received " << fulNumMessages << " messages";
250 
251  std::string msgStr(static_cast<char*>(msg->GetData()), msg->GetSize());
252  std::istringstream iss(msgStr);
253  boost::archive::binary_iarchive inputArchive(iss);
254 
256  fles::StorableTimeslice ts {0};
257  inputArchive >> ts;
258 
260  if (-1.0 == fdTsCoreSizeInNs) {
261  fuNbCoreMsPerTs = ts.num_core_microslices();
262  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
263  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
264  fdTsOverSizeInNs = fdMsSizeInNs * (fuNbOverMsPerTs);
265  fdTsFullSizeInNs = fdTsCoreSizeInNs + fdTsOverSizeInNs;
266  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
267  << " Core MS and " << fuNbOverMsPerTs
268  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
269  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
270  } // if( -1.0 == fdTsCoreSizeInNs )
271 
272  fTsMetaData = new TimesliceMetaData(
273  ts.descriptor(0, 0).idx, fdTsCoreSizeInNs, fdTsOverSizeInNs, ts.index());
274 
276  DoUnpack(ts, 0);
277 
279  if (!SendUnpData()) return false;
280 
281  delete fTsMetaData;
282 
284  fUnpAlgoSts->ClearVector();
285  fUnpAlgoMuch->ClearVector();
286  fUnpAlgoTrd->ClearVector();
287  fUnpAlgoTof->ClearVector();
288  fUnpAlgoRich->ClearVector();
289  fUnpAlgoPsd->ClearVector();
290 
292  fUnpAlgoSts->ClearErrorVector();
293  fUnpAlgoMuch->ClearErrorVector();
294  fUnpAlgoTrd->ClearErrorVector();
295  fUnpAlgoTof->ClearErrorVector();
296  fUnpAlgoRich->ClearErrorVector();
297  fUnpAlgoPsd->ClearErrorVector();
298 
299  return true;
300 }
301 
302 bool CbmDeviceMcbmUnpack::SendUnpData() {
303 
305  /*
306  std::stringstream ossTsMeta;
307  boost::archive::binary_oarchive oaTsMeta(ossTsMeta);
308  oaTsMeta << *(fTsMetaData);
309  std::string* strMsgTsMetaE = new std::string(ossTsMeta.str());
310 */
311  FairMQMessagePtr messTsMeta(NewMessage());
312  Serialize<RootSerializer>(*messTsMeta, fTsMetaData);
313 
314  std::stringstream ossSts;
315  boost::archive::binary_oarchive oaSts(ossSts);
316  oaSts << fUnpAlgoSts->GetVector();
317  std::string* strMsgSts = new std::string(ossSts.str());
318 
319  std::stringstream ossMuch;
320  boost::archive::binary_oarchive oaMuch(ossMuch);
321  oaMuch << fUnpAlgoMuch->GetVector();
322  std::string* strMsgMuch = new std::string(ossMuch.str());
323 
324  std::stringstream ossTrd;
325  boost::archive::binary_oarchive oaTrd(ossTrd);
326  oaTrd << fUnpAlgoTrd->GetVector();
327  std::string* strMsgTrd = new std::string(ossTrd.str());
328 
330  std::vector<CbmTofDigi>& vDigiTofT0 = fUnpAlgoTof->GetVector();
331  std::vector<CbmTofDigi> vDigiTof = {};
332  std::vector<CbmTofDigi> vDigiT0 = {};
333 
334  for (auto digi : vDigiTofT0) {
335  if (fuDigiMaskedIdT0 == (digi.GetAddress() & fuDigiMaskId)) {
337  vDigiT0.emplace_back(digi);
338  } // if( fuDigiMaskedIdT0 == ( digi.GetAddress() & fuDigiMaskId ) )
339  else {
341  vDigiTof.emplace_back(digi);
342  } // else of if( fuDigiMaskedIdT0 == ( digi.GetAddress() & fuDigiMaskId ) )
343  } // for( auto digi: vDigi )
344 
345  std::stringstream ossTof;
346  boost::archive::binary_oarchive oaTof(ossTof);
347  oaTof << vDigiTof;
348  std::string* strMsgTof = new std::string(ossTof.str());
349 
350  std::stringstream ossT0;
351  boost::archive::binary_oarchive oaT0(ossT0);
352  oaT0 << vDigiT0;
353  std::string* strMsgT0 = new std::string(ossT0.str());
354 
355  std::stringstream ossRich;
356  boost::archive::binary_oarchive oaRich(ossRich);
357  oaRich << fUnpAlgoRich->GetVector();
358  std::string* strMsgRich = new std::string(ossRich.str());
359 
360  std::stringstream ossPsd;
361  boost::archive::binary_oarchive oaPsd(ossPsd);
362  oaPsd << fUnpAlgoPsd->GetVector();
363  std::string* strMsgPsd = new std::string(ossPsd.str());
364 
365  FairMQParts parts;
366 
367  parts.AddPart(std::move(messTsMeta));
368  /*
369  parts.AddPart( NewMessage( const_cast< char * >( strMsgTsMetaE->c_str() ), // data
370  strMsgTsMetaE->length(), // size
371  []( void* , void* object ){ delete static_cast< std::string * >( object ); },
372  strMsgTsMetaE
373  )
374  ); // object that manages the data
375 */
376 
377  parts.AddPart(NewMessage(
378  const_cast<char*>(strMsgT0->c_str()), // data
379  strMsgT0->length(), // size
380  [](void*, void* object) { delete static_cast<std::string*>(object); },
381  strMsgT0)); // object that manages the data
382 
383  parts.AddPart(NewMessage(
384  const_cast<char*>(strMsgSts->c_str()), // data
385  strMsgSts->length(), // size
386  [](void*, void* object) { delete static_cast<std::string*>(object); },
387  strMsgSts)); // object that manages the data
388 
389  parts.AddPart(NewMessage(
390  const_cast<char*>(strMsgMuch->c_str()), // data
391  strMsgMuch->length(), // size
392  [](void*, void* object) { delete static_cast<std::string*>(object); },
393  strMsgMuch)); // object that manages the data
394 
395  parts.AddPart(NewMessage(
396  const_cast<char*>(strMsgTrd->c_str()), // data
397  strMsgTrd->length(), // size
398  [](void*, void* object) { delete static_cast<std::string*>(object); },
399  strMsgTrd)); // object that manages the data
400 
401  parts.AddPart(NewMessage(
402  const_cast<char*>(strMsgTof->c_str()), // data
403  strMsgTof->length(), // size
404  [](void*, void* object) { delete static_cast<std::string*>(object); },
405  strMsgTof)); // object that manages the data
406 
407  parts.AddPart(NewMessage(
408  const_cast<char*>(strMsgRich->c_str()), // data
409  strMsgRich->length(), // size
410  [](void*, void* object) { delete static_cast<std::string*>(object); },
411  strMsgRich)); // object that manages the data
412 
413  parts.AddPart(NewMessage(
414  const_cast<char*>(strMsgPsd->c_str()), // data
415  strMsgPsd->length(), // size
416  [](void*, void* object) { delete static_cast<std::string*>(object); },
417  strMsgPsd)); // object that manages the data
418 
419  if (Send(parts, fsChannelNameDataOutput) < 0) {
420  LOG(error) << "Problem sending data to " << fsChannelNameDataOutput;
421  return false;
422  }
423 
424  return true;
425 }
426 
427 
428 CbmDeviceMcbmUnpack::~CbmDeviceMcbmUnpack() {
429  if (nullptr != fUnpAlgoSts) delete fUnpAlgoSts;
430  if (nullptr != fUnpAlgoMuch) delete fUnpAlgoMuch;
431  if (nullptr != fUnpAlgoTrd) delete fUnpAlgoTrd;
432  if (nullptr != fUnpAlgoTof) delete fUnpAlgoTof;
433  if (nullptr != fUnpAlgoRich) delete fUnpAlgoRich;
434  if (nullptr != fUnpAlgoPsd) delete fUnpAlgoPsd;
435 }
436 
437 
438 Bool_t CbmDeviceMcbmUnpack::DoUnpack(const fles::Timeslice& ts,
439  size_t /*component*/) {
440  fulTsCounter++;
441 
442  if (kFALSE == fbComponentsAddedToList) {
443  for (uint32_t uCompIdx = 0; uCompIdx < ts.num_components(); ++uCompIdx) {
444  switch (ts.descriptor(uCompIdx, 0).sys_id) {
445  case kusSysIdSts: {
446  fUnpAlgoSts->AddMsComponentToList(uCompIdx, kusSysIdSts);
447  break;
448  } // case kusSysIdSts
449  case kusSysIdMuch: {
450  fUnpAlgoMuch->AddMsComponentToList(uCompIdx, kusSysIdMuch);
451  break;
452  } // case kusSysIdMuch
453  case kusSysIdTrd: {
454  fUnpAlgoTrd->AddMsComponentToList(uCompIdx, kusSysIdTrd);
455  break;
456  } // case kusSysIdTrd
457  case kusSysIdTof: {
458  fUnpAlgoTof->AddMsComponentToList(uCompIdx, kusSysIdTof);
459  break;
460  } // case kusSysIdTof
461  case kusSysIdT0: {
462  fUnpAlgoTof->AddMsComponentToList(uCompIdx, kusSysIdT0);
463  break;
464  } // case kusSysIdT0
465  case kusSysIdRich: {
466  fUnpAlgoRich->AddMsComponentToList(uCompIdx, kusSysIdRich);
467  break;
468  } // case kusSysIdRich
469  case kusSysIdPsd: {
470  fUnpAlgoPsd->AddMsComponentToList(uCompIdx, kusSysIdPsd);
471  break;
472  } // case kusSysIdPsd
473  default: break;
474  } // switch( ts.descriptor( uCompIdx, 0 ).sys_id )
475  } // for( uint32_t uComp = 0; uComp < ts.num_components(); ++uComp )
476  fbComponentsAddedToList = kTRUE;
477  } // if( kFALSE == fbComponentsAddedToList )
478 
479  if (kFALSE == fUnpAlgoSts->ProcessTs(ts)) {
480  LOG(error) << "Failed processing TS " << ts.index()
481  << " in STS unpacker algorithm class";
482  return kTRUE;
483  } // if( kFALSE == fUnpAlgoSts->ProcessTs( ts ) )
484 
485  if (kFALSE == fUnpAlgoMuch->ProcessTs(ts)) {
486  LOG(error) << "Failed processing TS " << ts.index()
487  << " in MUCH unpacker algorithm class";
488  return kTRUE;
489  } // if( kFALSE == fUnpAlgoMuch->ProcessTs( ts ) )
490 
491  if (kFALSE == fUnpAlgoTrd->ProcessTs(ts)) {
492  LOG(error) << "Failed processing TS " << ts.index()
493  << " in TRD unpacker algorithm class";
494  return kTRUE;
495  } // if( kFALSE == fUnpAlgoTrd->ProcessTs( ts ) )
496 
497  if (kFALSE == fUnpAlgoTof->ProcessTs(ts)) {
498  LOG(error) << "Failed processing TS " << ts.index()
499  << " in TOF unpacker algorithm class";
500  return kTRUE;
501  } // if( kFALSE == fUnpAlgoTof->ProcessTs( ts ) )
502 
503  if (kFALSE == fUnpAlgoRich->ProcessTs(ts)) {
504  LOG(error) << "Failed processing TS " << ts.index()
505  << " in RICH unpacker algorithm class";
506  return kTRUE;
507  } // if( kFALSE == fUnpAlgoRich->ProcessTs( ts ) )
508 
509  if (kFALSE == fUnpAlgoPsd->ProcessTs(ts)) {
510  LOG(error) << "Failed processing TS " << ts.index()
511  << " in PSD unpacker algorithm class";
512  return kTRUE;
513  } // if( kFALSE == fUnpAlgoPsd->ProcessTs( ts ) )
514 
515 
516  if (0 == fulTsCounter % 10000)
517  LOG(info) << "Processed " << fulTsCounter << " time slices";
518 
519  return kTRUE;
520 }
521 
522 void CbmDeviceMcbmUnpack::Finish() {}
CbmMcbm2018UnpackerAlgoTof
Definition: CbmMcbm2018UnpackerAlgoTof.h:35
CbmMcbm2018UnpackerAlgoPsd.h
InitTaskError
CBM headers.
Definition: CbmDeviceEventBuilderEtofStar2019.cxx:36
CbmDeviceMcbmUnpack::CbmDeviceMcbmUnpack
CbmDeviceMcbmUnpack()
Definition: CbmDeviceMcbmUnpack.cxx:50
CbmFlesCanvasTools.h
TimesliceMetaData
Definition: TimesliceMetaData.h:11
CbmMQTMessage
Definition: CbmDeviceEventBuilderEtofStar2019.h:96
CbmMcbm2018UnpackerAlgoTof.h
CbmDeviceMcbmUnpack::InitParameters
Bool_t InitParameters(TList *fParCList)
Parameters management.
Definition: CbmDeviceMcbmUnpack.cxx:202
CbmMcbm2018UnpackerAlgoPsd
Definition: CbmMcbm2018UnpackerAlgoPsd.h:30
cbm::mq::Transition::ErrorFound
@ ErrorFound
CbmDeviceMcbmUnpack::HandleData
bool HandleData(FairMQMessagePtr &, int)
Definition: CbmDeviceMcbmUnpack.cxx:243
bMcbm2018MonitorTaskT0ResetHistos
Bool_t bMcbm2018MonitorTaskT0ResetHistos
Definition: CbmDeviceMcbmUnpack.cxx:48
CbmDeviceMcbmUnpack::SendUnpData
bool SendUnpData()
Definition: CbmDeviceMcbmUnpack.cxx:302
CbmDeviceMcbmUnpack::Finish
void Finish()
Definition: CbmDeviceMcbmUnpack.cxx:522
CbmMcbm2018UnpackerAlgoSts.h
CbmMcbm2018UnpackerAlgoSts
Definition: CbmMcbm2018UnpackerAlgoSts.h:37
CbmMcbm2018UnpackerAlgoTrdR.h
CbmMcbm2018UnpackerAlgoMuch
Definition: CbmMcbm2018UnpackerAlgoMuch.h:37
CbmDeviceMcbmUnpack.h
CbmMcbm2018UnpackerAlgoRich
Definition: CbmMcbm2018UnpackerAlgoRich.h:44
CbmMcbm2018UnpackerAlgoRich.h
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmDeviceMcbmUnpack::InitContainers
Bool_t InitContainers()
Definition: CbmDeviceMcbmUnpack.cxx:117
CbmDeviceMcbmUnpack::IsChannelNameAllowed
bool IsChannelNameAllowed(std::string channelName)
Definition: CbmDeviceMcbmUnpack.cxx:96
TimesliceMetaData.h
CbmMcbm2018UnpackerAlgoMuch.h
CbmMQDefs.h
CbmDeviceMcbmUnpack::~CbmDeviceMcbmUnpack
virtual ~CbmDeviceMcbmUnpack()
Definition: CbmDeviceMcbmUnpack.cxx:428
cbm::mq::ChangeState
void ChangeState(FairMQDevice *device, cbm::mq::Transition transition)
Definition: CbmMQDefs.h:19
CbmDeviceMcbmUnpack::DoUnpack
Bool_t DoUnpack(const fles::Timeslice &ts, size_t component)
Definition: CbmDeviceMcbmUnpack.cxx:438
CbmDeviceMcbmUnpack::InitTask
virtual void InitTask()
Definition: CbmDeviceMcbmUnpack.cxx:59
CbmMcbm2018UnpackerAlgoTrdR
Timeslice unpacker algorithm for Spadic v.2.2 .
Definition: CbmMcbm2018UnpackerAlgoTrdR.h:34