CbmRoot
CbmMQTsaSamplerTof.cxx
Go to the documentation of this file.
1 
9 #include "CbmMQTsaSamplerTof.h"
10 #include "CbmMQDefs.h"
11 
12 #include "FairMQLogger.h"
13 #include "FairMQProgOptions.h" // device->fConfig
14 
15 #include "TimesliceInputArchive.hpp"
16 #include "TimesliceSubscriber.hpp"
17 
18 #include <boost/algorithm/string.hpp>
19 #include <boost/archive/binary_oarchive.hpp>
20 #include <boost/filesystem.hpp>
21 #include <boost/regex.hpp>
22 
23 namespace filesys = boost::filesystem;
24 
25 #include <algorithm>
26 #include <chrono>
27 #include <ctime>
28 #include <stdio.h>
29 #include <string>
30 #include <thread> // this_thread::sleep_for
31 
32 using namespace std;
33 
34 #include <stdexcept>
35 
36 struct InitTaskError : std::runtime_error {
37  using std::runtime_error::runtime_error;
38 };
39 
40 
42  : FairMQDevice()
43  , fMaxTimeslices(0)
44  , fFileName("")
45  , fDirName("")
46  , fInputFileList()
47  , fFileCounter(0)
48  , fHost("")
49  , fPort(0)
50  , fTSNumber(0)
51  , fTSCounter(0)
52  , fMessageCounter(0)
53  , fSource(nullptr)
54  , fTime() {}
55 
57  // Get the values from the command line options (via fConfig)
58  fFileName = fConfig->GetValue<string>("filename");
59  fDirName = fConfig->GetValue<string>("dirname");
60  fHost = fConfig->GetValue<string>("flib-host");
61  fPort = fConfig->GetValue<uint64_t>("flib-port");
62  fMaxTimeslices = fConfig->GetValue<uint64_t>("max-timeslices");
63 
64  // Check which input is defined
65  // Posibilities
66  // filename && ! dirname : single file
67  // filename with wildcards && diranme : all files with filename regex in the directory
68  // host && port : connect to the flim server
69 
70  bool isGoodInputCombi {false};
71  if (0 != fFileName.size() && 0 == fDirName.size() && 0 == fHost.size()
72  && 0 == fPort) {
73  isGoodInputCombi = true;
74  // Create a Path object from given path string
75  filesys::path pathObj(fFileName);
76  if (!filesys::is_regular_file(pathObj)) {
77  throw InitTaskError("Passed file name is no valid file");
78  }
79  fInputFileList.push_back(fFileName);
80  LOG(info) << "Filename: " << fFileName;
81  } else if (0 != fFileName.size() && 0 != fDirName.size() && 0 == fHost.size()
82  && 0 == fPort) {
83  isGoodInputCombi = true;
84  filesys::path pathObj = fDirName;
85  if (!filesys::is_directory(pathObj)) {
86  throw InitTaskError("Passed directory name is no valid directory");
87  }
88  if (fFileName.find("*") == std::string::npos) {
89  // Normal file without wildcards
90  pathObj += fFileName;
91  if (!filesys::is_regular_file(pathObj)) {
92  throw InitTaskError("Passed file name is no valid file");
93  }
94  fInputFileList.push_back(pathObj.string());
95  LOG(info) << "Filename: " << fInputFileList[0];
96  } else {
97  std::vector<filesys::path> v;
98 
99  // escape "." which have a special meaning in regex
100  // change "*" to ".*" to find any number
101  // e.g. tofget4_hd2018.*.tsa => tofget4_hd2018\..*\.tsa
102  boost::replace_all(fFileName, ".", "\\.");
103  boost::replace_all(fFileName, "*", ".*");
104 
105  // create regex
106  const boost::regex my_filter(fFileName);
107 
108  // loop over all files in input directory
109  for (auto&& x : filesys::directory_iterator(pathObj)) {
110  // Skip if not a file
111  if (!boost::filesystem::is_regular_file(x)) continue;
112 
113  // Skip if no match
114  // x.path().leaf().string() means get from directory iterator the
115  // current entry as filesys::path, from this extract the leaf
116  // filename or directory name and convert it to a string to be
117  // used in the regex:match
118  boost::smatch what;
119  if (!boost::regex_match(x.path().leaf().string(), what, my_filter))
120  continue;
121 
122  v.push_back(x.path());
123  }
124 
125  // sort the files which match the regex in increasing order
126  // (hopefully)
127  std::sort(v.begin(), v.end());
128 
129  for (auto&& x : v)
130  fInputFileList.push_back(x.string());
131 
132  LOG(info) << "The following files will be used in this order.";
133  for (auto&& x : v)
134  LOG(info) << " " << x;
135  }
136  // throw InitTaskError("Input is a directory");
137 
138  } else if (0 == fFileName.size() && 0 == fDirName.size() && 0 != fHost.size()
139  && 0 != fPort) {
140  isGoodInputCombi = true;
141  LOG(info) << "Host: " << fHost;
142  LOG(info) << "Port: " << fPort;
143  } else {
144  isGoodInputCombi = false;
145  }
146 
147  if (!isGoodInputCombi) {
148  throw InitTaskError(
149  "Wrong combination of inputs. Either file or wildcard file + directory "
150  "or host + port are allowed combination.");
151  }
152 
153 
154  LOG(info) << "MaxTimeslices: " << fMaxTimeslices;
155 
156  // Get the information about created channels from the device
157  // Check if the defined channels from the topology (by name)
158  // are in the list of channels which are possible/allowed
159  // for the device
160  // The idea is to check at initilization if the devices are
161  // properly connected. For the time beeing this is done with a
162  // nameing convention. It is not avoided that someone sends other
163  // data on this channel.
164  int noChannel = fChannels.size();
165  LOG(info) << "Number of defined output channels: " << noChannel;
166  for (auto const& entry : fChannels) {
167  LOG(info) << "Channel name: " << entry.first;
168  if (!IsChannelNameAllowed(entry.first))
169  throw InitTaskError("Channel name does not match.");
170  }
171 
172  for (auto const& value : fComponentsToSend) {
173  LOG(info) << "Value : " << value;
174  if (value > 1) {
175  throw InitTaskError("Sending same data to more than one output channel "
176  "not implemented yet.");
177  }
178  }
179 
180  if (0 == fFileName.size() && 0 != fHost.size()) {
181  std::string connector = "tcp://" + fHost + ":" + std::to_string(fPort);
182  LOG(info) << "Open TSPublisher at " << connector;
183  fSource = new fles::TimesliceSubscriber(connector);
184  if (!fSource) { throw InitTaskError("Could not connect to publisher."); }
185  } else {
186  if (false == OpenNextFile()) {
187  throw InitTaskError(
188  "Could not open the first input file in the list, Doing nothing!");
189  }
190  }
191 
192  fTime = std::chrono::steady_clock::now();
193 } catch (InitTaskError& e) {
194  LOG(error) << e.what();
195  // Wrapper defined in CbmMQDefs.h to support different FairMQ versions
197 }
198 
200  // First Close and delete existing source
201  if (nullptr != fSource) delete fSource;
202 
203  if (fInputFileList.size() > 0) {
205  fInputFileList.erase(fInputFileList.begin());
206  LOG(info) << "Open the Flib input file " << fFileName;
207  filesys::path pathObj(fFileName);
208  if (!filesys::is_regular_file(pathObj)) {
209  LOG(error) << "Input file " << fFileName << " doesn't exist.";
210  return false;
211  }
212  fSource = new fles::TimesliceInputArchive(fFileName);
213  if (!fSource) {
214  LOG(error) << "Could not open input file.";
215  return false;
216  }
217  } else {
218  LOG(info) << "End of files list reached.";
219  return false;
220  }
221  return true;
222 }
223 
224 bool CbmMQTsaSamplerTof::IsChannelNameAllowed(std::string channelName) {
225  LOG(info) << "Number of allowed channels: " << fAllowedChannels.size();
226  for (auto const& entry : fAllowedChannels) {
227  LOG(info) << "Inspect " << entry;
228  std::size_t pos1 = channelName.find(entry);
229  if (pos1 != std::string::npos) {
230  const vector<std::string>::const_iterator pos =
231  std::find(fAllowedChannels.begin(), fAllowedChannels.end(), entry);
232  const vector<std::string>::size_type idx = pos - fAllowedChannels.begin();
233  LOG(info) << "Found " << entry << " in " << channelName;
234  LOG(info) << "Channel name " << channelName
235  << " found in list of allowed channel names at position "
236  << idx;
237  if (idx < 3) { //FIXME, hardwired constant!!!
238  fComponentsToSend[idx]++;
239  fChannelsToSend[idx].push_back(channelName);
240  }
241  return true;
242  }
243  }
244  LOG(info) << "Channel name " << channelName
245  << " not found in list of allowed channel names.";
246  LOG(error) << "Stop device.";
247  return false;
248 }
249 
250 bool CbmMQTsaSamplerTof::IsChannelUp(std::string channelName) {
251  for (auto const& entry : fChannels) {
252  LOG(info) << "Inspect " << entry.first;
253  std::size_t pos1 = channelName.find(entry.first);
254  if (pos1 != std::string::npos) {
255  LOG(info) << "Channel name " << channelName
256  << " found in list of defined channel names ";
257  return true;
258  }
259  }
260  LOG(info) << "Channel name " << channelName
261  << " not found in list of defined channel names.";
262  LOG(error) << "Stop device.";
263  return false;
264 }
265 
267 
268  auto timeslice = fSource->get();
269  if (timeslice) {
270  if (fTSCounter < fMaxTimeslices) {
271  fTSCounter++;
272 
273  const fles::Timeslice& ts = *timeslice;
274  auto tsIndex = ts.index();
275 
276  if (fTSCounter % 10000 == 0)
277  LOG(info) << "Sample TimeSlice " << fTSCounter << ", Index " << tsIndex;
278 
279  LOG(debug) << "Found " << ts.num_components()
280  << " different components in timeslice " << fTSCounter
281  << ", index " << tsIndex;
282 
283 
284  CheckTimeslice(ts);
285  /*
286  for (int nrComp = 0; nrComp < ts.num_components(); ++nrComp) {
287  CreateAndSendComponent(ts, nrComp);
288  }
289  */
290  // keep components together
291  std::vector<FairMQParts> parts;
292  std::vector<bool> bparts;
293  parts.resize(fComponentsToSend.size());
294  bparts.resize(parts.size());
295  for (uint i = 0; i < bparts.size(); i++)
296  bparts[i] = false;
297  LOG(debug) << "parts with size " << parts.size();
298 
299  for (uint nrComp = 0; nrComp < ts.num_components(); ++nrComp) {
300  // CreateAndCombineComponents(ts, nrComp);
301  LOG(debug) << "nrComp " << nrComp << ", SysID: "
302  << static_cast<int>(ts.descriptor(nrComp, 0).sys_id);
303  const vector<int>::const_iterator pos =
304  std::find(fSysId.begin(),
305  fSysId.end(),
306  static_cast<int>(ts.descriptor(nrComp, 0).sys_id));
307  if (pos != fSysId.end()) {
308  const vector<std::string>::size_type idx = pos - fSysId.begin();
309  if (fComponentsToSend[idx] > 0) {
310  LOG(debug) << "Append timeslice component of link " << nrComp
311  << " to idx " << idx;
312 
313  fles::StorableTimeslice component {
314  static_cast<uint32_t>(ts.num_microslices(nrComp), ts.index())};
315  component.append_component(ts.num_microslices(0));
316 
317  for (size_t m = 0; m < ts.num_microslices(nrComp); ++m) {
318  component.append_microslice(
319  0, m, ts.descriptor(nrComp, m), ts.content(nrComp, m));
320  }
321 
322  //LOG(debug)<<"Parts size available for "<<idx<<": "<<parts.size();
323  //if(idx > parts.size()-1) parts.resize(idx+1);
324 
325  //if ( !AppendData(component, idx) ) return false;
326  // serialize the timeslice and create the message
327  std::stringstream oss;
328  boost::archive::binary_oarchive oa(oss);
329  oa << component;
330  std::string* strMsg = new std::string(oss.str());
331 
332  LOG(debug) << "AddParts to " << idx << ": current size "
333  << parts[idx].Size();
334 
335  parts[idx].AddPart(NewMessage(
336  const_cast<char*>(strMsg->c_str()), // data
337  strMsg->length(), // size
338  [](void* /*data*/, void* object) {
339  delete static_cast<std::string*>(object);
340  },
341  strMsg)); // object that manages the data
342 
343  bparts[idx] = true;
344  }
345  }
346  }
347 
348  for (uint idx = 0; idx < parts.size(); idx++)
349  if (bparts[idx]) {
350  LOG(debug) << "Send parts with size " << parts[idx].Size()
351  << " to channel " << fChannelsToSend[idx][0];
352  if (Send(parts[idx], fChannelsToSend[idx][0]) < 0) {
353  LOG(error) << "Problem sending data";
354  return false;
355  }
356  LOG(debug) << "Sent message " << fMessageCounter << " with a size of "
357  << parts[idx].Size();
358  fMessageCounter++;
359  }
360 
361  //if(!SendTs()) return false;
362  return true;
363  } else {
364  LOG(info) << " Number of requested time slices reached, exiting ";
365  if (false == OpenNextFile()) {
366  CalcRuntime();
367  SendSysCmdStop();
368  return false;
369  } else {
370  CalcRuntime();
371  SendSysCmdStop();
372  return false;
373  }
374  }
375  } else {
376  if (false == OpenNextFile()) {
377  CalcRuntime();
378  SendSysCmdStop();
379  return false;
380  } else {
381  return true;
382  }
383  }
384 }
385 
387  const fles::Timeslice& /*ts*/,
388  int /*nrComp*/) {
389 
390  // Check if component has to be send. If the corresponding channel
391  // is connected append it to parts
392  /*
393  LOG(debug) <<"nrComp "<< nrComp<< ", SysID: " << static_cast<int>(ts.descriptor(nrComp,0).sys_id);
394  const vector<int>::const_iterator pos =
395  std::find(fSysId.begin(), fSysId.end(), static_cast<int>(ts.descriptor(nrComp,0).sys_id));
396  if (pos != fSysId.end() ) {
397  const vector<std::string>::size_type idx = pos-fSysId.begin();
398  if (fComponentsToSend[idx]>0) {
399  LOG(debug) << "Append timeslice component of link " << nrComp<< " to idx "<<idx;
400 
401  fles::StorableTimeslice component{static_cast<uint32_t>(ts.num_microslices(nrComp), ts.index())};
402  component.append_component(ts.num_microslices(0));
403 
404  for (size_t m = 0; m < ts.num_microslices(nrComp); ++m) {
405  component.append_microslice( 0, m, ts.descriptor(nrComp, m), ts.content(nrComp, m) );
406  }
407 
408  //LOG(debug)<<"Parts size available for "<<idx<<": "<<parts.size();
409  if(idx > parts.size()-1) parts.resize(idx+1);
410 
411  if ( !AppendData(component, idx) ) return false;
412  bparts[idx]=true;
413  return true;
414  }
415  }
416  */
417  return true;
418 }
419 
421  const fles::StorableTimeslice& /*component*/,
422  int /*idx*/) {
423  // serialize the timeslice and create the message
424  /*
425  std::stringstream oss;
426  boost::archive::binary_oarchive oa(oss);
427  oa << component;
428  std::string* strMsg = new std::string(oss.str());
429 
430  LOG(debug)<<"AddParts to "<<idx<<": current size "<<parts[idx].Size();
431 
432  parts[idx].AddPart(NewMessage(const_cast<char*>(strMsg->c_str()), // data
433  strMsg->length(), // size
434  [](void*, void* object){ delete static_cast<std::string*>(object); },
435  strMsg)); // object that manages the data
436  */
437  return true;
438 }
439 
441  /*
442  for (int idx=0; idx<parts.size(); idx++)
443  if(bparts[idx]){
444  LOG(debug) << "Send data to channel " << fChannelsToSend[idx][0];
445  if (Send(parts[idx], fChannelsToSend[idx][0]) < 0) {
446  LOG(error) << "Problem sending data";
447  return false;
448  }
449 
450  fMessageCounter++;
451  LOG(debug) << "Send message " << fMessageCounter << " with a size of "
452  << parts[idx].Size();
453  }
454  */
455  return true;
456 }
457 
458 bool CbmMQTsaSamplerTof::CreateAndSendComponent(const fles::Timeslice& ts,
459  int nrComp) {
460 
461  // Check if component has to be send. If the corresponding channel
462  // is connected create the new timeslice and send it to the
463  // correct channel
464 
465  LOG(debug) << "SysID: " << static_cast<int>(ts.descriptor(nrComp, 0).sys_id);
466  const vector<int>::const_iterator pos =
467  std::find(fSysId.begin(),
468  fSysId.end(),
469  static_cast<int>(ts.descriptor(nrComp, 0).sys_id));
470  if (pos != fSysId.end()) {
471  const vector<std::string>::size_type idx = pos - fSysId.begin();
472  if (fComponentsToSend[idx] > 0) {
473  LOG(debug) << "Create timeslice component for link " << nrComp;
474 
475  fles::StorableTimeslice component {
476  static_cast<uint32_t>(ts.num_microslices(nrComp), ts.index())};
477  component.append_component(ts.num_microslices(0));
478 
479  for (size_t m = 0; m < ts.num_microslices(nrComp); ++m) {
480  component.append_microslice(
481  0, m, ts.descriptor(nrComp, m), ts.content(nrComp, m));
482  }
483  if (!SendData(component, idx)) return false;
484  return true;
485  }
486  }
487  return true;
488 }
489 
490 bool CbmMQTsaSamplerTof::SendData(const fles::StorableTimeslice& component,
491  int idx) {
492  // serialize the timeslice and create the message
493  std::stringstream oss;
494  boost::archive::binary_oarchive oa(oss);
495  oa << component;
496  std::string* strMsg = new std::string(oss.str());
497 
498  FairMQMessagePtr msg(NewMessage(
499  const_cast<char*>(strMsg->c_str()), // data
500  strMsg->length(), // size
501  [](void* /*data*/, void* object) {
502  delete static_cast<std::string*>(object);
503  },
504  strMsg)); // object that manages the data
505 
506  // TODO: Implement sending same data to more than one channel
507  // Need to create new message (copy message??)
508  if (fComponentsToSend[idx] > 1) { LOG(debug) << "Need to copy FairMessage"; }
509 
510  // in case of error or transfer interruption,
511  // return false to go to IDLE state
512  // successfull transfer will return number of bytes
513  // transfered (can be 0 if sending an empty message).
514 
515  LOG(debug) << "Send data to channel " << fChannelsToSend[idx][0];
516  if (Send(msg, fChannelsToSend[idx][0]) < 0) {
517  LOG(error) << "Problem sending data";
518  return false;
519  }
520 
521  fMessageCounter++;
522  LOG(debug) << "Send message " << fMessageCounter << " with a size of "
523  << msg->GetSize();
524 
525  return true;
526 }
527 
528 
530 
532  std::chrono::duration<double> run_time =
533  std::chrono::steady_clock::now() - fTime;
534 
535  LOG(info) << "Runtime: " << run_time.count();
536  LOG(info) << "No more input data";
537 }
538 
539 
541  const fles::MicrosliceDescriptor& mdsc) {
542  LOG(info) << "Header ID: Ox" << std::hex << static_cast<int>(mdsc.hdr_id)
543  << std::dec;
544  LOG(info) << "Header version: Ox" << std::hex
545  << static_cast<int>(mdsc.hdr_ver) << std::dec;
546  LOG(info) << "Equipement ID: " << mdsc.eq_id;
547  LOG(info) << "Flags: " << mdsc.flags;
548  LOG(info) << "Sys ID: Ox" << std::hex << static_cast<int>(mdsc.sys_id)
549  << std::dec;
550  LOG(info) << "Sys version: Ox" << std::hex << static_cast<int>(mdsc.sys_ver)
551  << std::dec;
552  LOG(info) << "Microslice Idx: " << mdsc.idx;
553  LOG(info) << "Checksum: " << mdsc.crc;
554  LOG(info) << "Size: " << mdsc.size;
555  LOG(info) << "Offset: " << mdsc.offset;
556 }
557 
558 bool CbmMQTsaSamplerTof::CheckTimeslice(const fles::Timeslice& ts) {
559  if (0 == ts.num_components()) {
560  LOG(error) << "No Component in TS " << ts.index();
561  return 1;
562  }
563  LOG(debug) << "Found " << ts.num_components()
564  << " different components in timeslice";
565 
566  for (size_t c = 0; c < ts.num_components(); ++c) {
567  LOG(debug) << "Found " << ts.num_microslices(c)
568  << " microslices in component " << c;
569  LOG(debug) << "Component " << c << " has a size of " << ts.size_component(c)
570  << " bytes";
571  LOG(debug) << "Component " << c << " has the system id 0x" << std::hex
572  << static_cast<int>(ts.descriptor(c, 0).sys_id) << std::dec;
573  /*
574  LOG(debug) << "Component " << c << " has the system id 0x"
575  << static_cast<int>(ts.descriptor(c,0).sys_id);
576  */
577  /*
578  for (size_t m = 0; m < ts.num_microslices(c); ++m) {
579  PrintMicroSliceDescriptor(ts.descriptor(c,m));
580  }
581 */
582  }
583 
584  return true;
585 }
586 
588  if (IsChannelUp("syscmd")) {
589  LOG(info) << "stop subscribers in 100 sec";
590  std::this_thread::sleep_for(std::chrono::milliseconds(100000));
591 
592  FairMQMessagePtr pub(NewSimpleMessage("STOP"));
593  if (Send(pub, "syscmd") < 0) {
594  LOG(error) << "Sending STOP message failed";
595  }
596 
597  LOG(info) << "task reset subscribers in 1 sec";
598  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
599  FairMQMessagePtr task_reset(NewSimpleMessage("TASK_RESET"));
600 
601  if (Send(task_reset, "syscmd") < 0) {
602  LOG(error) << "Sending Task_Reset message failed";
603  }
604  }
605  // FairMQStateMachine::ChangeState(STOP);
606 }
CbmMQTsaSamplerTof::fMessageCounter
uint64_t fMessageCounter
Definition: CbmMQTsaSamplerTof.h:42
CbmMQTsaSamplerTof::fPort
uint64_t fPort
Definition: CbmMQTsaSamplerTof.h:38
CbmMQTsaSamplerTof::CbmMQTsaSamplerTof
CbmMQTsaSamplerTof()
Definition: CbmMQTsaSamplerTof.cxx:41
CbmMQTsaSamplerTof.h
CbmMQTsaSamplerTof::ConditionalRun
virtual bool ConditionalRun()
Definition: CbmMQTsaSamplerTof.cxx:266
CbmMQTsaSamplerTof::SendTs
bool SendTs()
Definition: CbmMQTsaSamplerTof.cxx:440
CbmMQTsaSamplerTof::fComponentsToSend
std::vector< int > fComponentsToSend
Definition: CbmMQTsaSamplerTof.h:87
CbmMQTsaSamplerTof::PrintMicroSliceDescriptor
void PrintMicroSliceDescriptor(const fles::MicrosliceDescriptor &mdsc)
Definition: CbmMQTsaSamplerTof.cxx:540
CbmMQTsaSamplerTof::InitTask
virtual void InitTask()
Definition: CbmMQTsaSamplerTof.cxx:56
InitTaskError
CBM headers.
Definition: CbmDeviceEventBuilderEtofStar2019.cxx:36
CbmMQTsaSamplerTof::fDirName
std::string fDirName
Definition: CbmMQTsaSamplerTof.h:33
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMQTsaSamplerTof::SendData
bool SendData(const fles::StorableTimeslice &component)
CbmMQTsaSamplerTof::IsChannelUp
bool IsChannelUp(std::string)
Definition: CbmMQTsaSamplerTof.cxx:250
CbmMQTsaSamplerTof::fAllowedChannels
std::vector< std::string > fAllowedChannels
Definition: CbmMQTsaSamplerTof.h:80
CbmMQTsaSamplerTof::fMaxTimeslices
uint64_t fMaxTimeslices
Definition: CbmMQTsaSamplerTof.h:30
cbm::mq::Transition::ErrorFound
@ ErrorFound
CbmMQTsaSamplerTof::fInputFileList
std::vector< std::string > fInputFileList
List of input files.
Definition: CbmMQTsaSamplerTof.h:35
CbmMQTsaSamplerTof::fSource
fles::TimesliceSource * fSource
Definition: CbmMQTsaSamplerTof.h:65
CbmMQTsaSamplerTof::fChannelsToSend
std::vector< std::vector< std::string > > fChannelsToSend
Definition: CbmMQTsaSamplerTof.h:88
CbmMQTsaSamplerTof::CalcRuntime
void CalcRuntime()
Definition: CbmMQTsaSamplerTof.cxx:531
CbmMQTsaSamplerTof::fHost
std::string fHost
Definition: CbmMQTsaSamplerTof.h:37
CbmMQTsaSamplerTof::OpenNextFile
bool OpenNextFile()
Definition: CbmMQTsaSamplerTof.cxx:199
CbmMQTsaSamplerTof::fSysId
std::vector< int > fSysId
Definition: CbmMQTsaSamplerTof.h:85
v
__m128 v
Definition: L1/vectors/P4_F32vec4.h:1
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMQTsaSamplerTof::CreateAndSendComponent
bool CreateAndSendComponent(const fles::Timeslice &, int)
Definition: CbmMQTsaSamplerTof.cxx:458
m
__m128 m
Definition: L1/vectors/P4_F32vec4.h:26
CbmMQTsaSamplerTof::fFileName
std::string fFileName
Definition: CbmMQTsaSamplerTof.h:32
CbmMQTsaSamplerTof::CheckTimeslice
bool CheckTimeslice(const fles::Timeslice &ts)
Definition: CbmMQTsaSamplerTof.cxx:558
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmMQTsaSamplerTof::AppendData
bool AppendData(const fles::StorableTimeslice &, int)
Definition: CbmMQTsaSamplerTof.cxx:420
CbmMQTsaSamplerTof::~CbmMQTsaSamplerTof
virtual ~CbmMQTsaSamplerTof()
Definition: CbmMQTsaSamplerTof.cxx:529
CbmMQTsaSamplerTof::fTime
std::chrono::steady_clock::time_point fTime
Definition: CbmMQTsaSamplerTof.h:66
CbmMQDefs.h
CbmMQTsaSamplerTof::SendSysCmdStop
void SendSysCmdStop()
Definition: CbmMQTsaSamplerTof.cxx:587
cbm::mq::ChangeState
void ChangeState(FairMQDevice *device, cbm::mq::Transition transition)
Definition: CbmMQDefs.h:19
CbmMQTsaSamplerTof::fTSCounter
uint64_t fTSCounter
Definition: CbmMQTsaSamplerTof.h:41
CbmMQTsaSamplerTof::IsChannelNameAllowed
bool IsChannelNameAllowed(std::string)
Definition: CbmMQTsaSamplerTof.cxx:224
CbmMQTsaSamplerTof::CreateAndCombineComponents
bool CreateAndCombineComponents(const fles::Timeslice &, int)
Definition: CbmMQTsaSamplerTof.cxx:386