Inheritance diagram for EventGen::ImportSingle311Event:

Public Member Functions
	ImportSingle311Event (fhicl::ParameterSet const &p)

void	produce (art::Event &evt)

void	beginJob ()

void	endJob ()

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	SplitAdc (const std::vector< adc16_t > adc, size_t channel, uint32_t num_samples, std::vector< short > &adclist, size_t LArchan)

size_t	Get311Chan (size_t LAr_chan)

double	GetPedMean (size_t RawChan, std::vector< std::pair< double, double > > *fPedMap)

double	GetPedRMS (size_t RawChan, std::vector< std::pair< double, double > > *fPedMap)

Private Attributes
EventDecoder	DataDecode {1280, 1}

std::string	fFilename

size_t	fEvt_num

std::string	fPedestalFile

std::vector< std::pair< double, double > >	fPedMap

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 32 of file ImportSingle311Event_module.cc.

Constructor & Destructor Documentation

EventGen::ImportSingle311Event::ImportSingle311Event ( fhicl::ParameterSet const & p )

explicit

Definition at line 92 of file ImportSingle311Event_module.cc.

   : EDProducer(p)
   {
     fFilename = p.get<std::string>("Filename");
     fEvt_num = p.get<size_t>("Evt_num");
     fPedestalFile = p.get<std::string>("PedestalFile");
     produces< std::vector<raw::RawDigit> >();
   }

Member Function Documentation

void EventGen::ImportSingle311Event::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 102 of file ImportSingle311Event_module.cc.

                                      { 
     DataDecode.Open(fFilename);
   }

void EventGen::ImportSingle311Event::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 201 of file ImportSingle311Event_module.cc.

                                    {
     DataDecode.Close();
   } 

size_t EventGen::ImportSingle311Event::Get311Chan ( size_t LAr_chan )

private

Definition at line 159 of file ImportSingle311Event_module.cc.

                                                         {
 
     size_t crate = LAr_chan / 320;
     size_t Chan311;
 
     LAr_chan = 8*(LAr_chan/8+1)-LAr_chan%8 -1;
 
     if(crate == 0)
       {
         LAr_chan = 32*(LAr_chan/32+1)-LAr_chan%32 -1;
         size_t card = 4 - ((LAr_chan / 32) % 5);
         if(LAr_chan > 159)
           {
             size_t shift = 31 - (LAr_chan % 32);
             Chan311 = (2*card)*32 + shift;
           }
         else
           {
             size_t shift = 31 - (LAr_chan % 32);
             Chan311 = (2*card + 1)*32 + shift;
           }
       }
     else
       {
         size_t new_LAr_chan = LAr_chan - crate*320;
         size_t card = ((new_LAr_chan / 32) % 5);
         if(new_LAr_chan > 159)
           {
             size_t shift = new_LAr_chan % 32;
             Chan311 = (2*card)*32 + shift;
           }
         else
           {
             size_t shift = new_LAr_chan % 32;
             Chan311 = (2*card + 1)*32 + shift;
           }
         Chan311 = Chan311 + crate*320;
       } // end of if/else statementi
 
     return Chan311;
   } // Get311Chan

double EventGen::ImportSingle311Event::GetPedMean	(	size_t	RawChan,
		std::vector< std::pair< double, double > > *	fPedMap
	)

inlineprivate

Definition at line 45 of file ImportSingle311Event_module.cc.

45 { return fPedMap->at(RawChan).first; }

double EventGen::ImportSingle311Event::GetPedRMS	(	size_t	RawChan,
		std::vector< std::pair< double, double > > *	fPedMap
	)

inlineprivate

Definition at line 46 of file ImportSingle311Event_module.cc.

46 { return fPedMap->at(RawChan).second; }

void EventGen::ImportSingle311Event::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 107 of file ImportSingle311Event_module.cc.

                                                  {
       ReadPedestalFile(fPedestalFile, fPedMap);
 
       //ImportSingle311Event(fhicl::ParameterSet const & p);
       //beginJob();
 
       uint32_t nsample;
       size_t nch = DataDecode.GetNCh();
       dlardaq::evheader_t EveHead;
       std::vector<adc16_t> adcvec;
       
       ssize_t blabla = DataDecode.GetEvent(fEvt_num, EveHead, adcvec);
       std::cout << "Fetching event " << blabla << "\n";
       nsample = (uint32_t) EveHead.ev_size/(nch*1.5);
       std::cout << "The size of the event is " << nsample << "\n";
       auto max_adcvec = std::max_element(std::begin(adcvec), std::end(adcvec));
       std::cout << "Maximum element of adcvec is: " << *max_adcvec << "\n";
       std::cout << "The size of adcvec is: " << adcvec.size() << "\n";
       // std::cout << "The size in bytes of adcvec is: " << sizeof(adcvec) << "\n";
 
       std::vector<short> adclist;
       std::unique_ptr<std::vector<raw::RawDigit>> digcol(new std::vector<raw::RawDigit>);
       for(size_t LAr_chan = 0; LAr_chan < nch; LAr_chan++){
         adclist.clear();
         size_t Chan311 = Get311Chan(LAr_chan);
         SplitAdc(adcvec, Chan311, nsample, adclist, LAr_chan);
 
         short unsigned int nTickReadout = nsample;
         raw::ChannelID_t channel = LAr_chan;
         raw::Compress_t comp = raw::kNone;
         
         raw::RawDigit rd(channel, nTickReadout, adclist, comp);
         double pedval = ImportSingle311Event::GetPedMean(Chan311, &fPedMap);
         double pedrms = ImportSingle311Event::GetPedRMS(Chan311, &fPedMap);
         rd.SetPedestal(pedval, pedrms);
 
         digcol->push_back(rd);
         }
 
       evt.put(std::move(digcol));
       //endJob();
   }  

void EventGen::ImportSingle311Event::SplitAdc	(	const std::vector< adc16_t >	adc,
		size_t	channel,
		uint32_t	num_samples,
		std::vector< short > &	adclist,
		size_t	LArchan
	)

private

Definition at line 151 of file ImportSingle311Event_module.cc.

                                                                                                                                                   {
     adclist.resize(num_samples);
     for (uint32_t i = 0; i<num_samples; i++){
       adclist[i] = static_cast<short>(adc[channel*num_samples + i]);
     }
   }