mu2e_artdaq_core  v1_02_11
 All Classes Functions
DebugFragmentWriter.hh
1 #ifndef mu2e_artdaq_Overlays_DebugFragmentWriter_hh
2 #define mu2e_artdaq_Overlays_DebugFragmentWriter_hh
3 
5 // DebugFragmentWriter
6 //
7 // Class derived from DetectorFragment which allows writes to the data (for
8 // simulation purposes). Note that for this reason it contains
9 // non-const members which hide the const members in its parent class,
10 // DetectorFragment, including its reference to the artdaq::Fragment
11 // object, artdaq_Fragment_, as well as its functions pointing to the
12 // beginning and end of ADC values in the fragment, dataBegin() and
13 // dataEnd()
14 //
16 
17 #include "artdaq-core/Data/Fragment.hh"
18 #include "mu2e-artdaq-core/Overlays/DebugFragmentReader.hh"
19 
20 #include <iostream>
21 
22 namespace mu2e {
23 class DebugFragmentWriter;
24 }
25 
27  public:
28  DebugFragmentWriter(artdaq::Fragment &f);
29 
30  virtual ~DebugFragmentWriter(){};
31 
32  // These functions form overload sets with const functions from
33  // mu2e::DetectorFragment
34 
35  adc_t *dataBegin();
36  adc_t *dataEnd();
37 
38  adc_t *dataBlockBegin();
39  adc_t *dataBlockEnd();
40 
41  // We'll need to hide the const version of header in DetectorFragment in
42  // order to be able to perform writes
43 
44  Header *header_() {
45  assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
46  return reinterpret_cast<Header *>(&*artdaq_Fragment_.dataBegin());
47  }
48 
49  void set_hdr_run_number(Header::run_number_t run_number) { header_()->run_number = run_number; }
50 
51  void resize(size_t nAdcs);
52 
53  // virtual void printAll() {};
54 
55  // void generateOffsetTable(const std::vector<size_t> dataBlockVec);
56 
57  private:
58  size_t calc_event_size_words_(size_t nAdcs);
59 
60  static size_t adcs_to_words_(size_t nAdcs);
61  static size_t words_to_frag_words_(size_t nWords);
62 
63  // Note that this non-const reference hides the const reference in the base class
64  artdaq::Fragment &artdaq_Fragment_;
65 };
66 
67 // The constructor will expect the artdaq::Fragment object it's been
68 // passed to contain the artdaq::Fragment header + the
69 // DetectorFragment::Metadata object, otherwise it throws
70 
71 mu2e::DebugFragmentWriter::DebugFragmentWriter(artdaq::Fragment &f) : DebugFragmentReader(f), artdaq_Fragment_(f) {
72  // DetectorFragment(f), artdaq_Fragment_(f) {
73 
74  // If this assert doesn't hold, then can't call
75  // "words_to_frag_words_" below, translating between the
76  // DetectorFragment's standard data type size and the
77  // artdaq::Fragment's data type size, on the Metadata object
78 
79  assert(sizeof(Metadata::data_t) == sizeof(Header::data_t));
80 
81  if (artdaq_Fragment_.size() !=
82  artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)) {
83  std::cerr << "artdaq_Fragment size: " << artdaq_Fragment_.size() << std::endl;
84  std::cerr << "Expected size: "
85  << artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)
86  << std::endl;
87 
88  throw cet::exception(
89  "DebugFragmentWriter: Raw artdaq::Fragment object size suggests it does not consist of its own header + the "
90  "DetectorFragment::Metadata object");
91  }
92 
93  // Allocate space for the header
94  artdaq_Fragment_.resize(words_to_frag_words_(Header::size_words));
95 }
96 
97 inline mu2e::DetectorFragment::adc_t *mu2e::DebugFragmentWriter::dataBegin() {
98  assert(artdaq_Fragment_.dataSize() > words_to_frag_words_(Header::size_words));
99  return reinterpret_cast<adc_t *>(header_() + 1);
100 }
101 
102 inline mu2e::DetectorFragment::adc_t *mu2e::DebugFragmentWriter::dataEnd() { return dataBegin() + total_adc_values(); }
103 
104 inline mu2e::DetectorFragment::adc_t *mu2e::DebugFragmentWriter::dataBlockBegin() {
105  assert(artdaq_Fragment_.dataSize() > words_to_frag_words_(Header::size_words));
106  return (reinterpret_cast<adc_t *>(header_() + 1)) + current_offset_;
107 }
108 
109 inline mu2e::DetectorFragment::adc_t *mu2e::DebugFragmentWriter::dataBlockEnd() {
110  return dataBegin() + total_adc_values_in_data_block();
111 }
112 
113 inline void mu2e::DebugFragmentWriter::resize(size_t nAdcs) {
114  auto es(calc_event_size_words_(nAdcs));
115  artdaq_Fragment_.resize(words_to_frag_words_(es));
116  header_()->event_size = es;
117 }
118 
119 inline size_t mu2e::DebugFragmentWriter::calc_event_size_words_(size_t nAdcs) {
120  return adcs_to_words_(nAdcs) + hdr_size_words();
121 }
122 
123 inline size_t mu2e::DebugFragmentWriter::adcs_to_words_(size_t nAdcs) {
124  auto mod(nAdcs % adcs_per_word_());
125  return (mod == 0) ? nAdcs / adcs_per_word_() : nAdcs / adcs_per_word_() + 1;
126 }
127 
128 inline size_t mu2e::DebugFragmentWriter::words_to_frag_words_(size_t nWords) {
129  size_t mod = nWords % words_per_frag_word_();
130  return mod ? nWords / words_per_frag_word_() + 1 : nWords / words_per_frag_word_();
131 }
132 
133 #endif /* mu2e_artdaq_Overlays_DebugFragmentWriter_hh */