HitMerger Class Reference

Inheritance diagram for HitMerger:

Public Member Functions
	HitMerger (fhicl::ParameterSet const &pset)
virtual	~HitMerger ()
	Destructor. More...
virtual void	reconfigure (fhicl::ParameterSet const &pset)
virtual void	produce (art::Event &e)
virtual void	beginJob ()
	Begin job method. More...
virtual void	endJob ()
	End job method. More...

Private Types
using	RecobHitToPtrMap = std::unordered_map< const recob::Hit *, art::Ptr< recob::Hit >>
using	HitPtrVector = std::vector< art::Ptr< recob::Hit >>

Private Member Functions
void	makeWireAssns (const art::Event &, art::Assns< recob::Wire, recob::Hit > &, RecobHitToPtrMap &) const
	Create recob::Wire to recob::Hit associations. More...
void	makeRawDigitAssns (const art::Event &, art::Assns< raw::RawDigit, recob::Hit > &, RecobHitToPtrMap &) const
	Create raw::RawDigit to recob::Hit associations. More...

Private Attributes
std::vector< art::InputTag >	HitMergerfHitProducerLabelVec
	The full collection of hits. More...

Detailed Description

Definition at line 40 of file HitMerger_module.cc.

Member Typedef Documentation

using HitMerger::HitPtrVector = std::vector<art::Ptr<recob::Hit>>

private

Definition at line 68 of file HitMerger_module.cc.

using HitMerger::RecobHitToPtrMap = std::unordered_map<const recob::Hit*, art::Ptr<recob::Hit>>

private

Definition at line 55 of file HitMerger_module.cc.

Constructor & Destructor Documentation

HitMerger::HitMerger ( fhicl::ParameterSet const &  pset )

explicit

Constructor.

Arguments:

pset - Fcl parameters.

Definition at line 83 of file HitMerger_module.cc.

                                                   : EDProducer{pset}
{
    reconfigure(pset);
    
    produces< std::vector<recob::Hit>>();
    produces< art::Assns<recob::Wire,   recob::Hit>>();
    produces< art::Assns<raw::RawDigit, recob::Hit>>();
    
    // Report.
    mf::LogInfo("HitMerger") << "HitMerger configured\n";
}

HitMerger::~HitMerger ( )

virtual

Destructor.

Definition at line 97 of file HitMerger_module.cc.

{}

Member Function Documentation

void HitMerger::beginJob ( )

virtual

Begin job method.

Definition at line 114 of file HitMerger_module.cc.

{
//    auto const* detp = lar::providerFrom<detinfo::DetectorPropertiesService>();
//    auto const* geo  = lar::providerFrom<geo::Geometry>();
//    auto const* ts   = lar::providerFrom<detinfo::DetectorClocksService>();
}

void HitMerger::endJob ( )

virtual

End job method.

Definition at line 270 of file HitMerger_module.cc.

{
    return;
}

void HitMerger::makeRawDigitAssns ( const art::Event &  evt, art::Assns< raw::RawDigit, recob::Hit > &  rawDigitAssns, RecobHitToPtrMap &  recobHitPtrMap  ) const

private

Create raw::RawDigit to recob::Hit associations.

Definition at line 226 of file HitMerger_module.cc.

{
    // Let's make sure the input associations container is empty
    rawDigitAssns = art::Assns<raw::RawDigit, recob::Hit>();
    
    // First task is to recover all of the previous wire <--> hit associations and map them by channel number
    // Create the temporary container
    std::unordered_map<raw::ChannelID_t, art::Ptr<raw::RawDigit>> channelToRawDigitMap;
    
    // Go through the list of input sources and fill out the map
    for(const auto& inputTag : HitMergerfHitProducerLabelVec)
    {
        art::ValidHandle<std::vector<recob::Hit>> hitHandle = evt.getValidHandle<std::vector<recob::Hit>>(inputTag);
        
        art::FindOneP<raw::RawDigit> hitToRawDigitAssns(hitHandle, evt, inputTag);
        
        if (hitToRawDigitAssns.isValid())
        {
            for(size_t rawDigitIdx = 0; rawDigitIdx < hitToRawDigitAssns.size(); rawDigitIdx++)
            {
                art::Ptr<raw::RawDigit> rawDigit = hitToRawDigitAssns.at(rawDigitIdx);
                
                channelToRawDigitMap[rawDigit->Channel()] = rawDigit;
            }
        }
    }
    
    // Now fill the container
    for(const auto& hitPtrPair : recobHitPtrMap)
    {
        raw::ChannelID_t channel = hitPtrPair.first->Channel();
        
        std::unordered_map<raw::ChannelID_t, art::Ptr<raw::RawDigit>>::iterator chanRawDigitItr = channelToRawDigitMap.find(channel);
        
        if (!(chanRawDigitItr != channelToRawDigitMap.end())) continue;
        
        rawDigitAssns.addSingle(chanRawDigitItr->second, hitPtrPair.second);
    }
    
    return;
}

void HitMerger::makeWireAssns ( const art::Event &  evt, art::Assns< recob::Wire, recob::Hit > &  wireAssns, RecobHitToPtrMap &  recobHitPtrMap  ) const

private

Create recob::Wire to recob::Hit associations.

Definition at line 184 of file HitMerger_module.cc.

{
    // Let's make sure the input associations container is empty
    wireAssns = art::Assns<recob::Wire, recob::Hit>();
    
    // First task is to recover all of the previous wire <--> hit associations and map them by channel number
    // Create the temporary container
    std::unordered_map<raw::ChannelID_t, art::Ptr<recob::Wire>> channelToWireMap;
    
    // Go through the list of input sources and fill out the map
    for(const auto& inputTag : HitMergerfHitProducerLabelVec)
    {
        art::ValidHandle<std::vector<recob::Hit>> hitHandle = evt.getValidHandle<std::vector<recob::Hit>>(inputTag);
        
        art::FindOneP<recob::Wire> hitToWireAssns(hitHandle, evt, inputTag);
        
        if (hitToWireAssns.isValid())
        {
            for(size_t wireIdx = 0; wireIdx < hitToWireAssns.size(); wireIdx++)
            {
                art::Ptr<recob::Wire> wire = hitToWireAssns.at(wireIdx);
                
                channelToWireMap[wire->Channel()] = wire;
            }
        }
    }
    
    // Now fill the container
    for(const auto& hitPtrPair : recobHitPtrMap)
    {
        raw::ChannelID_t channel = hitPtrPair.first->Channel();
        
        std::unordered_map<raw::ChannelID_t, art::Ptr<recob::Wire>>::iterator chanWireItr = channelToWireMap.find(channel);
        
        if (!(chanWireItr != channelToWireMap.end())) continue;
        
        wireAssns.addSingle(chanWireItr->second, hitPtrPair.second);
    }
    
    return;
}

void HitMerger::produce ( art::Event &  evt )

virtual

Produce method.

Arguments:

evt - Art event.

This is the primary method. The goal is to merge input hit collections and output a single hit collection on the backside.

Associations with wires.

Associations with raw digits.

Definition at line 131 of file HitMerger_module.cc.

{
    // container for our new hit collection
    std::unique_ptr<std::vector<recob::Hit>> outputHitPtrVec(new std::vector<recob::Hit>);
    
    /// Associations with wires.
    std::unique_ptr<art::Assns<recob::Wire, recob::Hit>> wireAssns(new art::Assns<recob::Wire, recob::Hit>);
    
    /// Associations with raw digits.
    std::unique_ptr<art::Assns<raw::RawDigit, recob::Hit>> rawDigitAssns(new art::Assns<raw::RawDigit, recob::Hit>);

    RecobHitToPtrMap recobHitToPtrMap;
    
    // Use this handy art utility to make art::Ptr objects to the new recob::Hits for use in the output phase
    art::PtrMaker<recob::Hit> ptrMaker(evt);
    
    // Outside loop over the input hit producers
    for(const auto& inputTag : HitMergerfHitProducerLabelVec)
    {
        // Start by looking up the original hits
        art::Handle< std::vector<recob::Hit> > hitHandle;
        evt.getByLabel(inputTag, hitHandle);
        
        for(size_t hitIdx = 0; hitIdx < hitHandle->size(); hitIdx++)
        {
            art::Ptr<recob::Hit> hitPtr(hitHandle,hitIdx);
            
            const recob::Hit* hit2D = hitPtr.get();
            
            // Create and save the new recob::Hit with the correct WireID
            outputHitPtrVec->emplace_back(recob::HitCreator(*hit2D, hit2D->WireID()).copy());
            
            // Recover a pointer to it...
            recob::Hit* newHit = &outputHitPtrVec->back();
            
            // Create a mapping from this hit to an art Ptr representing it
            recobHitToPtrMap[newHit] = ptrMaker(outputHitPtrVec->size()-1);
        }
    }
    
    // Set up to make the associations (if desired)
    makeWireAssns(evt, *wireAssns, recobHitToPtrMap);
    
    makeRawDigitAssns(evt, *rawDigitAssns, recobHitToPtrMap);
    
    // Move everything into the event
    evt.put(std::move(outputHitPtrVec));
    evt.put(std::move(wireAssns));
    evt.put(std::move(rawDigitAssns));
    
    return;
}

void HitMerger::reconfigure ( fhicl::ParameterSet const &  pset )

virtual

Reconfigure method.

Arguments:

pset - Fcl parameter set.

Definition at line 107 of file HitMerger_module.cc.

{
    HitMergerfHitProducerLabelVec = pset.get<std::vector<art::InputTag>>("HitProducerLabelVec");
}

Member Data Documentation

std::vector<art::InputTag> HitMerger::HitMergerfHitProducerLabelVec

private

The full collection of hits.

Definition at line 71 of file HitMerger_module.cc.

---

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

• HitMerger_module.cc