CRT::CRTSim Class Reference

Inheritance diagram for CRT::CRTSim:

Public Member Functions
	CRTSim (fhicl::ParameterSet const &p)
	CRTSim (CRTSim const &)=delete
	CRTSim (CRTSim &&)=delete
CRTSim &	operator= (CRTSim const &)=delete
CRTSim &	operator= (CRTSim &&)=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 long long int	time
typedef unsigned short	adc_t

Private Attributes
art::InputTag	fSimLabel
double	fGeVToADC
time	fIntegrationTime
size_t	fReadoutWindowSize
size_t	fDeadtime
adc_t	fDACThreshold

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 CRTSim_module.cc.

Member Typedef Documentation

typedef unsigned short CRT::CRTSim::adc_t

private

Definition at line 89 of file CRTSim_module.cc.

typedef long long int CRT::CRTSim::time

private

Definition at line 88 of file CRTSim_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 118 of file CRTSim_module.cc.

                                            : EDProducer{p}, fSimLabel(p.get<art::InputTag>("SimLabel")), 
                                                              /*fScintillationYield(p.get<double>("ScintillationYield")), 
                                                              fQuantumEff(p.get<double>("QuantumEff")), 
                                                              fDummyGain(p.get<double>("DummyGain")),*/
                                                              fGeVToADC(p.get<double>("GeVToADC")),
                                                              fIntegrationTime(p.get<time>("IntegrationTime")), 
                                                              fReadoutWindowSize(p.get<size_t>("ReadoutWindowSize")), 
                                                              fDeadtime(p.get<size_t>("Deadtime")),
                                                              fDACThreshold(p.get<adc_t>("DACThreshold"))
{
  //Tell ART that I convert std::vector<AuxDetSimChannel> to CRT::Hits associated with raw::ExternalTriggers
  produces<std::vector<CRT::Trigger>>();
  produces<art::Assns<sim::AuxDetSimChannel, CRT::Trigger>>(); 
  consumes<std::vector<sim::AuxDetSimChannel>>(fSimLabel);
}

CRT::CRTSim::CRTSim ( CRTSim const &  )

delete

CRT::CRTSim::CRTSim ( CRTSim &&  )

delete

Member Function Documentation

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

delete

CRTSim& CRT::CRTSim::operator= ( CRTSim &&  )

delete

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

overridevirtual

Implements art::EDProducer.

Definition at line 135 of file CRTSim_module.cc.

{
  //Get collection of AuxDetSimChannel as input
  auto channels = e.getValidHandle<std::vector<sim::AuxDetSimChannel>>(fSimLabel);

  //Collections of CRT::Trigger and AuxDetSimChannel-CRT::Trigger associations that I will std::move() into e at the end of produce
  auto trigCol = std::make_unique<std::vector<CRT::Trigger>>();
  auto simToTrigger = std::make_unique<art::Assns<sim::AuxDetSimChannel, CRT::Trigger>>();

  //Utilities to go along with making Assns
  art::PtrMaker<sim::AuxDetSimChannel> makeSimPtr(e, channels.id());
  art::PtrMaker<CRT::Trigger> makeTrigPtr(e);

  //Get access to geometry for each event (TODO: -> subrun?) in case CRTs move later
  art::ServiceHandle<geo::Geometry> geom;

  //Group AuxDetSimChannels by module they came from for easier access later.  Storing AuxDetSimChannels as art::Ptrs so I can make Assns later.
  //TODO: I'm spending a lot of effort and confusing code on keeping track of sim::AuxDetSimChannels for Assns at the end of this module.  
  //      Are raw -> simulation Assns worth this much trouble?  Can I restructure my logic somehow to make this association more natural?  
  std::map<uint32_t, art::PtrVector<sim::AuxDetSimChannel>> moduleToChannels;
  for(size_t channelPos = 0; channelPos < channels->size(); ++channelPos)
  {
    const auto id = (*channels)[channelPos].AuxDetID();
    const auto& det = geom->AuxDet(id);
    if(det.Name().find("CRT") != std::string::npos) //If this is a CRT AuxDet
    {
      moduleToChannels[id].push_back(makeSimPtr(channelPos)); 
    } //End if this is a CRT AuxDet
  } //End for each simulated sensitive volume -> CRT strip

  MF_LOG_DEBUG("moduleToChannels") << "Got " << moduleToChannels.size() << " modules to process in detector simulation.\n";

  //For each CRT module
  for(auto& pair: moduleToChannels)
  {
    auto& module = pair.second;

    //Probably a good idea to write a function/algorithm class for each of these
    //TODO: Any leftover physics like Birks' Law?  I can handle Birks' Law more accurately if I 
    //      can get access to individual Geant steps.  
    //TODO: Read detector response from MariaDB database on DAQ machine?
    //TODO: Simulate detector response with quantum efficiency and detection efficiency?
    //TODO: simulate time -> timestamp.  Check out how 35t example in dunetpc/dunesim/DetSim does this.

    //Integrate "energy deposited" over time, then form a time-ordered sparse-vector (=std::map) of CRT::Hits
    //associated with the art::Ptr that produced each hit. Associating each hit with a time value gives me the 
    //option to skip over dead time later.  Each time bin contains up to one hit per channel.
    MF_LOG_DEBUG("moduleToChannels") << "Processing " << module.size() << " channels in module " << pair.first << "\n";
     std::map<time, std::vector<std::pair<CRT::Hit, art::Ptr<sim::AuxDetSimChannel>>>>timeToHits; //Mapping from integration time bin to list of hit-Ptr pairs
    for(const auto& channel: module)
    {
      MF_LOG_DEBUG("channels") << "Processing channel " << channel->AuxDetSensitiveID() << "\n";
      const auto& ides = channel->AuxDetIDEs();
      for(const auto& eDep: ides)
      {
        const size_t tAvg = (eDep.exitT+eDep.entryT)/2.;
        timeToHits[tAvg/fIntegrationTime].emplace_back(CRT::Hit(channel->AuxDetSensitiveID(), eDep.energyDeposited*fGeVToADC), channel);
        MF_LOG_DEBUG("TrueTimes") << "Assigned true hit at time " << tAvg << " to bin " << tAvg/fIntegrationTime << ".\n";
      }
    }
    //std::map<time, std::vector<std::pair<CRT::Hit, art::Ptr<sim::AuxDetSimChannel>>>> oldWindow;
    std::stringstream ss;
    auto lastTimeStamp=time(0);
    int i=0;
    for(auto window : timeToHits) 
    {
        if (i!=0 && (time(fDeadtime)+lastTimeStamp)>window.first && lastTimeStamp<window.first) continue;
        i++;
      const auto& hitsInWindow = window.second;
      const auto aboveThresh = std::find_if(hitsInWindow.begin(), hitsInWindow.end(), 
                                            [this](const auto& hitPair) { return hitPair.first.ADC() > fDACThreshold; });


if(aboveThresh != hitsInWindow.end()){

       std::vector<CRT::Hit> hits;
        const time timestamp = window.first; //Set timestamp before window is changed.
        const time end = (timestamp+fReadoutWindowSize);
        std::set<uint32_t> channelBusy; //A std::set contains only unique elements.  This set stores channels that have already been read out in 
                                        //this readout window and so are "busy" and cannot contribute any more hits. 
    for(auto busyCheckWindow : timeToHits){
        if (time(busyCheckWindow.first)<timestamp || time(busyCheckWindow.first)>end) continue;
          for(const auto& hitPair: window.second)
          {
            const auto channel = hitPair.first.Channel(); //TODO: Get channel number back without needing art::Ptr here.  
                                                                    //      Maybe store crt::Hits.
            if(channelBusy.insert(channel).second) //If this channel hasn't already contributed to this readout window
            {
              hits.push_back(hitPair.first);
              simToTrigger->addSingle(hitPair.second, makeTrigPtr(trigCol->size()-1)); 
                }
                }       
        }
        //std::cout<<"Hits Generated:"<<hits.size()<<std::endl;
        lastTimeStamp=window.first;

        MF_LOG_DEBUG("CreateTrigger") << "Creating CRT::Trigger...\n";
        trigCol->emplace_back(pair.first, timestamp*fIntegrationTime, std::move(hits)); 
        } // For each readout with a triggerable hit
    }  // For each time window

  } //For each CRT module

  //Put Triggers and Assns into the event
  MF_LOG_DEBUG("CreateTrigger") << "Putting " << trigCol->size() << " CRT::Triggers into the event at the end of analyze().\n";
  e.put(std::move(trigCol));
  e.put(std::move(simToTrigger));
}

Member Data Documentation

adc_t CRT::CRTSim::fDACThreshold

private

Definition at line 111 of file CRTSim_module.cc.

size_t CRT::CRTSim::fDeadtime

private

Definition at line 110 of file CRTSim_module.cc.

double CRT::CRTSim::fGeVToADC

private

Definition at line 102 of file CRTSim_module.cc.

time CRT::CRTSim::fIntegrationTime

private

Definition at line 107 of file CRTSim_module.cc.

size_t CRT::CRTSim::fReadoutWindowSize

private

Definition at line 108 of file CRTSim_module.cc.

art::InputTag CRT::CRTSim::fSimLabel

private

Definition at line 92 of file CRTSim_module.cc.

---

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

• duneprototypes/duneprototypes/Protodune/singlephase/CRT/CRTSim_module.cc