Inheritance diagram for IcebergTPCRawDecoder:

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

	IcebergTPCRawDecoder (IcebergTPCRawDecoder const &)=delete

	IcebergTPCRawDecoder (IcebergTPCRawDecoder &&)=delete

IcebergTPCRawDecoder &	operator= (IcebergTPCRawDecoder const &)=delete

IcebergTPCRawDecoder &	operator= (IcebergTPCRawDecoder &&)=delete

void	produce (art::Event &e) override

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 Types
typedef std::vector< raw::RawDigit >	RawDigits

typedef std::vector< raw::RDTimeStamp >	RDTimeStamps

typedef art::Assns< raw::RawDigit, raw::RDTimeStamp >	RDTsAssocs

typedef art::PtrMaker< raw::RawDigit >	RDPmkr

typedef art::PtrMaker< raw::RDTimeStamp >	TSPmkr

typedef std::vector< raw::RDStatus >	RDStatuses

Private Member Functions
bool	_processRCE (art::Event &evt, RawDigits &raw_digits, RDTimeStamps &timestamps, RDTsAssocs &tsassocs, RDPmkr &rdpm, TSPmkr &tspm)

bool	_processFELIX (art::Event &evt, RawDigits &raw_digits, RDTimeStamps &timestamps, RDTsAssocs &tsassocs, RDPmkr &rdpm, TSPmkr &tspm)

bool	_process_RCE_AUX (const artdaq::Fragment &frag, RawDigits &raw_digits, RDTimeStamps &timestamps, RDTsAssocs &tsassocs, RDPmkr &rdpm, TSPmkr &tspm, uint32_t runNumber)

bool	_process_FELIX_AUX (const artdaq::Fragment &frag, RawDigits &raw_digits, RDTimeStamps &timestamps, RDTsAssocs &tsassocs, RDPmkr &rdpm, TSPmkr &tspm, uint32_t runNumber)

void	computeMedianSigma (raw::RawDigit::ADCvector_t &v_adc, float &median, float &sigma)

Private Attributes
std::string	_rce_input_label

std::string	_rce_input_container_instance

std::string	_rce_input_noncontainer_instance

std::string	_felix_input_label

std::string	_felix_input_container_instance

std::string	_felix_input_noncontainer_instance

int	_rce_fragment_type

int	_felix_fragment_type

std::string	_output_label

bool	_enforce_full_channel_count

unsigned int	_full_channel_count

bool	_enforce_same_tick_count

bool	_enforce_full_tick_count

unsigned int	_full_tick_count

bool	_enforce_error_free

bool	_enforce_no_duplicate_channels

bool	_drop_events_with_small_rce_frags

bool	_drop_small_rce_frags

size_t	_rce_frag_small_size

bool	_rce_drop_frags_with_badcsf

bool	_rce_hex_dump

bool	_rce_save_frags_to_files

bool	_rce_check_buffer_size

size_t	_rce_buffer_size_checklimit

bool	_felix_hex_dump

bool	_felix_drop_frags_with_badcsf

bool	_felix_enforce_exact_crate_number

int	_felix_crate_number_to_check

bool	_drop_events_with_small_felix_frags

bool	_drop_small_felix_frags

size_t	_felix_frag_small_size

bool	_felix_check_buffer_size

size_t	_felix_buffer_size_checklimit

bool	_compress_Huffman

bool	_print_coldata_convert_count

bool	_make_histograms

unsigned int	duplicate_channels

unsigned int	error_counter

unsigned int	incorrect_ticks

unsigned int	rcechans

unsigned int	felixchans

TH1D *	fIncorrectTickNumbers

TH1I *	fParticipRCE

TH1I *	fParticipFELIX

TH1I *	fDuplicatesNumber

TH1D *	fErrorsNumber

TH1I *	fFragSizeRCE

TH1I *	fFragSizeFELIX

TH1I *	fDeltaTimestamp

unsigned int	_tick_count_this_event

bool	_initialized_tick_count_this_event

bool	_discard_data

const unsigned int	_duplicate_channel_checklist_size =15360

bool	_duplicate_channel_checklist [15360]

bool	_DiscardedCorruptData

bool	_KeptCorruptData

std::vector< int16_t >	_buffer

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 58 of file IcebergTPCRawDecoder_module.cc.

Member Typedef Documentation

typedef std::vector<raw::RawDigit> IcebergTPCRawDecoder::RawDigits

private

Definition at line 69 of file IcebergTPCRawDecoder_module.cc.

typedef art::PtrMaker<raw::RawDigit> IcebergTPCRawDecoder::RDPmkr

private

Definition at line 72 of file IcebergTPCRawDecoder_module.cc.

typedef std::vector<raw::RDStatus> IcebergTPCRawDecoder::RDStatuses

private

Definition at line 74 of file IcebergTPCRawDecoder_module.cc.

typedef std::vector<raw::RDTimeStamp> IcebergTPCRawDecoder::RDTimeStamps

private

Definition at line 70 of file IcebergTPCRawDecoder_module.cc.

typedef art::Assns<raw::RawDigit,raw::RDTimeStamp> IcebergTPCRawDecoder::RDTsAssocs

private

Definition at line 71 of file IcebergTPCRawDecoder_module.cc.

typedef art::PtrMaker<raw::RDTimeStamp> IcebergTPCRawDecoder::TSPmkr

private

Definition at line 73 of file IcebergTPCRawDecoder_module.cc.

Constructor & Destructor Documentation

IcebergTPCRawDecoder::IcebergTPCRawDecoder ( fhicl::ParameterSet const & p )

explicit

Definition at line 156 of file IcebergTPCRawDecoder_module.cc.

   : EDProducer(p)
 {
   std::vector<int> emptyivec;
   _rce_input_label = p.get<std::string>("RCERawDataLabel","daq");
   _rce_input_container_instance = p.get<std::string>("RCERawDataContainerInstance","ContainerTPC");
   _rce_input_noncontainer_instance = p.get<std::string>("RCERawDataNonContainerInstance","TPC");
   _rce_fragment_type = p.get<int>("RCEFragmentType",2);
   _drop_events_with_small_rce_frags = p.get<bool>("RCEDropEventsWithSmallFrags",false);
   _drop_small_rce_frags = p.get<bool>("RCEDropSmallFrags",true);
   _rce_frag_small_size = p.get<unsigned int>("RCESmallFragSize",10000);
   _rce_drop_frags_with_badcsf = p.get<bool>("RCEDropFragsWithBadCSF",true);
   _rce_hex_dump = p.get<bool>("RCEHexDump",false);  
   _rce_save_frags_to_files = p.get<bool>("RCESaveFragsToFiles",false);  
   _rce_check_buffer_size = p.get<bool>("RCECheckBufferSize",true);
   _rce_buffer_size_checklimit = p.get<unsigned int>("RCEBufferSizeCheckLimit",10000000);
 
   _felix_input_label = p.get<std::string>("FELIXRawDataLabel");
   _felix_input_container_instance = p.get<std::string>("FELIXRawDataContainerInstance","ContainerFELIX");
   _felix_input_noncontainer_instance = p.get<std::string>("FELIXRawDataNonContainerInstance","FELIX");
   _felix_fragment_type = p.get<int>("FELIXFragmentType",8);
   _felix_drop_frags_with_badcsf = p.get<bool>("FELIXDropFragsWithBadCSF",true);
   _felix_hex_dump = p.get<bool>("FELIXHexDump",false);  
   _felix_enforce_exact_crate_number = p.get<bool>("FELIXEnforceExactCrateNumber",false);  
   _felix_crate_number_to_check = p.get<int>("FELIXCrateNumberToCheck",6);  
   _drop_events_with_small_felix_frags = p.get<bool>("FELIXDropEventsWithSmallFrags",false);
   _drop_small_felix_frags = p.get<bool>("FELIXDropSmallFrags",true);
   _felix_frag_small_size = p.get<unsigned int>("FELIXSmallFragSize",10000);
   _felix_check_buffer_size = p.get<bool>("FELIXCheckBufferSize",true);
   _felix_buffer_size_checklimit = p.get<unsigned int>("FELIXBufferSizeCheckLimit",10000000);
 
   _output_label = p.get<std::string>("OutputDataLabel");
 
   _enforce_full_channel_count = p.get<bool>("EnforceFullChannelCount", false);
   _full_channel_count = p.get<unsigned int>("FullChannelCount", 15360);
   _enforce_same_tick_count = p.get<bool>("EnforceSameTickCount",false);
   _enforce_full_tick_count = p.get<bool>("EnforceFullTickCount",false);
   _full_tick_count = p.get<unsigned int>("FullTickCount",6000);
   _enforce_error_free = p.get<bool>("EnforceErrorFree",false);
   _enforce_no_duplicate_channels = p.get<bool>("EnforceNoDuplicateChannels", true);
 
   _compress_Huffman = p.get<bool>("CompressHuffman",false);
   _print_coldata_convert_count = p.get<bool>("PrintColdataConvertCount",false);
 
   produces<RawDigits>( _output_label ); //the strings in <> are the typedefs defined above
   produces<RDTimeStamps>( _output_label );
   produces<RDTsAssocs>( _output_label );
   produces<RDStatuses>( _output_label );
 
   //Initialize Histograms if the tag is present
   //art::ServiceHandle<art::TFileService> fs;
   _make_histograms = p.get<bool>("MakeHistograms",false);
 
   if (_make_histograms)
     {
       art::ServiceHandle<art::TFileService> tFileService;
 
       //Number of channels with wrong number of tics plotted to have an adjusted log2 scale on x axis
       fIncorrectTickNumbers = tFileService->make<TH1D>("fIncorrectTickNumbers","Channels with Unexpected Number of Ticks",  45, -0.5, 14.5);
       fIncorrectTickNumbers->GetXaxis()->SetTitle("Channels with an Unexpected Number of Ticks");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(2,"1");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(8,"4");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(14,"16");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(23,"128");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(32,"1024");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(38,"4096");
       fIncorrectTickNumbers->GetXaxis()->SetBinLabel(44, "16384");
         
       //same as fIncorrectTickNumbers but with a zoomed domain
       //fIncorrectTickNumbersZoomed = tFileService->make<TH1I>("fIncorrectTickNumbersZoomed","Channels with Unexpected Number of Ticks", , 0.5, 100.5);
       //fIncorrectTickNumbersZoomed->GetXaxis()->SetTitle("Channels with an Unexpected Number of Tics (log2)");
 
       //number of participating RCE channels per event
       fParticipRCE = tFileService->make<TH1I>("fParticipRCE","Participating RCE channels", 130, 0.5, 15000.5); //expected value 128000
       fParticipRCE->GetXaxis()->SetTitle("RCE channels");
 
       //number of participating FELIX channels per event
       fParticipFELIX = tFileService->make<TH1I>("fParticipFELIX","Participating FELIX channels", 100, 0.5, 3000.5); //expected value 2560
       fParticipFELIX->GetXaxis()->SetTitle("FELIX channels");
 
       //number of duplicated channels per event
       fDuplicatesNumber = tFileService->make<TH1I>("fDuplicatesNumber", "Number of Duplucated Channels", 200, 0.5, 200.5);
       fDuplicatesNumber->GetXaxis()->SetTitle("Number of Duplicates");
       //gStyle->SetOptStat("nemro");
 
       //number of channels with error returns
       fErrorsNumber = tFileService->make<TH1D>("fErrorsNumber", "Channels with Errors", 45, -0.5, 14.5);
       fErrorsNumber->GetXaxis()->SetTitle("Number of channels with errors");
       fErrorsNumber->GetXaxis()->SetBinLabel(2,"1");
       fErrorsNumber->GetXaxis()->SetBinLabel(8,"4");
       fErrorsNumber->GetXaxis()->SetBinLabel(14,"16");
       fErrorsNumber->GetXaxis()->SetBinLabel(23,"128");
       fErrorsNumber->GetXaxis()->SetBinLabel(32,"1024");
       fErrorsNumber->GetXaxis()->SetBinLabel(38,"4096");
       fErrorsNumber->GetXaxis()->SetBinLabel(44, "16384");
 
       //total fragment sizes
       fFragSizeRCE = tFileService->make<TH1I>("fFragSizeRCE", "RCE Fragment Size", 100, 0.5, 288000000.5);
       fFragSizeRCE->GetXaxis()->SetTitle("Size of RCE Fragments (bytes)");
 
       fFragSizeFELIX = tFileService->make<TH1I>("fFragSizeFELIX", "FELIX Fragment Size", 100, 0.5, 57600000.5);
       fFragSizeFELIX->GetXaxis()->SetTitle("Size of FELIX Fragments (bytes)");
 
       fDeltaTimestamp = tFileService->make<TH1I>("fDeltaTimestamp", "Delta Timestamp Between Frames", 101, -0.5, 100.5);
 
     }
 
 }

IcebergTPCRawDecoder::IcebergTPCRawDecoder ( IcebergTPCRawDecoder const & )

delete

IcebergTPCRawDecoder::IcebergTPCRawDecoder ( IcebergTPCRawDecoder && )

delete

Member Function Documentation

bool IcebergTPCRawDecoder::_process_FELIX_AUX	(	const artdaq::Fragment &	frag,
		RawDigits &	raw_digits,
		RDTimeStamps &	timestamps,
		RDTsAssocs &	tsassocs,
		RDPmkr &	rdpm,
		TSPmkr &	tspm,
		uint32_t	runNumber
	)

private

Definition at line 985 of file IcebergTPCRawDecoder_module.cc.

 {
 
   //std::cout 
   //<< "   SequenceID = " << frag.sequenceID()
   //<< "   fragmentID = " << frag.fragmentID()
   //<< "   fragmentType = " << (unsigned)frag.type()
   //<< "   Timestamp =  " << frag.timestamp() << std::endl;
 
   if (_felix_hex_dump)
     {
       std::ios oldState(nullptr);
       oldState.copyfmt(std::cout);
 
       std::cout << "FELIX Fragment: all numbers in hex "  << std::hex
                 << "   SequenceID = " << frag.sequenceID()
                 << "   fragmentID = " << frag.fragmentID()
                 << "   fragmentType = " << (unsigned)frag.type()
                 << "   Timestamp =  " << frag.timestamp() << std::endl;
       std::cout << "Offset      Data";
       artdaq::Fragment fragloc(frag);
       unsigned char *dbegin = reinterpret_cast<unsigned char *>(fragloc.dataAddress());
       size_t dsize = fragloc.dataSizeBytes();
       size_t offcounter=0;
       for (size_t bcounter=0; bcounter<dsize;++bcounter)
         {
           if ( (offcounter % 8) == 0 )
             {
               std::cout << std::endl << std::hex << std::setfill('0') << std::setw(8) << offcounter << " ";
             }
           std::cout << std::hex << std::setfill('0') << std::setw(2) << (int) *dbegin << " ";
           dbegin++;
           offcounter++;
         }
       std::cout << std::endl;
       std::cout.copyfmt(oldState);
     }
 
   // check against _felix_fragment_type
   if(frag.type() != _felix_fragment_type) 
     {
       _DiscardedCorruptData = true;
       MF_LOG_WARNING("_process_FELIX_AUX:") << " FELIX fragment type " << (int) frag.type() << " doesn't match expected value: " << _felix_fragment_type << " Discarding FELIX fragment";
       return false;
     }
   //if (frag.fragmentID() == 501) 
   //  {
   //    std::cout << "Temporary hack: discarding fragment ID 501" << std::endl;
   //    return false;
   //  }
 
   art::ServiceHandle<dune::IcebergChannelMapService> channelMap;
 
   //Load overlay class.
 
   bool is14 = _felix_input_noncontainer_instance == "FRAME14" || _felix_input_container_instance == "FRAME14";
   std::unique_ptr<dune::FelixFragment> felixptr;
   std::unique_ptr<dune::Frame14FragmentUnordered> frame14ptr;
   if (is14)
     {
       std::unique_ptr<dune::Frame14FragmentUnordered> ftmp(new dune::Frame14FragmentUnordered(frag));
       frame14ptr = std::move(ftmp);
     }
   else
     {
       std::unique_ptr<dune::FelixFragment> ftmp(new dune::FelixFragment(frag));
       felixptr = std::move(ftmp);
     }
 
   //Get detector element numbers from the fragment
 
   uint8_t crate = 0;
   uint8_t slot  = 0;
   uint8_t fiber = 0;
 
   if (is14)
     {
       crate = frame14ptr->crate_no(0);
       slot  = frame14ptr->slot_no(0);
       fiber = frame14ptr->fiber_no(0); // decode this one later
       int frame_version = frame14ptr->frame_version(0);
       //std::cout << "ICEBERG frame_version, crate, slot, fiber, fragID: " << frame_version << " "
       // << (int) crate << " " << (int) slot << " " << (int) fiber << " " << (int) frag.fragmentID() << std::endl;
       if (frame_version == 0) 
         {
           std::cout << "ICEBERG frame_version = 0; skipping this fragment" << std::endl;
           return false;
         }
       fiber ++;  // read in 0 to 1, go from 1 to 2
 
       // temporary hacks
       crate = 1;
       //int fragid = (int) frag.fragmentID();
       // if (fragid == 600)
       //        {
       //          slot = 0;
       //          fiber = 1;
       //        }
       // if (fragid == 601)
       //        {
       //          slot = 0;
       //          fiber = 2;
       //        }
       // if (fragid == 700)
       //        {
       //          slot = 2;
       //          fiber = 1;
       //        }
       // if (fragid == 701)
       //        {
       //          slot = 2;
       //          fiber = 2;
       //        }
       // if (fragid == 800)
       //        {
       //          slot = 1;
       //          fiber = 1;
       //        }
       // if (fragid == 801)
       //        {
       //          slot = 1;
       //          fiber = 2;
       //        }
 
     }
   else
     {
       crate = felixptr->crate_no(0);
       slot  = felixptr->slot_no(0);
       fiber = felixptr->fiber_no(0); // decode this one later 
     }
 
   if (crate == 0 || crate > 6 || slot > 4) 
     {
       if (_felix_drop_frags_with_badcsf)  // we'll check the fiber later
         {
           _DiscardedCorruptData = true;
           MF_LOG_WARNING("_process_FELIX_AUX:") << "Invalid crate or slot: c=" << (int) crate << " s=" << (int) slot << " discarding FELIX data.";
           return false;
         }
       _KeptCorruptData = true;
     }
   if ( _felix_crate_number_to_check > -1 && (int) crate != _felix_crate_number_to_check )
     {
       if (_felix_enforce_exact_crate_number)
         {
           _DiscardedCorruptData = true;
           MF_LOG_WARNING("_process_FELIX_AUX:") << "Crate c=" << (int) crate << " mismatches required crate: " << _felix_crate_number_to_check << " discarding FELIX data.";
           return false;  
         }
       _KeptCorruptData = true;
     }
 
   if (_print_coldata_convert_count)
     {
       size_t first_coldata_convert_count = 0;
       if (is14)
         {
           first_coldata_convert_count = felixptr->coldata_convert_count(0,0);
         }
       else
         {
           first_coldata_convert_count = frame14ptr->total_frames();
         }
       std::cout << "FELIX Coldata convert count: " << (int) first_coldata_convert_count << std::endl;
     }
 
   //std::cout << "FELIX raw decoder crate, slot, fiber: " << (int) crate << " " << (int) slot << " " << (int) fiber << std::endl;
   // One frame contains 25 felix (20 ns-long) ticks.  A "frame" is an offline tick
   unsigned n_frames = 0;
   if (is14)
     {
       n_frames = frame14ptr->total_frames();
     }
   else
     {
       n_frames = felixptr->total_frames(); 
     }
 
   //std::cout<<" Nframes = "<<n_frames<<std::endl;
   //_h_nframes->Fill(n_frames);
   const unsigned n_channels = dune::FelixFrame::num_ch_per_frame;// should be 256
 
   if (n_frames*n_channels > _felix_buffer_size_checklimit)
     {
       if (_felix_check_buffer_size)
         {
           MF_LOG_WARNING("_process_FELIX_AUX:") << "n_channels*n_frames too large: " << n_channels << " * " << n_frames << " = " << 
             n_frames*n_channels << " larger than: " <<  _felix_buffer_size_checklimit << ".  Discarding this fragment";
           _DiscardedCorruptData = true;
           return false;
         }
       else
         {
           _KeptCorruptData = true;
         }
     }
 
   if(_make_histograms)
     {
       felixchans=felixchans+n_channels;
     }
 
   // this test does not yet exist for Frame14
 
   if (!is14)
     {
       for (unsigned int iframe=0; iframe<n_frames; ++iframe)
         {
           if ( felixptr->wib_errors(iframe) != 0)
             {
               if (_enforce_error_free )
                 {
                   _DiscardedCorruptData = true;
                   MF_LOG_WARNING("_process_FELIX_AUX:") << "WIB Errors on frame: " << iframe << " : " << felixptr->wib_errors(iframe)
                                                         << " Discarding Data";
                   error_counter++;
                   // drop just this fragment
                   //_discard_data = true;
                   return true;
                 }
               _KeptCorruptData = true;
             }
         }
     }
 
   // check optimization of this -- size not reserved
 
   raw::RawDigit::ADCvector_t v_adc;
   //v_adc.reserve(n_frames*n_channels);
   // Fill the adc vector.  
 
   for(unsigned ch = 0; ch < n_channels; ++ch) {
     v_adc.clear();
     //std::cout<<"crate:slot:fiber = "<<crate<<", "<<slot<<", "<<fiber<<std::endl;
     std::vector<dune::adc_t> waveform( is14 ? 
                                        frame14ptr->get_ADCs_by_channel(ch) : 
                                        felixptr->get_ADCs_by_channel(ch) );
     for(unsigned int nframe=0;nframe<waveform.size();nframe++){
       // if(ch==0 && nframe<100) {
       //  if(nframe==0) std::cout<<"Print the first 100 ADCs of Channel#1"<<std::endl;  
       //  std::cout<<waveform.at(nframe)<<"  ";
       //  if(nframe==99) std::cout<<std::endl;
       // }
       v_adc.push_back(waveform.at(nframe));  
     }
 
     // handle 256 channels on two fibers -- use the channel map that assumes 128 chans per fiber (=FEMB)
     
     unsigned int fiberloc = 0;
     if (fiber == 1) 
       {
         fiberloc = 1;
       }
     else if (fiber == 2)
       {
         fiberloc = 3;
       }
     else
       {
         MF_LOG_WARNING("_process_FELIX_AUX:") << " Fiber number " << (int) fiber << " is expected to be 1 or 2 -- revisit logic";
         fiberloc = 1;
         error_counter++;
         if (_felix_drop_frags_with_badcsf) 
           {
             MF_LOG_WARNING("_process_FELIX_AUX:") << " Dropping FELIX Data";
             return false;
           }
       }
 
     unsigned int chloc = ch;
     if (chloc > 127)
       {
         chloc -= 128;
         fiberloc++;
       }
     //unsigned int crateloc = crate;  
 
     // conversion of Run 7 slot and fibers to Run 5
 
     if (runNumber > 9745)
       {
         auto slotloc3 = slot;
         auto fiberloc3 = fiberloc;
 
         // conversion map
         // run 7 slot, run 7 fiber, run 5 slot, run 5 fiber
         unsigned int sfmap[10][4] = 
           {
             {4, 1,  0, 4},
             {3, 4,  1, 4},
             {3, 3,  2, 4},
             {3, 2,  0, 3},
             {3, 1,  1, 3},
             {0, 1,  0, 1},
             {0, 2,  2, 2},
             {0, 3,  1, 2},
             {0, 4,  0, 2},
             {1, 1,  2, 3}
           };
         bool found = false;
         for (size_t imap = 0; imap<10; ++imap)
           {
             if (slot == sfmap[imap][0] && fiberloc == sfmap[imap][1])
               {
                 slotloc3 = sfmap[imap][2];
                 fiberloc3 = sfmap[imap][3];
                 found = true;
                 break;
               }
             if (!found)
               {
                 std::cout << "Slot, fiber not understood in mapping from Run 7 to Run 5: " << (int) slot << " " << (int) fiberloc << std::endl;
                 slotloc3 = 0;
                 fiberloc3 = 4;
               }
           }
         slot = slotloc3;
         fiberloc = fiberloc3;
       }
 
     // inverted ordering on back side, Run 2c (=Run 3)
     // note Shekhar's FEMB number is fiber-1, and WIB is slot+1
     // This goes up to run 5
 
     auto slotloc2 = slot;
     auto fiberloc2 = fiberloc;
 
     if (runNumber > 2572)
       {
 
         if (slot == 0 && fiberloc == 4)
           {
             slotloc2 = 1;
             fiberloc2 = 3;
           }
         if (slot == 1 && fiberloc == 4)
           {
             slotloc2 = 0;
             fiberloc2 = 3;
           }
         if (slot == 1 && fiberloc == 3)
           {
             slotloc2 = 0;
             fiberloc2 = 4;
           }
         if (slot == 0 && fiberloc == 3)
           {
             slotloc2 = 1;
             fiberloc2 = 4;
           }
       }
 
     // skip the fake TPC data
 
     if ( slotloc2 == 1 && fiberloc2 == 1 ) 
       {
         continue;
       }
 
     if ( slotloc2 == 2 && fiberloc2 == 1 )
       {
         continue;
       }
 
     // for iceberg, hardcode the crate number to suppress warnings
     unsigned int offlineChannel = channelMap->GetOfflineNumberFromDetectorElements(1, slotloc2, fiberloc2, chloc, dune::IcebergChannelMapService::kFELIX); 
 
     //std::cout << "Calling channel map: " << (int) slotloc2 << " " << fiberloc2 << " " << chloc << " " << offlineChannel << std::endl;
 
     if ( v_adc.size() != _full_tick_count)
       {
         if (_enforce_full_tick_count)
           {
             MF_LOG_WARNING("_process_FELIX_AUX:") << "Nticks not the required value: " << v_adc.size() << " " 
                                                   << _full_tick_count << " Discarding Data";
             error_counter++;
             incorrect_ticks++;
             _discard_data = true;
             _DiscardedCorruptData = true;
             return true; 
           }
         _KeptCorruptData = true;
       }
 
     if (!_initialized_tick_count_this_event)
       {
         _initialized_tick_count_this_event = true;
         _tick_count_this_event = v_adc.size();
       }
     else
       {
         if (_enforce_same_tick_count)
           {
             if (v_adc.size() != _tick_count_this_event)
               {
                 MF_LOG_WARNING("_process_FELIX_AUX:") << "Nticks different for two channel streams: " << v_adc.size() 
                                                       << " vs " << _tick_count_this_event << " Discarding Data";
                 error_counter++;
                 _discard_data = true;
                 _DiscardedCorruptData = true;
                 return true;
               }
             _KeptCorruptData = true;
           }
       }
 
     if (offlineChannel < _duplicate_channel_checklist_size)
       {
         if (_duplicate_channel_checklist[offlineChannel])
           {
             if(_make_histograms)
               {
                 duplicate_channels++;
               }
             if (_enforce_no_duplicate_channels)
               {
                 MF_LOG_WARNING("_process_FELIX_AUX:") << "Duplicate Channel: " << offlineChannel
                                                       << " c:s:f:ich: " << (int) crate << " " << (int) slot << " " << (int) fiber << " " << (int) ch << " Discarding Data";
                 error_counter++;
                 _discard_data = true;
                 _DiscardedCorruptData = true;
                 return true;
               }
             _KeptCorruptData = true;        
           }
         _duplicate_channel_checklist[offlineChannel] = true;
       }
 
     float median=0;
     float sigma=0;
     computeMedianSigma(v_adc,median,sigma);
 
     auto n_ticks = v_adc.size();
     raw::Compress_t cflag=raw::kNone;
     if (_compress_Huffman)
       {
         cflag = raw::kHuffman;
         raw::Compress(v_adc,cflag);
       }
     // here n_ticks is the uncompressed size as required by the constructor
     raw::RawDigit raw_digit(offlineChannel, n_ticks, v_adc, cflag);
     raw_digit.SetPedestal(median,sigma);
     raw_digits.push_back(raw_digit);
 
     raw::RDTimeStamp rdtimestamp( is14 ? frame14ptr->timestamp() : felixptr->timestamp(),offlineChannel);
     timestamps.push_back(rdtimestamp);
 
     if (_make_histograms)
       {
         uint64_t last_timestamp = (is14 ? frame14ptr->timestamp(0) : felixptr->timestamp(0));
         for (size_t itick=1; itick<n_ticks; ++itick)
           {
             uint64_t timestamp = (is14 ? frame14ptr->timestamp(itick) : felixptr->timestamp(itick));
             uint64_t tdiff = 0;
             if (timestamp > last_timestamp)
               {
                 tdiff = timestamp - last_timestamp;
               }
             else
               {
                 tdiff = last_timestamp - timestamp;
               }
             fDeltaTimestamp->Fill(tdiff);
             last_timestamp = timestamp;
           }
       }
 
     //associate the raw digit and the timestamp data products
     auto const rawdigitptr = rdpm(raw_digits.size()-1);
     auto const rdtimestampptr = tspm(timestamps.size()-1);
     tsassocs.addSingle(rawdigitptr,rdtimestampptr);
   }
 
 
   return true;
 }

bool IcebergTPCRawDecoder::_process_RCE_AUX	(	const artdaq::Fragment &	frag,
		RawDigits &	raw_digits,
		RDTimeStamps &	timestamps,
		RDTsAssocs &	tsassocs,
		RDPmkr &	rdpm,
		TSPmkr &	tspm,
		uint32_t	runNumber
	)

private

FEMB 302 IS crate 3, slot 3, fiber 2

Definition at line 456 of file IcebergTPCRawDecoder_module.cc.

 {
 
   if (_rce_hex_dump)
     {
       std::ios oldState(nullptr);
       oldState.copyfmt(std::cout);
 
       std::cout << "RCE Fragment: all numbers in hex "  << std::hex
                 << "   SequenceID = " << frag.sequenceID()
                 << "   fragmentID = " << frag.fragmentID()
                 << "   fragmentType = " << (unsigned)frag.type()
                 << "   Timestamp =  " << frag.timestamp() << std::endl;
       std::cout << "Offset      Data";
       artdaq::Fragment fragloc(frag);
       unsigned char *dbegin = reinterpret_cast<unsigned char *>(fragloc.dataAddress());
       size_t dsize = fragloc.dataSizeBytes();
       size_t offcounter=0;
       for (size_t bcounter=0; bcounter<dsize;++bcounter)
         {
           if ( (offcounter % 8) == 0 )
             {
               std::cout << std::endl << std::hex << std::setfill('0') << std::setw(8) << offcounter << " ";
             }
           std::cout << std::hex << std::setfill('0') << std::setw(2) << (int) *dbegin << " ";
           dbegin++;
           offcounter++;
         }
       std::cout << std::endl;
       std::cout.copyfmt(oldState);
     }
 
   if(frag.type() != _rce_fragment_type) 
     {
       MF_LOG_WARNING("_process_RCE_AUX:") << " RCE fragment type " << (int) frag.type() << " doesn't match expected value: " << _rce_fragment_type << " Discarding RCE fragment";
       _DiscardedCorruptData = true;
       return false;
     }
   //MF_LOG_INFO("_Process_RCE_AUX")
   //<< "   SequenceID = " << frag.sequenceID()
   //<< "   fragmentID = " << frag.fragmentID()
   //<< "   fragmentType = " << (unsigned)frag.type()
   //<< "   Timestamp =  " << frag.timestamp();
   art::ServiceHandle<dune::IcebergChannelMapService> channelMap;
   
   artdaq::Fragment cfragloc(frag);
   size_t cdsize = cfragloc.dataSizeBytes();
   const uint64_t* cdptr = (uint64_t const*) (cfragloc.dataBeginBytes() + 12);  // see dune-raw-data/Overlays/RceFragment.cc
   HeaderFragmentUnpack const cdheader(cdptr);
   //bool isOkay = RceFragmentUnpack::isOkay(cdptr,cdsize+sizeof(cdheader));
   if (cdsize>16) cdsize -= 16;
   bool isOkay = RceFragmentUnpack::isOkay(cdptr,cdsize);
   if (!isOkay)
     {
       MF_LOG_WARNING("_process_RCE_AUX:") << "RCE Fragment isOkay failed: " << cdsize << " Discarding this fragment"; 
       error_counter++;
       _DiscardedCorruptData = true;
       return false; 
     }
   DataFragmentUnpack df(cdptr);
   //std::cout << "isTPpcNormal: " << df.isTpcNormal() << " isTpcDamaged: " << df.isTpcDamaged() << " isTpcEmpty: " << df.isTpcEmpty() << std::endl;
 
   dune::RceFragment rce(frag);
   if (_rce_save_frags_to_files)
     {
       TString outfilename="rce";
       outfilename += frag.sequenceID();
       outfilename += "_";
       outfilename += frag.fragmentID();
       outfilename+=".fragment";
       rce.save(outfilename.Data());
       std::cout << "Saved an RCE fragment with " << rce.size() << " streams: " << outfilename << std::endl;
     }
 
   uint32_t ch_counter = 0;
   for (int i = 0; i < rce.size(); ++i)
     {
       auto const * rce_stream = rce.get_stream(i);
       size_t n_ch = rce_stream->getNChannels();
       size_t n_ticks = rce_stream->getNTicks();
       auto const identifier = rce_stream->getIdentifier();
       uint32_t crateNumber = identifier.getCrate();
       uint32_t slotNumber = identifier.getSlot();
       uint32_t fiberNumber = identifier.getFiber();
 
       //std::cout << "Processing an RCE Stream: " << crateNumber << " " << slotNumber << " " << fiberNumber << " " << n_ticks << " " << n_ch << std::endl;
 
       if (crateNumber == 0 || crateNumber > 6 || slotNumber > 4 || fiberNumber == 0 || fiberNumber > 4)
         {
           if (_rce_drop_frags_with_badcsf)
             {
               MF_LOG_WARNING("_process_RCE:") << "Bad crate, slot, fiber number, discarding fragment on request: " 
                                               << crateNumber << " " << slotNumber << " " << fiberNumber;
               _DiscardedCorruptData = true;
               return false;
             }
           _KeptCorruptData = true;
         }
 
       // inverted ordering on back side, Run 2c (=Run 3)
       // note Shekhar's FEMB number is fiber-1, and WIB is slot+1
 
       if (runNumber > 2572)
         {
           auto oldfiber = fiberNumber;
           auto oldslot = slotNumber;
 
           if (oldslot == 0 && oldfiber == 4)
             {
               slotNumber = 1;
               fiberNumber = 3;
             }
           if (oldslot == 1 && oldfiber == 4)
             {
               slotNumber = 0;
               fiberNumber = 3;
             }
           if (oldslot == 1 && oldfiber == 3)
             {
               slotNumber = 0;
               fiberNumber = 4;
             }
           if (oldslot == 0 && oldfiber == 3)
             {
               slotNumber = 1;
               fiberNumber = 4;
             }
         }
 
       // two cable swaps on June 20, 2019, and go back to the original on Jan 22, 2020
 
       if (runNumber > 1530 && runNumber < 2572)
         {
           auto oldfiber = fiberNumber;
           auto oldslot = slotNumber;
 
           // second swap, June 21, 2019 -- see Slack
 
           if (oldslot == 2 && oldfiber == 1)
             {
               slotNumber = 2;
               fiberNumber = 3;
             }
           if (oldslot == 1 && oldfiber == 1)
             {
               slotNumber = 1;
               fiberNumber = 3;
             }
           if (oldslot == 2 && oldfiber == 3)
             {
               slotNumber = 2;
               fiberNumber = 1;
             }
           if (oldslot == 1 && oldfiber == 3)
             {
               slotNumber = 1;
               fiberNumber = 1;
             }
 
           oldfiber = fiberNumber;
           oldslot = slotNumber;
 
           if (oldslot == 0 && oldfiber == 4)
             {
               slotNumber = 1;
               fiberNumber = 3;
             }
           if (oldslot == 1 && oldfiber == 4)
             {
               slotNumber = 0;
               fiberNumber = 3;
             }
           if (oldslot == 0 && oldfiber == 3)
             {
               slotNumber = 1;
               fiberNumber = 4;
             }
           if (oldslot == 1 && oldfiber == 3)
             {
               slotNumber = 0;
               fiberNumber = 4;
             }
         }
 
       // skip the fake TPC data
 
       if ( slotNumber == 1 && fiberNumber == 1 ) 
         {
           continue;
         }
 
       if ( slotNumber == 2 && fiberNumber == 1 )
         {
           continue;
         }
 
       //std::cout << "  After cable swap : WIB: " << slotNumber+1 << " FEMB: " << fiberNumber-1 << std::endl;
 
       if (_print_coldata_convert_count)
         {
           std::cout << "Printing coldata convert counts for slot: " << slotNumber << " fiber: " << fiberNumber << std::endl;
           // from JJ's PdReaderTest.cc
           using namespace pdd;
           using namespace pdd::access;
           //bool printed=false;
           TpcStream const        &stream = rce_stream->getStream ();
           TpcToc           toc    (stream.getToc    ());
           TpcPacket        pktRec (stream.getPacket ());
           TpcPacketBody    pktBdy (pktRec.getRecord ());
           int   npkts = toc.getNPacketDscs ();
           for (int ipkt = 0; ipkt < npkts; ++ipkt)
             {
               TpcTocPacketDsc pktDsc (toc.getPacketDsc (ipkt));
               unsigned int      o64 = pktDsc.getOffset64 ();
               unsigned int  pktType = pktDsc.getType ();
               unsigned nWibFrames = pktDsc.getNWibFrames ();
               WibFrame const *wf = pktBdy.getWibFrames (pktType, o64);
               for (unsigned iwf = 0; iwf < nWibFrames; ++iwf)
                 {
                   auto const &colddata = wf->getColdData ();
                   auto cvt0 = colddata[0].getConvertCount ();
                   //auto cvt1 = colddata[1].getConvertCount ();
                   int diff = (int) cvt0 - (int) iwf; 
                   std::cout << "Packet: " << ipkt << " WIB frame: " << iwf << " RCE coldata convert count: " << cvt0 << " Difference: " << diff << std::endl;
                   //printed = true;
                   ++wf;  // in case we were looping over WIB frames, but let's stop at the first
                   //break;
                 }
               //if (printed) break;
             }
         }
 
 
       if(_make_histograms)
         {
           //log the participating RCE channels
           rcechans=rcechans+n_ch;
         }
 
       if (n_ticks != _full_tick_count)
         {
           if (_enforce_full_tick_count)
             {
               MF_LOG_WARNING("_process_RCE_AUX:") << "Nticks not the required value: " << n_ticks << " " 
                                                   << _full_tick_count << " Discarding Data";
               error_counter++;
               incorrect_ticks++;
               _discard_data = true;
               _DiscardedCorruptData = true;
               return false; 
             }
           _KeptCorruptData = true;
         }
 
       if (!_initialized_tick_count_this_event)
         {
           _initialized_tick_count_this_event = true;
           _tick_count_this_event = n_ticks;
         }
       else
         {
           if (n_ticks != _tick_count_this_event)
             {
               if (_enforce_same_tick_count)
                 {
                   MF_LOG_WARNING("_process_RCE_AUX:") << "Nticks different for two channel streams: " << n_ticks 
                                                       << " vs " << _tick_count_this_event << " Discarding Data";
                   error_counter++;
                   _discard_data = true;
                   _DiscardedCorruptData = true;
                   return false;
                 }
             }
           _KeptCorruptData = true;
         }
 
 
       //MF_LOG_INFO("_Process_RCE_AUX")
       //<< "RceFragment timestamp: " << rce_stream->getTimeStamp()
       //<< ", NChannels: " << n_ch
       //<< ", NTicks: " << n_ticks;
 
       // TODO -- speed this up!!  Remove one buffer copy
 
       size_t buffer_size = n_ch * n_ticks;
 
       if (buffer_size > _rce_buffer_size_checklimit)
         {
           if (_rce_check_buffer_size)
             {
               MF_LOG_WARNING("_process_RCE_AUX:") << "n_ch*nticks too large: " << n_ch << " * " << n_ticks << " = " << 
                 buffer_size << " larger than: " <<  _rce_buffer_size_checklimit << ".  Discarding this fragment";
               _DiscardedCorruptData = true;
               return false;
             }
           else
             {
               _KeptCorruptData = true;
             }
         }
 
       if (_buffer.capacity() < buffer_size)
         {
           //  MF_LOG_INFO("_process_RCE_AUX")
           //<< "Increase buffer size from " << _buffer.capacity()
           //<< " to " << buffer_size;
 
           _buffer.reserve(buffer_size);
         }
 
       int16_t* adcs = _buffer.data();
       bool sgmcdretcode = rce_stream->getMultiChannelData(adcs);
       if (!sgmcdretcode)
         {
           if (_enforce_error_free)
             {
               MF_LOG_WARNING("_process_RCE_AUX:") << "getMutliChannelData returns error flag: " 
                                                   << " c:s:f:ich: " << crateNumber << " " << slotNumber << " " << fiberNumber << " Discarding Data";
               error_counter++;
               _DiscardedCorruptData = true;
               return false;
             }
           _KeptCorruptData = true;
         }
 
       //std::cout << "RCE raw decoder trj -- adjusted slot and fibers after run 1332: " << crateNumber << " " << slotNumber << " " << fiberNumber << std::endl;
 
       
       raw::RawDigit::ADCvector_t v_adc;
       for (size_t i_ch = 0; i_ch < n_ch; i_ch++)
         {
           // hardcode crate number 1 so we don't get warning messages
           unsigned int offlineChannel = channelMap->GetOfflineNumberFromDetectorElements(1, slotNumber, fiberNumber, i_ch, dune::IcebergChannelMapService::kRCE);
 
           v_adc.clear();
 
           for (size_t i_tick = 0; i_tick < n_ticks; i_tick++)
             {
               v_adc.push_back(adcs[i_tick]);
             }
           adcs += n_ticks;
 
           ch_counter++;
 
           if (offlineChannel < _duplicate_channel_checklist_size)
             {
               if (_duplicate_channel_checklist[offlineChannel])
                 {
                   if(_make_histograms)
                     {
                       duplicate_channels++;
                     }
 
                   if (_enforce_no_duplicate_channels)
                     {
                       MF_LOG_WARNING("_process_RCE_AUX:") << "Duplicate Channel: " << offlineChannel
                                                           << " c:s:f:ich: " << crateNumber << " " << slotNumber << " " << fiberNumber << " " << i_ch << " Discarding Data";
                       error_counter++;
                       _discard_data = true;
                       _DiscardedCorruptData = true;
                       return false;
                     }
                   _KeptCorruptData = true;
                 }
               _duplicate_channel_checklist[offlineChannel] = true;
             }
           
           float median=0;
           float sigma=0;
           computeMedianSigma(v_adc,median,sigma);
 
           /// FEMB 302 IS crate 3, slot 3, fiber 2
 
           auto uncompressed_nticks = v_adc.size();  // can be different from n_ticks due to padding of FEMB 302
 
           raw::Compress_t cflag=raw::kNone;
           if (_compress_Huffman)
             {
               cflag = raw::kHuffman;
               raw::Compress(v_adc,cflag);
             }
           // here n_ticks is the uncompressed size as required by the constructor
           raw::RawDigit raw_digit(offlineChannel, uncompressed_nticks, v_adc, cflag);
           raw_digit.SetPedestal(median,sigma);
           raw_digits.push_back(raw_digit);  
 
           raw::RDTimeStamp rdtimestamp(rce_stream->getTimeStamp(),offlineChannel);
           timestamps.push_back(rdtimestamp);
 
           //associate the raw digit and the timestamp data products
           auto const rawdigitptr = rdpm(raw_digits.size()-1);
           auto const rdtimestampptr = tspm(timestamps.size()-1);
           tsassocs.addSingle(rawdigitptr,rdtimestampptr);            
         }
     }
 
   return true;
 }

bool IcebergTPCRawDecoder::_processFELIX	(	art::Event &	evt,
		RawDigits &	raw_digits,
		RDTimeStamps &	timestamps,
		RDTsAssocs &	tsassocs,
		RDPmkr &	rdpm,
		TSPmkr &	tspm
	)

private

Definition at line 864 of file IcebergTPCRawDecoder_module.cc.

 {
 
   // TODO Use MF_LOG_DEBUG
   //MF_LOG_INFO("_processFELIX") << "-------------------- FELIX RawDecoder -------------------";
 
   unsigned int n_felix_frags = 0;  
 
   art::InputTag itag3(_felix_input_label, _felix_input_container_instance);
   auto cont_frags = evt.getHandle<artdaq::Fragments>(itag3);
 
   bool have_data = false;
   bool have_data_nc = false;
 
   uint32_t runNumber = evt.run();
 
   if (cont_frags)
     {
       have_data = true;
 
       //size of felix fragments into histogram
       if(_make_histograms)
         {
           size_t felixbytes = 0;
           for (auto const& cont : *cont_frags)
             {
               felixbytes = felixbytes + (cont.sizeBytes());
             }
           fFragSizeFELIX->Fill(felixbytes);
         }
     
       for (auto const& cont : *cont_frags)
         {
           bool process_flag = true;
           if (cont.sizeBytes() < _felix_frag_small_size)
             {
               if ( _drop_events_with_small_felix_frags )
                 { 
                   MF_LOG_WARNING("_process_FELIX:") << " Small FELIX fragment size: " << cont.sizeBytes() << " Discarding Event on request.";
                   _discard_data = true; 
                   _DiscardedCorruptData = true;
                   evt.removeCachedProduct(cont_frags);
                   return false;
                 }
               if ( _drop_small_felix_frags )
                 { 
                   MF_LOG_WARNING("_process_FELIX:") << " Small FELIX fragment size: " << cont.sizeBytes() << " Discarding just this fragment on request.";
                   _DiscardedCorruptData = true;
                   process_flag = false;
                 }
               _KeptCorruptData = true;
             }
           if (process_flag)
             {
               artdaq::ContainerFragment cont_frag(cont);
               for (size_t ii = 0; ii < cont_frag.block_count(); ++ii)
                 {
                   if (_process_FELIX_AUX(*cont_frag[ii], raw_digits, timestamps, tsassocs, rdpm, tspm, runNumber)) ++n_felix_frags;
                 }
             }
         }
       evt.removeCachedProduct(cont_frags);
     }
 
   // noncontainer frags
 
   art::InputTag itag4(_felix_input_label, _felix_input_noncontainer_instance);
   auto frags = evt.getHandle<artdaq::Fragments>(itag4);
 
   if (frags)
     {
 
       if(_make_histograms)
         {
           size_t felixbytes = 0;
           for (auto const& frag: *frags)
             {
               felixbytes = felixbytes + (frag.sizeBytes());
             }
           fFragSizeFELIX->Fill(felixbytes);
         }
 
       for(auto const& frag: *frags)
         {
           bool process_flag = true;
           if (frag.sizeBytes() < _felix_frag_small_size)
             {
               if ( _drop_events_with_small_felix_frags )
                 { 
                   MF_LOG_WARNING("_process_FELIX:") << " Small FELIX fragment size: " << frag.sizeBytes() << " Discarding Event on request.";
                   _discard_data = true; 
                   _DiscardedCorruptData = true;
                   evt.removeCachedProduct(frags);
                   return false;
                 }
               if ( _drop_small_felix_frags )
                 { 
                   MF_LOG_WARNING("_process_FELIX:") << " Small FELIX fragment size: " << frag.sizeBytes() << " Discarding just this fragment on request.";
                   _DiscardedCorruptData = true;
                   process_flag = false;
                 }
               _KeptCorruptData = true;
             }
           if (process_flag)
             {
               if (_process_FELIX_AUX(frag, raw_digits,timestamps, tsassocs, rdpm, tspm, runNumber)) ++n_felix_frags;
             }
         }
       evt.removeCachedProduct(frags);
     }
 
 
   //MF_LOG_INFO("_processFELIX")
   //<< " Processed " << n_felix_frags
   //<< " FELIX Fragments, total size of raw digits is now "
   //<< raw_digits.size()
   //<< " RawDigits.";
 
   return have_data || have_data_nc;
 }

bool IcebergTPCRawDecoder::_processRCE	(	art::Event &	evt,
		RawDigits &	raw_digits,
		RDTimeStamps &	timestamps,
		RDTsAssocs &	tsassocs,
		RDPmkr &	rdpm,
		TSPmkr &	tspm
	)

private

Definition at line 335 of file IcebergTPCRawDecoder_module.cc.

 {
   size_t n_rce_frags = 0;
   art::InputTag itag1(_rce_input_label, _rce_input_container_instance);
   auto cont_frags = evt.getHandle<artdaq::Fragments>(itag1);
 
   bool have_data=false;
   bool have_data_nc=false;
 
   uint32_t runNumber = evt.run();
 
   if (cont_frags)
     {
       have_data = true;
 
       //size of RCE fragments into histogram
       if(_make_histograms)
         {
           size_t rcebytes = 0;
           for (auto const& cont : *cont_frags)
             {
               rcebytes = rcebytes + (cont.sizeBytes());
             }
           fFragSizeRCE->Fill(rcebytes);
         }
     
       for (auto const& cont : *cont_frags)
         {
           //std::cout << "RCE container fragment size bytes: " << cont.sizeBytes() << std::endl; 
           bool process_flag = true;
           if (cont.sizeBytes() < _rce_frag_small_size)
             {
               if ( _drop_events_with_small_rce_frags )
                 { 
                   MF_LOG_WARNING("_process_RCE:") << " Small RCE fragment size: " << cont.sizeBytes() << " Discarding Event on request.";
                   _discard_data = true; 
                   _DiscardedCorruptData = true;
                   evt.removeCachedProduct(cont_frags);
                   return false;
                 }
               if ( _drop_small_rce_frags )
                 { 
                   MF_LOG_WARNING("_process_RCE:") << " Small RCE fragment size: " << cont.sizeBytes() << " Discarding just this fragment on request.";
                   _DiscardedCorruptData = true;
                   process_flag = false;
                 }
               _KeptCorruptData = true;
             }
           if (process_flag)
             {
               artdaq::ContainerFragment cont_frag(cont);
               for (size_t ii = 0; ii < cont_frag.block_count(); ++ii)
                 {
                   if (_process_RCE_AUX(*cont_frag[ii], raw_digits, timestamps, tsassocs, rdpm, tspm, runNumber)) ++n_rce_frags;
                 }
             }
         }
       evt.removeCachedProduct(cont_frags);
     }
 
   //noncontainer frags
 
   art::InputTag itag2(_rce_input_label, _rce_input_noncontainer_instance);
   auto frags = evt.getHandle<artdaq::Fragments>(itag2);
 
   if (frags)
     {
       have_data_nc = true;
 
       //size of RCE fragments into histogram
       if(_make_histograms)
         {
           size_t rcebytes = 0;
           for (auto const& frag: *frags)
             {
               rcebytes = rcebytes + (frag.sizeBytes());
             }
           fFragSizeRCE->Fill(rcebytes);
         }
 
       for(auto const& frag: *frags)
         {
           bool process_flag = true;
           if (frag.sizeBytes() < _rce_frag_small_size)
             {
               if ( _drop_events_with_small_rce_frags )
                 { 
                   MF_LOG_WARNING("_process_RCE:") << " Small RCE fragment size: " << frag.sizeBytes() << " Discarding Event on request.";
                   _discard_data = true; 
                   _DiscardedCorruptData = true;
                   evt.removeCachedProduct(frags);
                   return false;
                 }
               if ( _drop_small_rce_frags )
                 { 
                   MF_LOG_WARNING("_process_RCE:") << " Small RCE fragment size: " << frag.sizeBytes() << " Discarding just this fragment on request.";
                   _DiscardedCorruptData = true;
                   process_flag = false;
                 }
               _KeptCorruptData = true;
             }
 
           if (process_flag)
             {
               if (_process_RCE_AUX(frag, raw_digits, timestamps,tsassocs, rdpm, tspm, runNumber)) ++n_rce_frags;
             }
         }
       evt.removeCachedProduct(frags);
     }
 
   //MF_LOG_INFO("_processRCE")
   //<< " Processed " << n_rce_frags
   //<< " RCE Fragments, making "
   //<< raw_digits.size()
   //<< " RawDigits.";
   return have_data || have_data_nc;
 }

void IcebergTPCRawDecoder::computeMedianSigma	(	raw::RawDigit::ADCvector_t &	v_adc,
		float &	median,
		float &	sigma
	)

private

Definition at line 1471 of file IcebergTPCRawDecoder_module.cc.

 {
   size_t asiz = v_adc.size();
   if (asiz == 0)
     {
       median = 0;
       sigma = 0;
     }
   else
     {
       // this is actually faster than the code below by about one second per event.
       // the RMS includes tails from bad samples and signals and may not be the best RMS calc.
 
       median = TMath::Median(asiz,v_adc.data());
       sigma = TMath::RMS(asiz,v_adc.data());
     }
 
   //  std::cout << "sigma: " << sigma << std::endl;
 }

IcebergTPCRawDecoder& IcebergTPCRawDecoder::operator= ( IcebergTPCRawDecoder const & )

delete

IcebergTPCRawDecoder& IcebergTPCRawDecoder::operator= ( IcebergTPCRawDecoder && )

delete

void IcebergTPCRawDecoder::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 265 of file IcebergTPCRawDecoder_module.cc.

 {
   RawDigits raw_digits;
   RDTimeStamps rd_timestamps;
   RDTsAssocs rd_ts_assocs;
 
   RDPmkr rdpm(e,_output_label);
   TSPmkr tspm(e,_output_label);
 
   error_counter = 0; //reset the errors to zero for each run
   incorrect_ticks = 0;
   duplicate_channels = 0;
   rcechans = 0;
   felixchans = 0;
 
   _initialized_tick_count_this_event = false;
   _discard_data = false;   // true if we're going to drop the whole event's worth of data
   _DiscardedCorruptData = false;   // can be set to true if we drop some of the event's data
   _KeptCorruptData = false;      // true if we identify a corruption candidate but are skipping the test to drop it
 
   for (size_t i=0; i<_duplicate_channel_checklist_size; ++i) _duplicate_channel_checklist[i] = false;
   
   _processRCE(e,raw_digits,rd_timestamps,rd_ts_assocs,rdpm,tspm);
   _processFELIX(e,raw_digits,rd_timestamps,rd_ts_assocs,rdpm,tspm);
 
   //Make the histograms for error checking. (other histograms are filled within the _process and _AUX functions)
   if(_make_histograms)
     {
       fErrorsNumber->Fill(log2(error_counter));
       fDuplicatesNumber->Fill(duplicate_channels);
       fIncorrectTickNumbers->Fill(log2(incorrect_ticks));
       fParticipFELIX->Fill(felixchans);
       fParticipRCE->Fill(rcechans);
       //fIncorrectTickNumbersZoomed->Fill(incorrect_ticks);
     }
 
   if (_enforce_full_channel_count && raw_digits.size() != _full_channel_count) 
     {
       MF_LOG_WARNING("IcebergTPCRawDecoder:") << "Wrong Total number of Channels " << raw_digits.size()  
                                               << " which is not " << _full_channel_count << ". Discarding Data";
       _DiscardedCorruptData = true;
       _discard_data = true;
     }
 
   if (_discard_data)
     {
       RawDigits empty_raw_digits;
       RDTimeStamps empty_rd_timestamps;
       RDTsAssocs empty_rd_ts_assocs;
       RDStatuses statuses;
       statuses.emplace_back(true,false,1);
       e.put(std::make_unique<decltype(empty_raw_digits)>(std::move(empty_raw_digits)),_output_label);
       e.put(std::make_unique<decltype(empty_rd_timestamps)>(std::move(empty_rd_timestamps)),_output_label);
       e.put(std::make_unique<decltype(empty_rd_ts_assocs)>(std::move(empty_rd_ts_assocs)),_output_label);
       e.put(std::make_unique<decltype(statuses)>(std::move(statuses)),_output_label);
     }
   else
     {
       RDStatuses statuses;
       unsigned int statword=0;
       if (_DiscardedCorruptData) statword |= 1;
       if (_KeptCorruptData) statword |= 2;
       statuses.emplace_back(_DiscardedCorruptData,_KeptCorruptData,statword);
       e.put(std::make_unique<decltype(raw_digits)>(std::move(raw_digits)),_output_label);
       e.put(std::make_unique<decltype(rd_timestamps)>(std::move(rd_timestamps)),_output_label);
       e.put(std::make_unique<decltype(rd_ts_assocs)>(std::move(rd_ts_assocs)),_output_label);
       e.put(std::make_unique<decltype(statuses)>(std::move(statuses)),_output_label);
     }
 }