CRT::CRTRawDecoder Class Reference

Inheritance diagram for CRT::CRTRawDecoder:

Classes
struct	PerModule

Public Member Functions
	CRTRawDecoder (fhicl::ParameterSet const &p)
	CRTRawDecoder (CRTRawDecoder const &)=delete
	CRTRawDecoder (CRTRawDecoder &&)=delete
CRTRawDecoder &	operator= (CRTRawDecoder const &)=delete
CRTRawDecoder &	operator= (CRTRawDecoder &&)=delete
void	produce (art::Event &e) override
void	beginJob () 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 Member Functions
void	FragmentToTriggers (const artdaq::Fragment &artFrag, std::unique_ptr< std::vector< CRT::Trigger >> &triggers)
void	SetEarliestTime (const artdaq::Fragment &frag)
void	createSyncPlots ()

Private Attributes
const art::InputTag	fFragTag
const bool	fLookForContainer
const bool	fMatchOfflineMapping
std::vector< size_t >	fChannelMap
std::vector< PerModule >	fSyncPlots
uint64_t	fEarliestTime

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 48 of file CRTRawDecoder_module.cc.

Constructor & Destructor Documentation

CRT::CRTRawDecoder::CRTRawDecoder ( fhicl::ParameterSet const &  p )

explicit

Definition at line 115 of file CRTRawDecoder_module.cc.

                                                         : EDProducer{p}, fFragTag(p.get<std::string>("RawDataTag")), 
                                                               fLookForContainer(p.get<bool>("LookForContainer", false)),
                                                               fMatchOfflineMapping(p.get<bool>("MatchOfflineMapping", true)),
                                                               fEarliestTime(std::numeric_limits<decltype(fEarliestTime)>::max())
  {
    // Call appropriate produces<>() functions here.
    produces<std::vector<CRT::Trigger>>();
    consumes<std::vector<artdaq::Fragment>>(fFragTag);
 
    //Register callback to make new plots on every file
    art::ServiceHandle<art::TFileService> tfs;
    tfs->registerFileSwitchCallback(this, &CRTRawDecoder::createSyncPlots);
  }

CRT::CRTRawDecoder::CRTRawDecoder ( CRTRawDecoder const &  )

delete

CRT::CRTRawDecoder::CRTRawDecoder ( CRTRawDecoder &&  )

delete

Member Function Documentation

void CRT::CRTRawDecoder::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 277 of file CRTRawDecoder_module.cc.

  {
    createSyncPlots();
  
    //Set up channel mapping base on user configuration
    art::ServiceHandle<geo::Geometry> geom;
    const auto nModules = geom->NAuxDets();
    if(fMatchOfflineMapping) 
    {
//      std::vector<const geo::AuxDetGeo*> auxDets; //The function to retrieve this vector seems to have been made protected
//      for(size_t auxDet = 0; auxDet < nModules; ++auxDet) auxDets.push_back(&geom->AuxDet(auxDet));
//
//      fChannelMap = CRTSorter::Mapping(auxDets); //Match whatever the current AuxDet sorter does.  
      //Based on v6 geometry (TY)
      fChannelMap.push_back(24);
      fChannelMap.push_back(25);
      fChannelMap.push_back(30);
      fChannelMap.push_back(18);
      fChannelMap.push_back(15);
      fChannelMap.push_back(7);
      fChannelMap.push_back(13);
      fChannelMap.push_back(12);
      fChannelMap.push_back(11);
      fChannelMap.push_back(10);
      fChannelMap.push_back(6);
      fChannelMap.push_back(14);
      fChannelMap.push_back(19);
      fChannelMap.push_back(31);
      fChannelMap.push_back(26);
      fChannelMap.push_back(27);
      fChannelMap.push_back(22);
      fChannelMap.push_back(23);
      fChannelMap.push_back(29);
      fChannelMap.push_back(17);
      fChannelMap.push_back(8);
      fChannelMap.push_back(0);
      fChannelMap.push_back(3);
      fChannelMap.push_back(2);
      fChannelMap.push_back(5);
      fChannelMap.push_back(4);
      fChannelMap.push_back(1);
      fChannelMap.push_back(9);
      fChannelMap.push_back(16);
      fChannelMap.push_back(28);
      fChannelMap.push_back(20);
      fChannelMap.push_back(21);
    }
    else 
    {
      for(size_t module = 0; module < nModules; ++module) fChannelMap.push_back(module); //Map each index to itself
    }
  }

void CRT::CRTRawDecoder::createSyncPlots ( )

private

Definition at line 330 of file CRTRawDecoder_module.cc.

  {
    const auto nModules = art::ServiceHandle<geo::Geometry>()->NAuxDets();
    art::ServiceHandle<art::TFileService> tfs;
    fSyncPlots.clear(); //Clear any previous pointers to histograms.  Some TFile owned them.  
    for(size_t module = 0; module < nModules; ++module) fSyncPlots.emplace_back(*tfs, module); //32 modules in the ProtoDUNE-SP CRT
  }

void CRT::CRTRawDecoder::FragmentToTriggers ( const artdaq::Fragment &  artFrag, std::unique_ptr< std::vector< CRT::Trigger >> &  triggers  )

private

Definition at line 129 of file CRTRawDecoder_module.cc.

  {
    CRT::Fragment frag(artFrag);
                                                                                                                                                   
    MF_LOG_DEBUG("CRTGoodEvent") << "Is this Fragment good?  " << ((frag.good_event())?"true":"false") << "\n";
    /*frag.print_header();
    frag.print_hits();*/
                                                                                                                                                   
    std::vector<CRT::Hit> hits;
                                                                                                                                                   
    //Make a CRT::Hit from each non-zero ADC value in this Fragment
    for(size_t hitNum = 0; hitNum < frag.num_hits(); ++hitNum)
    {
      const auto hit = *(frag.hit(hitNum));
      MF_LOG_DEBUG("CRTRaw") << "Channel: " << (int)(hit.channel) << "\n"
                          << "ADC: " << hit.adc << "\n";
      //Determine the offline channel number for each strip
      size_t offline_channel = hit.channel;
      if (frag.module_num() == 14 ||
          frag.module_num() == 15 ||
          frag.module_num() == 8 ||
          frag.module_num() == 9 ||
          frag.module_num() == 10 ||
          frag.module_num() == 11 ||
          frag.module_num() == 4 ||
          frag.module_num() == 5 ||
          frag.module_num() == 30 ||
          frag.module_num() == 31 ||
          frag.module_num() == 24 ||
          frag.module_num() == 25 ||
          frag.module_num() == 26 ||
          frag.module_num() == 27 ||
          frag.module_num() == 20 ||
          frag.module_num() == 21){ //Strips need to be flipped (TY)
        if (hit.channel<32){
          offline_channel = (31-hit.channel)*2;
        }
        else{
          offline_channel = (63-hit.channel)*2+1;
        }
      }
      else{//Strips do not need to be flipped
        if (hit.channel<32){
          offline_channel = hit.channel*2;
        }
        else{
          offline_channel = (hit.channel-32)*2+1;
        }
      }
      //Flip the two layers
      if (offline_channel%2==0) ++offline_channel;
      else --offline_channel;
      hits.emplace_back(offline_channel, hit.adc);
      //MF_LOG_DEBUG("CRT Hits") CRT::operator << hits.back() << "\n"; //TODO: Some function template from the message service interferes with my  
                                                                    //      function template from namespace CRT.  using namespace CRT seems like 
                                                                    //      it should solve this, but it doesn't seem to.
    }
                                                                                                                                                   
    MF_LOG_DEBUG("CRTFragments") << "Module: " << frag.module_num() << "\n"
                              << "Number of hits: " << frag.num_hits() << "\n"
                              << "Fifty MHz time: " << frag.fifty_mhz_time() << "\n";
   
    try
    {  
      triggers->emplace_back(fChannelMap.at(frag.module_num()), frag.fifty_mhz_time(), std::move(hits)); 
    }
    catch(const std::out_of_range& e)
    {
      mf::LogWarning("Bad CRT Channel") << "Got CRT channel number " << frag.module_num() << " that is greater than the number of boards"
                                        << " in the channel map: " << fChannelMap.size() << ".  Throwing out this Trigger.\n";
    }
    
    //Make diagnostic plots for sync pulses
    const auto& plots = fSyncPlots[frag.module_num()];
    const double deltaT = (frag.fifty_mhz_time() - fEarliestTime)*1.6e-8; //TODO: Get size of clock ticks from a service
    if(deltaT > 0 && deltaT < 1e6) //Ignore time differences less than 1s and greater than 1 day
                                   //TODO: Understand why these cases come up
    {
      plots.fLowerTimeVersusTime->SetPoint(plots.fLowerTimeVersusTime->GetN(), deltaT, frag.raw_backend_time());
    }
    else
    {
      mf::LogWarning("SyncPlots") << "Got time difference " << deltaT << " that was not included in sync plots.\n"
                                  << "lhs is " << frag.fifty_mhz_time() << ", and rhs is " << fEarliestTime << ".\n"
                                  << "Hardware raw time is " << frag.raw_backend_time() << ".\n";
    }
  }

CRTRawDecoder& CRT::CRTRawDecoder::operator= ( CRTRawDecoder const &  )

delete

CRTRawDecoder& CRT::CRTRawDecoder::operator= ( CRTRawDecoder &&  )

delete

void CRT::CRTRawDecoder::produce ( art::Event &  e )

overridevirtual

Implements art::EDProducer.

Definition at line 224 of file CRTRawDecoder_module.cc.

  {
    //Create an empty container of CRT::Triggers.  Any Triggers in this container will be put into the 
    //event at the end of produce.  I will try to fill this container, but just not produce any CRT::Triggers 
    //if there are no input artdaq::Fragments.  
    auto triggers = std::make_unique<std::vector<CRT::Trigger>>();

    try
    {
      //Try to get artdaq::Fragments produced from CRT data.  The following line is the reason for 
      //this try-catch block.  I don't expect anything else to throw a cet::Exception.
      const auto& fragHandle = e.getValidHandle<std::vector<artdaq::Fragment>>(fFragTag);

      if(fLookForContainer)
      {
        //If this is the first event, set fEarliestTime
        if(fEarliestTime == std::numeric_limits<decltype(fEarliestTime)>::max())
        {
          for(const auto& frag: *fragHandle) 
          {
            artdaq::ContainerFragment container(frag);
            for(size_t pos = 0; pos < container.block_count(); ++pos) SetEarliestTime(*container[pos]);
          }
        }

        for(const auto& artFrag: *fragHandle)
        {
          artdaq::ContainerFragment container(artFrag);
          for(size_t pos = 0; pos < container.block_count(); ++pos) FragmentToTriggers(*container[pos], triggers); 
        }
      }
      else
      {
        //If this is the first event, set fEarliestTime
        if(fEarliestTime == std::numeric_limits<decltype(fEarliestTime)>::max())
        {
          for(const auto& frag: *fragHandle) SetEarliestTime(frag);
        }

        //Convert each fragment into a CRT::Trigger.
        for(const auto& artFrag: *fragHandle) FragmentToTriggers(artFrag, triggers);
      }
    }
    catch(const cet::exception& exc) //If there are no artdaq::Fragments in this Event, just add an empty container of CRT::Triggers.
    {
      mf::LogWarning("MissingData") << "No artdaq::Fragments produced by " << fFragTag << " in this event, so "
                                    << "not doing anything.\n";
    }

    //Put a vector of CRT::Triggers into this Event for other modules to read.
    e.put(std::move(triggers));
  }

void CRT::CRTRawDecoder::SetEarliestTime ( const artdaq::Fragment &  frag )

private

Definition at line 217 of file CRTRawDecoder_module.cc.

  {
    CRT::Fragment crt(frag);
    if(crt.fifty_mhz_time() < fEarliestTime) fEarliestTime = crt.fifty_mhz_time();
  }

Member Data Documentation

std::vector<size_t> CRT::CRTRawDecoder::fChannelMap

private

Definition at line 86 of file CRTRawDecoder_module.cc.

uint64_t CRT::CRTRawDecoder::fEarliestTime

private

Definition at line 111 of file CRTRawDecoder_module.cc.

const art::InputTag CRT::CRTRawDecoder::fFragTag

private

Definition at line 72 of file CRTRawDecoder_module.cc.

const bool CRT::CRTRawDecoder::fLookForContainer

private

Definition at line 75 of file CRTRawDecoder_module.cc.

const bool CRT::CRTRawDecoder::fMatchOfflineMapping

private

Definition at line 83 of file CRTRawDecoder_module.cc.

std::vector<PerModule> CRT::CRTRawDecoder::fSyncPlots

private

Definition at line 110 of file CRTRawDecoder_module.cc.

---

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

• duneprototypes/duneprototypes/Protodune/singlephase/RawDecoding/CRTRawDecoder_module.cc