daq::DaqDecoderIcarusPMTold Class Reference

Inheritance diagram for daq::DaqDecoderIcarusPMTold:

Classes
class	Config

Public Member Functions
	DaqDecoderIcarusPMTold (fhicl::ParameterSet const &p)
void	produce (art::Event &e) override

Private Member Functions
void	process_fragment (art::Event &event, const artdaq::Fragment &frag, std::unique_ptr< std::vector< raw::RawDigit >> &product_collectionf)

Private Attributes
art::InputTag	_tag
Config	_config

Detailed Description

Definition at line 37 of file DaqDecoderICARUSPMTold_module.cc.

Constructor & Destructor Documentation

daq::DaqDecoderIcarusPMTold::DaqDecoderIcarusPMTold ( fhicl::ParameterSet const &  p )

explicit

Definition at line 93 of file DaqDecoderICARUSPMTold_module.cc.

                                                                             : 
    art::EDProducer{param},
    _tag(param.get<art::InputTag>("FragmentsLabel", "daq:CAENV1730")),
    _config(param)//,
    //_last_event_number(0),
    //_last_trig_frame_number(0)
{
  
    // produce stuff
    produces<std::vector<raw::OpDetWaveform>>();
    // if (_config.produce_header) {
    //   produces<std::vector<tpcAnalysis::HeaderData>>();
    // }
}

Member Function Documentation

void daq::DaqDecoderIcarusPMTold::process_fragment ( art::Event &  event, const artdaq::Fragment &  frag, std::unique_ptr< std::vector< raw::RawDigit >> &  product_collectionf  )

private

Definition at line 233 of file DaqDecoderICARUSPMTold_module.cc.

{
    // convert fragment to Nevis fragment
    icarus::PhysCrateFragment fragment(frag);
          std::cout << " n boards " << fragment.nBoards() << std::endl;
    //int channel_count=0;

    for(size_t i_b=0; i_b < fragment.nBoards(); i_b++)
    {
              //A2795DataBlock const& block_data = *(crate_data.BoardDataBlock(i_b));

              for(size_t i_ch=0; i_ch < fragment.nChannelsPerBoard(); ++i_ch)
        {
                  //raw::ChannelID_t channel_num = (i_ch & 0xff ) + (i_b << 8);
            raw::ChannelID_t channel_num = i_ch+i_b*64;
                  raw::RawDigit::ADCvector_t wvfm(fragment.nSamplesPerChannel());
          
            for(size_t i_t=0; i_t < fragment.nSamplesPerChannel(); ++i_t) 
            {
                      wvfm[i_t] = fragment.adc_val(i_b,i_ch,i_t);
                // if(channel_num==1855) std::cout << " sample " << i_t << " wave " << wvfm[i_t] << std::endl;
            }
            //   product_collection->emplace_back(channel_count++,fragment.nSamplesPerChannel(),wvfm);
            product_collection->emplace_back(channel_num,fragment.nSamplesPerChannel(),wvfm);
            //std::cout << " channel " << channel_num << " waveform size " << fragment.nSamplesPerChannel() << std::endl;

              }//loop over channels

    }//loop over boards
    std::cout << "Total number of channels added is " << product_collection->size() << std::endl;
}

void daq::DaqDecoderIcarusPMTold::produce ( art::Event &  e )

override

Definition at line 137 of file DaqDecoderICARUSPMTold_module.cc.

{
    if (_config.wait_sec >= 0) 
    {
        std::this_thread::sleep_for(std::chrono::seconds(_config.wait_sec) + std::chrono::microseconds(_config.wait_usec));
    }
    //auto const& daq_handle = event.getValidHandle<artdaq::Fragments>(_tag);
  
    // storage for waveform
    std::unique_ptr<std::vector<raw::OpDetWaveform>> product_collection(new std::vector<raw::OpDetWaveform>());
    // storage for header info
    // std::unique_ptr<std::vector<tpcAnalysis::HeaderData>> header_collection(new std::vector<tpcAnalysis::HeaderData>);

    /************************************************************************************************/
    art::Handle< std::vector<artdaq::Fragment> > rawFragHandle;
    event.getByLabel(_tag, rawFragHandle);
  
    if (rawFragHandle.isValid()) {

    std::cout << "######################################################################\n";
    std::cout << "Run " << event.run() << ", subrun " << event.subRun() << std::endl;

    for (size_t idx = 0; idx < rawFragHandle->size(); ++idx) /*loop over the fragments*/
    {
        //--use this fragment as a reference to the same data
        const auto& frag((*rawFragHandle)[idx]); 
        sbndaq::CAENV1730Fragment bb(frag);
        auto const* md = bb.Metadata();
        sbndaq::CAENV1730Event const* event_ptr = bb.Event();
        sbndaq::CAENV1730EventHeader header = event_ptr->Header;

        std::cout << "\tFragment ID: " << frag.fragmentID() << ", type: " << frag.typeString() << ", type: " << frag.type() << ", boardID: " << header.boardID << ", msk lo: " << header.channelMask_lo << ", hi: " << header.channelMask_hi << std::endl;
        std::cout << "\tFrom header, event counter is "  << header.eventCounter   << "\n";
        std::cout << "\tFrom header, triggerTimeTag is " << header.triggerTimeTag << "\n";
        std::vector< std::vector<uint16_t> >  fWvfmsVec;
        size_t nChannels = md->nChannels;
        std::cout <<"\tFrom header , no of channel is " << nChannels << "\n";
      
        uint32_t ev_size_quad_bytes = header.eventSize;
        //   std::cout << "Event size in quad bytes is: " << ev_size_quad_bytes << "\n";
        uint32_t evt_header_size_quad_bytes = sizeof(sbndaq::CAENV1730EventHeader)/sizeof(uint32_t);
        uint32_t data_size_double_bytes = 2*(ev_size_quad_bytes - evt_header_size_quad_bytes);
        uint32_t wfm_length = data_size_double_bytes/nChannels;

        //--note, needs to take into account channel mask
        //   std::cout << "Channel waveform length = " << wfm_length << "\n";

        const uint16_t* data_begin = reinterpret_cast<const uint16_t*>(frag.dataBeginBytes() 
                                   + sizeof(sbndaq::CAENV1730EventHeader));

        const uint16_t* value_ptr =  data_begin;
        size_t ch_offset = 0;
        uint16_t value;

        // loop over channels
        for (size_t i_ch=0; i_ch<nChannels; ++i_ch)
        {
            //fWvfmsVec[i_ch].resize(wfm_length);
            ch_offset = i_ch * wfm_length;
      
            raw::OpDetWaveform my_wf(0.00, i_ch, wfm_length);
            my_wf.resize(wfm_length);
            // Loop over waveform
      
            for(size_t i_t=0; i_t<wfm_length; ++i_t)
            { 
                //fTicksVec[i_t] = t0*Ttt_DownSamp + i_t;   /*timestamps, event level*/
                value_ptr = data_begin + ch_offset + i_t; /*pointer arithmetic*/
                      //value_ptr = (i_t%2 == 0) ? (index+1) : (index-1); 
                value = *(value_ptr);
                my_wf[i_t] = value;
                      //std::cout<<"Value is" << value << "and" << my_wf[i_t] << "\n";
                      //if (i_ch == 0 && fEvent == 0) h_wvfm_ev0_ch0->SetBinContent(i_t,value);
                //fWvfmsVec[i_ch][i_t] = value;
            }  //--end loop samples
 
            product_collection->push_back(my_wf);
          }// end loop over channels
        // std::cout<<"product collection"<<product_collection->back().size()<<"\n";
      } // end loop over fragments
    }
    event.put(std::move(product_collection));
}

Member Data Documentation

Config daq::DaqDecoderIcarusPMTold::_config

private

Definition at line 83 of file DaqDecoderICARUSPMTold_module.cc.

art::InputTag daq::DaqDecoderIcarusPMTold::_tag

private

Definition at line 82 of file DaqDecoderICARUSPMTold_module.cc.

---

The documentation for this class was generated from the following file:

• DaqDecoderICARUSPMTold_module.cc