00001 #ifndef mu2e_artdaq_core_Overlays_mu2eFragmentWriter_hh
00002 #define mu2e_artdaq_core_Overlays_mu2eFragmentWriter_hh
00003
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00016
00017 #include "artdaq-core/Data/Fragment.hh"
00018 #include "mu2e-artdaq-core/Overlays/mu2eFragment.hh"
00019
00020 #include <iostream>
00021 #include "trace.h"
00022
00023 namespace mu2e {
00024 class mu2eFragmentWriter;
00025 }
00026
00027
00028 class mu2e::mu2eFragmentWriter: public mu2e::mu2eFragment {
00029 public:
00030
00031
00032 mu2eFragmentWriter(artdaq::Fragment & f);
00033
00034
00035
00036
00037 Header::data_t * dataBegin();
00038 Header::data_t * dataAt(size_t index);
00039 Header::data_t * dataEnd();
00040 Header::data_t * dataAtBytes(size_t offset);
00041
00042
00043
00044
00045 Header * header_() {
00046
00047 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words) );
00048 return reinterpret_cast<Header *>(&*artdaq_Fragment_.dataBegin());
00049 }
00050
00051 void set_hdr_fragment_type(Header::data_t type) {
00052 header_()->fragment_type = type;
00053 }
00054
00055 void addSpace(size_t bytes);
00056 void endSubEvt(size_t bytes);
00057
00058 private:
00059
00060 artdaq::Fragment & artdaq_Fragment_;
00061 static size_t words_to_frag_words_(size_t nWords);
00062 };
00063
00064
00065
00066
00067
00068 mu2e::mu2eFragmentWriter::mu2eFragmentWriter(artdaq::Fragment& f ) :
00069 mu2eFragment(f), artdaq_Fragment_(f) {
00070
00071
00072
00073
00074
00075
00076 TRACE(2, "mu2eFragmentWriter Constructor");
00077
00078 assert( sizeof(Metadata::data_t) == sizeof(Header::data_t) );
00079
00080
00081 if (artdaq_Fragment_.size() !=
00082 artdaq::detail::RawFragmentHeader::num_words() +
00083 words_to_frag_words_( Metadata::size_words ))
00084 {
00085 std::cerr << "artdaq_Fragment size: " << artdaq_Fragment_.size() << std::endl;
00086 std::cerr << "Expected size: " << artdaq::detail::RawFragmentHeader::num_words() +
00087 words_to_frag_words_( Metadata::size_words) << std::endl;
00088
00089 throw cet::exception("mu2eFragmentWriter: Raw artdaq::Fragment object size suggests it does not consist of its own header + the mu2eFragment::Metadata object");
00090 }
00091
00092
00093 artdaq_Fragment_.resize(words_to_frag_words_( Header::size_words ) );
00094 header_()->block_count = 0;
00095 memset((void*)&(header_()->index[0]), 0, sizeof(size_t) * mu2e::BLOCK_COUNT_MAX);
00096 }
00097
00098
00099 inline mu2e::mu2eFragmentWriter::Header::data_t * mu2e::mu2eFragmentWriter::dataBegin() {
00100 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
00101 return reinterpret_cast<Header::data_t *>(header_() + 1);
00102 }
00103
00104 inline mu2e::mu2eFragmentWriter::Header::data_t * mu2e::mu2eFragmentWriter::dataAt(size_t index) {
00105 if(index == 0) return dataBegin();
00106 auto block = header_()->index[ index - 1 ] / sizeof(Header::data_t);
00107 return reinterpret_cast<Header::data_t*>(dataBegin() + block);
00108 }
00109
00110 inline mu2e::mu2eFragmentWriter::Header::data_t * mu2e::mu2eFragmentWriter::dataEnd() {
00111 return dataAt(hdr_block_count());
00112 }
00113
00114
00115 inline mu2e::mu2eFragmentWriter::Header::data_t * mu2e::mu2eFragmentWriter::dataAtBytes(size_t offset) {
00116 return dataBegin() + (offset / sizeof(Header::data_t));
00117 }
00118
00119 inline size_t mu2e::mu2eFragmentWriter::words_to_frag_words_(size_t nWords) {
00120 size_t mod = nWords % words_per_frag_word_();
00121 return mod ?
00122 nWords / words_per_frag_word_() + 1 :
00123 nWords / words_per_frag_word_();
00124 }
00125
00126 void mu2e::mu2eFragmentWriter::addSpace(size_t bytes) {
00127 TRACE(2, "mu2eFragmentWriter::addSpace START bytes=%lu", bytes);
00128 auto currSize = sizeof(artdaq::Fragment::value_type) * artdaq_Fragment_.size();
00129 TRACE(2, "Resizing fragment: additional bytes requested: %lu, size of fragment: %lu", bytes, currSize );
00130 artdaq_Fragment_.resizeBytes( bytes + currSize );
00131 }
00132
00133 void mu2e::mu2eFragmentWriter::endSubEvt(size_t bytes) {
00134 TRACE(2, "mu2eFragmentWriter::endSubEvt START bytes=%lu", bytes);
00135 header_()->index[hdr_block_count()] = blockOffset(hdr_block_count()) + bytes;
00136 header_()->block_count++;
00137 TRACE(2, "endSubEvt END");
00138 }
00139
00140 #endif