HitFinderAnalysis::HitFinderAnalysis Class Reference

Inheritance diagram for HitFinderAnalysis::HitFinderAnalysis:

Public Member Functions
	HitFinderAnalysis (fhicl::ParameterSet const &pset)
	Constructor. More...
	~HitFinderAnalysis ()
	Destructor. More...
void	configure (fhicl::ParameterSet const &pset) override
void	initializeHists (art::ServiceHandle< art::TFileService > &, const std::string &) override
	Interface for initializing the histograms to be filled. More...
void	initializeTuple (TTree *) override
	Interface for initializing the tuple variables. More...
void	endJob (int numEvents) override
	Interface for method to executve at the end of run processing. More...
void	fillHistograms (const art::Event &) const override
	Interface for filling histograms. More...
Public Member Functions inherited from IHitEfficiencyHistogramTool
virtual	~IHitEfficiencyHistogramTool () noexcept=default
	Virtual Destructor. More...
virtual	~IHitEfficiencyHistogramTool () noexcept=default
	Virtual Destructor. More...

Private Member Functions
void	clear () const

Private Attributes
art::InputTag	fRawDigitProducerLabel
art::InputTag	fWireProducerLabel
art::InputTag	fHitProducerLabel
art::InputTag	fMCParticleProducerLabel
art::InputTag	fSimChannelProducerLabel
art::InputTag	fBadChannelProducerLabel
bool	fUseBadChannelDB
std::string	fLocalDirName
	Fraction for truncated mean. More...
std::vector< int >	fOffsetVec
	Allow offsets for each plane. More...
std::vector< float >	fSigmaVec
	Window size for matching to SimChannels. More...
int	fMinAllowedChanStatus
	Don't consider channels with lower status. More...
std::vector< TH1F * >	fTotalElectronsHistVec
std::vector< TH1F * >	fMaxElectronsHistVec
std::vector< TH1F * >	fHitElectronsVec
std::vector< TH1F * >	fHitSumADCVec
std::vector< TH1F * >	fHitIntegralHistVec
std::vector< TH1F * >	fHitPulseHeightVec
std::vector< TH1F * >	fHitPulseWidthVec
std::vector< TH1F * >	fSimNumTDCVec
std::vector< TH1F * >	fHitNumTDCVec
std::vector< TH1F * >	fSnippetLenVec
std::vector< TH1F * >	fNMatchedHitVec
std::vector< TH1F * >	fDeltaMidTDCVec
std::vector< TProfile * >	fWireEfficVec
std::vector< TProfile * >	fWireEfficPHVec
std::vector< TProfile * >	fHitEfficVec
std::vector< TProfile * >	fHitEfficPHVec
std::vector< TProfile * >	fHitEfficXZVec
std::vector< TProfile * >	fHitEfficRMSVec
std::vector< TProfile * >	fCosXZvRMSVec
std::vector< TProfile2D * >	fHitENEvXZVec
std::vector< TH1F * >	fSimDivHitChgVec
std::vector< TH1F * >	fSimDivHitChg1Vec
std::vector< TH2F * >	fHitVsSimChgVec
std::vector< TH2F * >	fHitVsSimIntVec
std::vector< TH2F * >	fToteVHitEIntVec
std::vector< TH1F * >	fNSimChannelHitsVec
std::vector< TH1F * >	fNRecobHitVec
std::vector< TH1F * >	fHitEfficiencyVec
TTree *	fTree
std::vector< int >	fTPCVec
std::vector< int >	fCryoVec
std::vector< int >	fPlaneVec
std::vector< int >	fWireVec
std::vector< float >	fTotalElectronsVec
std::vector< float >	fMaxElectronsVec
std::vector< int >	fStartTickVec
std::vector< int >	fStopTickVec
std::vector< int >	fMaxETickVec
std::vector< float >	fPartDirX
std::vector< float >	fPartDirY
std::vector< float >	fPartDirZ
std::vector< int >	fNMatchedWires
std::vector< int >	fNMatchedHits
std::vector< float >	fHitPeakTimeVec
std::vector< float >	fHitPeakAmpVec
std::vector< float >	fHitPeakRMSVec
std::vector< float >	fHitBaselinevec
std::vector< float >	fHitSummedADCVec
std::vector< float >	fHitIntegralVec
std::vector< int >	fHitStartTickVec
std::vector< int >	fHitStopTickVec
std::vector< int >	fHitMultiplicityVec
std::vector< int >	fHitLocalIndexVec
std::vector< float >	fHitGoodnessVec
std::vector< int >	fNumDegreesVec
const geo::GeometryCore *	fGeometry
	pointer to Geometry service More...

Detailed Description

Definition at line 59 of file HitFinderAnalysis_tool.cc.

Constructor & Destructor Documentation

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

explicit

Constructor.

Parameters

pset	Constructor.

Arguments:

pset - Fcl parameters.

Definition at line 197 of file HitFinderAnalysis_tool.cc.

                                                                   : fTree(nullptr)
{
    fGeometry           = lar::providerFrom<geo::Geometry>();
    
    configure(pset);
    
    // Report.
    mf::LogInfo("HitFinderAnalysis") << "HitFinderAnalysis configured\n";
}

HitFinderAnalysis::HitFinderAnalysis::~HitFinderAnalysis

(

)

Destructor.

Definition at line 209 of file HitFinderAnalysis_tool.cc.

{}

Member Function Documentation

void HitFinderAnalysis::HitFinderAnalysis::clear ( ) const

private

Definition at line 350 of file HitFinderAnalysis_tool.cc.

{
    fTPCVec.clear();
    fCryoVec.clear();
    fPlaneVec.clear();
    fWireVec.clear();

    fTotalElectronsVec.clear();
    fMaxElectronsVec.clear();
    fStartTickVec.clear();
    fStopTickVec.clear();
    fMaxETickVec.clear();
    fPartDirX.clear();
    fPartDirY.clear();
    fPartDirZ.clear();
    
    fNMatchedWires.clear();
    fNMatchedHits.clear();

    fHitPeakTimeVec.clear();
    fHitPeakAmpVec.clear();
    fHitPeakRMSVec.clear();
    fHitBaselinevec.clear();
    fHitSummedADCVec.clear();
    fHitIntegralVec.clear();
    fHitStartTickVec.clear();
    fHitStopTickVec.clear();
    fHitMultiplicityVec.clear();
    fHitLocalIndexVec.clear();
    fHitGoodnessVec.clear();
    fNumDegreesVec.clear();
    
    return;
}

void HitFinderAnalysis::HitFinderAnalysis::configure ( fhicl::ParameterSet const &  pset )

overridevirtual

Reconfigure method.

Arguments:

pset - Fcl parameter set.

Implements IHitEfficiencyHistogramTool.

Definition at line 219 of file HitFinderAnalysis_tool.cc.

{
    fRawDigitProducerLabel   = pset.get< art::InputTag             >("RawDigitLabel",   "rawdigitfilter");
    fWireProducerLabel       = pset.get< art::InputTag             >("WireModuleLabel", "decon1droi");
    fHitProducerLabel        = pset.get< art::InputTag             >("HitModuleLabel",  "gauss");
    fMCParticleProducerLabel = pset.get< art::InputTag             >("MCParticleLabel", "largeant");
    fSimChannelProducerLabel = pset.get< art::InputTag             >("SimChannelLabel", "largeant");
    fBadChannelProducerLabel = pset.get< art::InputTag             >("BadChannelLabel", "simnfspl1:badchannels");
    fUseBadChannelDB         = pset.get< bool                      >("UseBadChannelDB", true);
    fLocalDirName            = pset.get<std::string                >("LocalDirName", std::string("wow"));
    fOffsetVec               = pset.get<std::vector<int>           >("OffsetVec", std::vector<int>()={0,0,0});
    fSigmaVec                = pset.get<std::vector<float>         >("SigmaVec", std::vector<float>()={1.,1.,1.});
    fMinAllowedChanStatus    = pset.get< int                       >("MinAllowedChannelStatus");
}

void HitFinderAnalysis::HitFinderAnalysis::endJob ( int  numEvents )

overridevirtual

Interface for method to executve at the end of run processing.

Parameters

int	number of events to use for normalization

Implements IHitEfficiencyHistogramTool.

Definition at line 826 of file HitFinderAnalysis_tool.cc.

{
    return;
}

void HitFinderAnalysis::HitFinderAnalysis::fillHistograms ( const art::Event &  event ) const

overridevirtual

Interface for filling histograms.

Implements IHitEfficiencyHistogramTool.

Definition at line 385 of file HitFinderAnalysis_tool.cc.

{
    // Always clear the tuple
    clear();
    
    art::Handle< std::vector<sim::SimChannel>> simChannelHandle;
    event.getByLabel(fSimChannelProducerLabel, simChannelHandle);
    
    // If there is no sim channel informaton then exit
    if (!simChannelHandle.isValid() || simChannelHandle->empty()) return;
    
    art::Handle< std::vector<raw::RawDigit> > rawDigitHandle;
    event.getByLabel(fRawDigitProducerLabel, rawDigitHandle);

    art::Handle< std::vector<recob::Wire> > wireHandle;
    event.getByLabel(fWireProducerLabel, wireHandle);
    
    art::Handle< std::vector<recob::Hit> > hitHandle;
    event.getByLabel(fHitProducerLabel, hitHandle);
    
    art::Handle< std::vector<simb::MCParticle>> mcParticleHandle;
    event.getByLabel(fMCParticleProducerLabel, mcParticleHandle);
    
    if (!rawDigitHandle.isValid() || !wireHandle.isValid() || !hitHandle.isValid() || !mcParticleHandle.isValid()) return;
    
    // Look up the list of bad channels
    art::Handle< std::vector<int>> badChannelHandle;
    event.getByLabel(fBadChannelProducerLabel, badChannelHandle);
    
    // Find the associations between wire data and hits
    // What we want to be able to do is look up hits that have been associated to Wire data
    // So we ask for the list of hits, given a handle to the Wire data and remember that the
    // associations are made in the hit finder
    //art::FindManyP<recob::Hit> wireHitAssns(wireHandle,event,fHitProducerLabel);
    
    // what needs to be done?
    // First we should build out a straightforward channel to Wire map so we can look up a given
    // channel's Wire data as we loop over SimChannels.
    using ChanToWireMap = std::unordered_map<raw::ChannelID_t,const recob::Wire*>;
    
    ChanToWireMap channelToWireMap;
    
    for(const auto& wire : *wireHandle) channelToWireMap[wire.Channel()] = &wire;
    
    // We will use the presence of a RawDigit as an indicator of a good channel... So
    // we want a mapping between channel and RawDigit
    using ChanToRawDigitMap = std::unordered_map<raw::ChannelID_t,const raw::RawDigit*>;
    
    ChanToRawDigitMap chanToRawDigitMap;
    
    for(const auto& rawDigit : *rawDigitHandle) chanToRawDigitMap[rawDigit.Channel()] = &rawDigit;
    
    // Then we should map out all hits by channel so we can easily look up from sim channels
    // Then go through the sim channels and match hits
    using ChanToHitVecMap = std::unordered_map<raw::ChannelID_t,std::vector<const recob::Hit*>>;
    ChanToHitVecMap channelToHitVec;
    
    for(const auto& hit : *hitHandle) channelToHitVec[hit.Channel()].push_back(&hit);
    
    // It is useful to create a mapping between trackID and MCParticle
    using TrackIDToMCParticleMap = std::unordered_map<int, const simb::MCParticle*>;
    
    TrackIDToMCParticleMap trackIDToMCParticleMap;
    
    for(const auto& mcParticle : *mcParticleHandle) trackIDToMCParticleMap[mcParticle.TrackId()] = &mcParticle;
    
    // Now go through the sim channels
    // There are several things going on here... for each channel we have particles (track id's) depositing energy in a range to ticks
    // So... for each channel we want to build a structure that relates particles to tdc ranges and deposited energy (or electrons)
    // Here is a complicated structure:
    
    using TDCToIDEMap             = std::map<unsigned short, sim::IDE>; // We need this one in order
    using ChanToTDCToIDEMap       = std::map<raw::ChannelID_t, TDCToIDEMap>;
    using PartToChanToTDCToIDEMap = std::unordered_map<int, ChanToTDCToIDEMap>;
    
    PartToChanToTDCToIDEMap partToChanToTDCToIDEMap;
    
    // Build out the above data structure
    for(const auto& simChannel : *simChannelHandle)
    {
        for(const auto& tdcide : simChannel.TDCIDEMap())
        {
            for(const auto& ide : tdcide.second) partToChanToTDCToIDEMap[ide.trackID][simChannel.Channel()][tdcide.first] = ide;
        }
    }
    
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
    const lariov::ChannelStatusProvider& chanFilt = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();

    std::vector<int> nSimChannelHitVec = {0,0,0};
    std::vector<int> nRecobHitVec      = {0,0,0};

    for(const auto& partToChanInfo : partToChanToTDCToIDEMap)
    {
        TrackIDToMCParticleMap::const_iterator trackIDToMCPartItr = trackIDToMCParticleMap.find(partToChanInfo.first);

        if (trackIDToMCPartItr == trackIDToMCParticleMap.end()) continue;

        int         trackPDGCode = trackIDToMCPartItr->second->PdgCode();
        std::string processName  = trackIDToMCPartItr->second->Process();

        // Looking for primary muons (e.g. CR Tracks)
        if (fabs(trackPDGCode) != 13 || processName != "primary") continue;
        
        // Recover particle position and angle information
        Eigen::Vector3f partStartPos(trackIDToMCPartItr->second->Vx(),trackIDToMCPartItr->second->Vy(),trackIDToMCPartItr->second->Vz());
        Eigen::Vector3f partStartDir(trackIDToMCPartItr->second->Px(),trackIDToMCPartItr->second->Py(),trackIDToMCPartItr->second->Pz());
        
        partStartDir.normalize();
        
        Eigen::Vector2f partStartDirVecXZ(partStartDir[0],partStartDir[2]);
        
        partStartDirVecXZ.normalize();

        // Assuming the SimChannels contain position information (currently not true for WC produced SimChannels)
        // then we want to keep a running position
        std::vector<Eigen::Vector3f> lastPositionVec = {partStartPos,partStartPos,partStartPos};

        for(const auto& chanToTDCToIDEMap : partToChanInfo.second)
        {
            // skip bad channels
            if (fUseBadChannelDB)
            {
                // This is the "correct" way to check and remove bad channels...
                if( chanFilt.Status(chanToTDCToIDEMap.first) < fMinAllowedChanStatus)
                {
                //std::vector<geo::WireID> wids = fGeometry->ChannelToWire(chanToTDCToIDEMap.first);
                //std::cout << "*** skipping bad channel with status: " << chanFilt.Status(chanToTDCToIDEMap.first) << " for channel: " << chanToTDCToIDEMap.first << ", plane: " << wids[0].Plane << ", wire: " << wids[0].Wire << std::endl;
                    continue;
                }
            }
            
            // Was a list made available?
            // If so then we try that
            if (badChannelHandle.isValid())
            {
                // Here we query the input list from the wirecell processing
                std::vector<int>::const_iterator badItr = std::find(badChannelHandle->begin(),badChannelHandle->end(),chanToTDCToIDEMap.first);

                if (badItr != badChannelHandle->end()) continue;
                //            {
                //                ChanToRawDigitMap::const_iterator rawDigitItr = chanToRawDigitMap.find(chanToTDCToIDEMap.first);
                //
                //                if (rawDigitItr != chanToRawDigitMap.end())
                //                {
                //                    float nSig(3.);
                //                    float mean(0.);
                //                    float rmsFull(0.);
                //                    float rmsTrunc(0.);
                //                    int   nTrunc(0);
                //
                //                    getTruncatedMeanRMS(rawDigitItr->second->ADCs(), nSig, mean, rmsFull, rmsTrunc, nTrunc);
                //
                //                    std::cout << "--> Rejecting channel: " << chanToTDCToIDEMap.first << " from bad channel list, rms: " << rmsFull << std::endl;
                //                }
                //
                //                continue;
                //            }
            }
            
            TDCToIDEMap    tdcToIDEMap = chanToTDCToIDEMap.second;
            float          totalElectrons(0.);
            float          maxElectrons(0.);
            unsigned short maxElectronsTDC(0);
            int            nMatchedWires(0);
            int            nMatchedHits(0);
            
            // The below try-catch block may no longer be necessary
            // Decode the channel and make sure we have a valid one
            std::vector<geo::WireID> wids = fGeometry->ChannelToWire(chanToTDCToIDEMap.first);
            
            // Recover plane and wire in the plane
            unsigned int plane = wids[0].Plane;
//            unsigned int wire  = wids[0].Wire;
            
            Eigen::Vector3f avePosition(0.,0.,0.);

            for(const auto& ideVal : tdcToIDEMap)
            {
                totalElectrons += ideVal.second.numElectrons;
                
                if (maxElectrons < ideVal.second.numElectrons)
                {
                    maxElectrons    = ideVal.second.numElectrons;
                    maxElectronsTDC = ideVal.first;
                }
                
                avePosition += Eigen::Vector3f(ideVal.second.x,ideVal.second.y,ideVal.second.z);
            }
            
            // Get local track direction by using the average position of deposited charge as the current position
            // and then subtracting the last position
            avePosition /= float(tdcToIDEMap.size());
            
            Eigen::Vector3f partDirVec = avePosition - lastPositionVec[plane];
            
            partDirVec.normalize();
            
            lastPositionVec[plane] = avePosition;
            
            // Now what we want is the projected angle in the XZ plane
            Eigen::Vector2f projPairDirVec(partDirVec[0],partDirVec[2]);
            
            projPairDirVec.normalize();
            
            float cosThetaXZ = projPairDirVec[0];

            totalElectrons = std::min(totalElectrons, float(99900.));
            
            fTotalElectronsHistVec[plane]->Fill(totalElectrons, 1.);
            fMaxElectronsHistVec[plane]->Fill(maxElectrons, 1.);
            
            nSimChannelHitVec[plane]++;

            unsigned short startTDC = tdcToIDEMap.begin()->first;
            unsigned short stopTDC  = tdcToIDEMap.rbegin()->first;
            
            // Convert to ticks to get in same units as hits
            unsigned short startTick = clockData.TPCTDC2Tick(startTDC)        + fOffsetVec[plane];
            unsigned short stopTick  = clockData.TPCTDC2Tick(stopTDC)         + fOffsetVec[plane];
            unsigned short maxETick  = clockData.TPCTDC2Tick(maxElectronsTDC) + fOffsetVec[plane];

            fSimNumTDCVec[plane]->Fill(stopTick - startTick, 1.);
    
            // Set up to extract the "best" parameters in the event of more than one hit for this pulse train
            float          nElectronsTotalBest(0.);
            float          hitSummedADCBest(0.);
            float          hitIntegralBest(0.);
            float          hitPeakTimeBest(0.);
            float          hitPeakAmpBest(-100.);
            float          hitRMSBest(0.);
            int            hitMultiplicityBest(0);
            int            hitLocalIndexBest(0);
            float          hitGoodnessBest(0.);
            int            hitNumDegreesBest(0);
            float          hitBaselineBest(0.);
            float          hitSnippetLenBest(0.);
            unsigned short hitStopTickBest(0);
            unsigned short hitStartTickBest(0);
//            unsigned short midHitTickBest(0);
            
            // Start by recovering the Wire associated to this channel
            ChanToWireMap::const_iterator wireItr = channelToWireMap.find(chanToTDCToIDEMap.first);
            
            if (wireItr != channelToWireMap.end())
            {
                const recob::Wire::RegionsOfInterest_t&       signalROI = wireItr->second->SignalROI();
                const lar::sparse_vector<float>::datarange_t* wireRangePtr(NULL);
                
                // Here we need to match the range of the ROI's on the given Wire with the tick range from the SimChannel
                for(const auto& range : signalROI.get_ranges())
                {
                    // #################################################
                    // ### Getting a vector of signals for this wire ###
                    // #################################################
                    //std::vector<float> signal(wire->Signal());
                    
                    const std::vector<float>& signal          = range.data();
                    raw::TDCtick_t            roiFirstBinTick = range.begin_index();
                    raw::TDCtick_t            roiLastBinTick  = roiFirstBinTick + signal.size();
                    
                    // If no overlap then go to next
                    if (roiFirstBinTick > stopTick || roiLastBinTick < startTick) continue;
                    
                    wireRangePtr = &range;
                    break;
                }
                
                // Check that we have found the wire range
                // Note that if we have not matched an ROI then we can't have a hit either so skip search for that...
                if (wireRangePtr)
                {
                    const recob::Hit* rejectedHit = 0;
                    const recob::Hit* bestHit     = 0;
                    
                    nMatchedWires++;
                    
                    // The next mission is to recover the hits associated to this Wire
                    // The easiest way to do this is to simply look up all the hits on this channel and then match
                    ChanToHitVecMap::iterator hitIter = channelToHitVec.find(chanToTDCToIDEMap.first);
                    
                    if (hitIter != channelToHitVec.end())
                    {
                        // Loop through the hits for this channel and look for matches
                        // In the event of more than one hit associated to the sim channel range, keep only
                        // the best match (assuming the nearby hits are "extra")
                        // Note that assumption breaks down for long pulse trains but worry about that later
                        for(const auto& hit : hitIter->second)
                        {
                            unsigned short hitStartTick = hit->PeakTime() - fSigmaVec[plane] * hit->RMS();
                            unsigned short hitStopTick  = hit->PeakTime() + fSigmaVec[plane] * hit->RMS();
//                            unsigned short midHitTick   = (hitStopTick + hitStartTick) / 2;
                        
                            // If hit is out of range then skip, it is not related to this particle
                            if (hitStartTick > stopTick || hitStopTick < startTick)
                            {
                                if (plane == 2) rejectedHit = hit;
                                continue;
                            }
                        
                            float hitHeight = hit->PeakAmplitude();
                        
                            // Use the hit with the largest pulse height as the "best"
                            if (hitHeight < hitPeakAmpBest) continue;
                        
                            hitPeakAmpBest   = hitHeight;
                            bestHit          = hit;
                            hitStartTickBest = hitStartTick;
                            hitStopTickBest  = hitStopTick;
//                            midHitTickBest   = midHitTick;
                        }
                        
                        // Find a match?
                        if (bestHit)
                        {
                            nElectronsTotalBest = 0.;
                            hitPeakTimeBest     = bestHit->PeakTime();
                            hitIntegralBest     = bestHit->Integral();
                            hitSummedADCBest    = bestHit->SummedADC();
                            hitRMSBest          = bestHit->RMS();
                            hitMultiplicityBest = bestHit->Multiplicity();
                            hitLocalIndexBest   = bestHit->LocalIndex();
                            hitGoodnessBest     = bestHit->GoodnessOfFit();
                            hitNumDegreesBest   = bestHit->DegreesOfFreedom();
                            hitSnippetLenBest   = bestHit->EndTick() - bestHit->StartTick();
                            hitBaselineBest     = 0.;  // To do...
                        
                            nMatchedHits++;
                        
                            // Get the number of electrons
                            for(unsigned short tick = hitStartTickBest; tick <= hitStopTickBest; tick++)
                            {
                                unsigned short hitTDC = clockData.TPCTick2TDC(tick - fOffsetVec[plane]);
                        
                                TDCToIDEMap::iterator ideIterator = tdcToIDEMap.find(hitTDC);
                        
                                if (ideIterator != tdcToIDEMap.end()) nElectronsTotalBest += ideIterator->second.numElectrons;
                            }
                        }
        
                        if (nMatchedHits > 0)
                        {
                            float chgRatioADC = hitSummedADCBest > 0. ? totalElectrons / hitSummedADCBest : 0.;
                            float chgRatioInt = hitIntegralBest  > 0. ? totalElectrons / hitIntegralBest  : 0.;
        
                            fHitSumADCVec[plane]->Fill(hitSummedADCBest, 1.);
                            fHitIntegralHistVec[plane]->Fill(hitIntegralBest, 1.);
                            fSimDivHitChgVec[plane]->Fill(chgRatioADC, 1.);
                            fSimDivHitChg1Vec[plane]->Fill(chgRatioInt, 1.);
                            fHitVsSimChgVec[plane]->Fill(std::min(hitSummedADCBest,float(999.)), totalElectrons, 1.);
                            fHitVsSimIntVec[plane]->Fill(std::min(hitIntegralBest,float(999.)), totalElectrons, 1.);
                            fToteVHitEIntVec[plane]->Fill(std::min(totalElectrons,float(99999.)),std::min(nElectronsTotalBest,float(99999.)),1.);
                            fHitPulseHeightVec[plane]->Fill(std::min(hitPeakAmpBest,float(149.5)), 1.);
                            fHitPulseWidthVec[plane]->Fill(std::min(hitRMSBest,float(19.8)), 1.);
                            fHitElectronsVec[plane]->Fill(nElectronsTotalBest, 1.);
                            fHitNumTDCVec[plane]->Fill(std::min(float(hitStopTickBest - hitStartTickBest),float(99.5)), 1.);
                            fSnippetLenVec[plane]->Fill(std::min(hitSnippetLenBest, float(99.5)), 1.);
                            fDeltaMidTDCVec[plane]->Fill(hitPeakTimeBest - maxETick, 1.);
                        
                            nRecobHitVec[plane]++;
                        }
                        else if (rejectedHit)
                        {
                            unsigned short hitStartTick = rejectedHit->PeakTime() - fSigmaVec[plane] * rejectedHit->RMS();
                            unsigned short hitStopTick  = rejectedHit->PeakTime() + fSigmaVec[plane] * rejectedHit->RMS();
        
                            mf::LogDebug("HitFinderAnalysis") << "**> TPC: " << rejectedHit->WireID().TPC << ", Plane " << rejectedHit->WireID().Plane << ", wire: " << rejectedHit->WireID().Wire << ", hit start/stop         tick: " << hitStartTick << "/" << hitStopTick << ", start/stop ticks: " << startTick << "/" << stopTick << std::endl;
                            mf::LogDebug("HitFinderAnalysis") << "    TPC/Plane/Wire: " << wids[0].TPC << "/" << plane << "/" << wids[0].Wire << ", Track # hits: " << partToChanInfo.second.size() << ", # hits: " <<      hitIter->second.size() << ", # electrons: " << totalElectrons << ", pulse Height: " << rejectedHit->PeakAmplitude() << ", charge: " << rejectedHit->Integral()      << ", " << rejectedHit->SummedADC() << std::endl;
                        }
                        else
                        {
                            mf::LogDebug("HitFinderAnalysis") << "==> No match, TPC/Plane/Wire: " << "/" << wids[0].TPC << "/" << wids[0].Plane << "/" << wids[0].Wire << ", # electrons: " << totalElectrons << ",         startTick: " << startTick << ", stopTick: " << stopTick << std::endl;
                        }
                    }
                }
            }

            fWireEfficVec.at(plane)->Fill(totalElectrons, std::min(nMatchedWires,1), 1.);
            fWireEfficPHVec.at(plane)->Fill(maxElectrons, std::min(nMatchedWires,1), 1.);

            float matchHit   = std::min(nMatchedHits,1);
            float snippetLen = std::min(float(stopTick - startTick),float(99.5));
        
            fNMatchedHitVec[plane]->Fill(nMatchedHits, 1.);
            fHitEfficVec[plane]->Fill(totalElectrons,   matchHit,   1.);
            fHitEfficPHVec[plane]->Fill(maxElectrons,   matchHit,   1.);
            fHitEfficXZVec[plane]->Fill(cosThetaXZ,     matchHit,   1.);
            fCosXZvRMSVec[plane]->Fill(cosThetaXZ,      snippetLen, 1.);
            fHitEfficRMSVec[plane]->Fill(snippetLen,    matchHit,   1.);
            
            fHitENEvXZVec[plane]->Fill(cosThetaXZ, totalElectrons, matchHit);
            
            // Store tuple variables
            fTPCVec.push_back(wids[0].TPC);
            fCryoVec.push_back(wids[0].Cryostat);
            fPlaneVec.push_back(wids[0].Plane);
            fWireVec.push_back(wids[0].Wire);
            
            fTotalElectronsVec.push_back(totalElectrons);
            fMaxElectronsVec.push_back(maxElectrons);
            fStartTickVec.push_back(startTick);
            fStopTickVec.push_back(stopTick);
            fMaxETickVec.push_back(maxETick);
            fPartDirX.push_back(partDirVec[0]);
            fPartDirY.push_back(partDirVec[1]);
            fPartDirZ.push_back(partDirVec[2]);

            fNMatchedWires.push_back(nMatchedWires);
            fNMatchedHits.push_back(nMatchedHits);

            fHitPeakTimeVec.push_back(hitPeakTimeBest);
            fHitPeakAmpVec.push_back(hitPeakAmpBest);
            fHitPeakRMSVec.push_back(hitRMSBest);
            fHitBaselinevec.push_back(hitBaselineBest);
            fHitSummedADCVec.push_back(hitSummedADCBest);
            fHitIntegralVec.push_back(hitIntegralBest);
            fHitStartTickVec.push_back(hitStartTickBest);
            fHitStopTickVec.push_back(hitStopTickBest);
            fHitMultiplicityVec.push_back(hitMultiplicityBest);
            fHitLocalIndexVec.push_back(hitLocalIndexBest);
            fHitGoodnessVec.push_back(hitGoodnessBest);
            fNumDegreesVec.push_back(hitNumDegreesBest);
        }
    }
    
    for(size_t idx = 0; idx < fGeometry->Nplanes();idx++)
    {
        if (nSimChannelHitVec[idx] > 10)
        {
            float hitEfficiency = float(nRecobHitVec[idx]) / float(nSimChannelHitVec[idx]);
            
            fNSimChannelHitsVec[idx]->Fill(std::min(nSimChannelHitVec[idx],1999),1.);
            fNRecobHitVec[idx]->Fill(std::min(nRecobHitVec[idx],1999), 1.);
            fHitEfficiencyVec[idx]->Fill(hitEfficiency, 1.);
        }
    }

    return;
}

void HitFinderAnalysis::HitFinderAnalysis::initializeHists ( art::ServiceHandle< art::TFileService > &  tfs, const std::string &  dirName  )

overridevirtual

Interface for initializing the histograms to be filled.

Begin job method.

Parameters

TFileService	handle to the TFile service
string	subdirectory to store the hists in

Implements IHitEfficiencyHistogramTool.

Definition at line 236 of file HitFinderAnalysis_tool.cc.

{
    // Make a directory for these histograms
    art::TFileDirectory dir = tfs->mkdir(dirName.c_str());
    
    fTotalElectronsHistVec.resize(fGeometry->Nplanes());
    fMaxElectronsHistVec.resize(fGeometry->Nplanes());
    fHitElectronsVec.resize(fGeometry->Nplanes());
    fHitSumADCVec.resize(fGeometry->Nplanes());
    fHitIntegralHistVec.resize(fGeometry->Nplanes());
    fHitPulseHeightVec.resize(fGeometry->Nplanes());
    fHitPulseWidthVec.resize(fGeometry->Nplanes());
    fSimNumTDCVec.resize(fGeometry->Nplanes());
    fHitNumTDCVec.resize(fGeometry->Nplanes());
    fSnippetLenVec.resize(fGeometry->Nplanes());
    fNMatchedHitVec.resize(fGeometry->Nplanes());
    fDeltaMidTDCVec.resize(fGeometry->Nplanes());
    fHitVsSimChgVec.resize(fGeometry->Nplanes());
    fHitVsSimIntVec.resize(fGeometry->Nplanes());
    fCosXZvRMSVec.resize(fGeometry->Nplanes());
    fToteVHitEIntVec.resize(fGeometry->Nplanes());
    fHitENEvXZVec.resize(fGeometry->Nplanes());
    fNSimChannelHitsVec.resize(fGeometry->Nplanes());
    fNRecobHitVec.resize(fGeometry->Nplanes());
    fHitEfficiencyVec.resize(fGeometry->Nplanes());
    fSimDivHitChgVec.resize(fGeometry->Nplanes());
    fSimDivHitChg1Vec.resize(fGeometry->Nplanes());

    fWireEfficVec.resize(fGeometry->Nplanes());
    fWireEfficPHVec.resize(fGeometry->Nplanes());

    fHitEfficVec.resize(fGeometry->Nplanes());
    fHitEfficPHVec.resize(fGeometry->Nplanes());
    fHitEfficXZVec.resize(fGeometry->Nplanes());
    fHitEfficRMSVec.resize(fGeometry->Nplanes());

    for(size_t plane = 0; plane < fGeometry->Nplanes(); plane++)
    {
        fTotalElectronsHistVec.at(plane) = dir.make<TH1F>(("TotalElecs"  + std::to_string(plane)).c_str(), ";Total # electrons",     250,    0.,  100000.);
        fMaxElectronsHistVec.at(plane)   = dir.make<TH1F>(("MaxElecs"    + std::to_string(plane)).c_str(), ";Max # electrons",       250,    0.,  20000.);
        fHitElectronsVec.at(plane)       = dir.make<TH1F>(("HitElecs"    + std::to_string(plane)).c_str(), ";# e- in Hit Range",     250,    0.,  100000.);
        fHitSumADCVec.at(plane)          = dir.make<TH1F>(("SumADC"      + std::to_string(plane)).c_str(), "Hit Sum ADC",            200,    0.,  1000.);
        fHitIntegralHistVec.at(plane)    = dir.make<TH1F>(("Integral"    + std::to_string(plane)).c_str(), "Hit Integral",           200,    0.,  1000.);
        fHitPulseHeightVec.at(plane)     = dir.make<TH1F>(("PulseHeight" + std::to_string(plane)).c_str(), "Hit PH (ADC)",           200,    0.,  150.);
        fHitPulseWidthVec.at(plane)      = dir.make<TH1F>(("PulseWidth"  + std::to_string(plane)).c_str(), "Hit PulseWidth;Hit RMS", 100,    0.,  20.);
        fSimNumTDCVec.at(plane)          = dir.make<TH1F>(("SimNumTDC"   + std::to_string(plane)).c_str(), ";TDC ticks",             100,    0.,  100.);
        fHitNumTDCVec.at(plane)          = dir.make<TH1F>(("HitNumTDC"   + std::to_string(plane)).c_str(), ";ticks",                 100,    0.,  100.);
        fSnippetLenVec.at(plane)         = dir.make<TH1F>(("SnippetLen"  + std::to_string(plane)).c_str(), ";ticks",                 100,    0.,  100.);
        fNMatchedHitVec.at(plane)        = dir.make<TH1F>(("NMatched"    + std::to_string(plane)).c_str(), ";# hits",                 20,    0.,  20.);
        fDeltaMidTDCVec.at(plane)        = dir.make<TH1F>(("DeltaMid"    + std::to_string(plane)).c_str(), ";# hits",                 50,  -25.,  25.);
        fNSimChannelHitsVec.at(plane)    = dir.make<TH1F>(("NSimChan"    + std::to_string(plane)).c_str(), ";# hits",                100,    0.,  1200.);
        fNRecobHitVec.at(plane)          = dir.make<TH1F>(("NRecobHit"   + std::to_string(plane)).c_str(), ";# hits",                100,    0.,  1200.);
        fHitEfficiencyVec.at(plane)      = dir.make<TH1F>(("PlnEffic"    + std::to_string(plane)).c_str(), ";# hits",                101,    0.,  1.01);
        fSimDivHitChgVec.at(plane)       = dir.make<TH1F>(("SimDivHit"   + std::to_string(plane)).c_str(), ";# e / SummedADC",       200,    0.,  200.);
        fSimDivHitChg1Vec.at(plane)      = dir.make<TH1F>(("SimDivHit1"  + std::to_string(plane)).c_str(), ";# e / Integral",        200,    0.,  200.);

        fHitVsSimChgVec.at(plane)        = dir.make<TH2F>(("HitVSimQ"  + std::to_string(plane)).c_str(), "# e vs Hit SumADC;SumADC;# e",     50, 0.,   1000., 50, 0., 100000.);
        fHitVsSimIntVec.at(plane)        = dir.make<TH2F>(("HitVSimI"  + std::to_string(plane)).c_str(), "# e vs Hit Integral;Integral;# e", 50, 0.,   1000., 50, 0., 100000.);
        fToteVHitEIntVec.at(plane)       = dir.make<TH2F>(("ToteVHite" + std::to_string(plane)).c_str(), "Tot e vs Hit e;Total #e;Hit #e",   50, 0., 100000., 50, 0., 100000.);
        
        fWireEfficVec.at(plane)          = dir.make<TProfile>  (("WireEffic"   + std::to_string(plane)).c_str(), "Wire Efficiency;# electrons",      50, 0., 100000.,  0., 1.);
        fWireEfficPHVec.at(plane)        = dir.make<TProfile>  (("WireEfficPH" + std::to_string(plane)).c_str(), "Wire Efficiency;# electrons",      50, 0.,  20000.,  0., 1.);

        fHitEfficVec.at(plane)           = dir.make<TProfile>  (("HitEffic"    + std::to_string(plane)).c_str(), "Hit Efficiency;Total # e-",        50,  0., 100000., 0., 1.);
        fHitEfficPHVec.at(plane)         = dir.make<TProfile>  (("HitEfficPH"  + std::to_string(plane)).c_str(), "Hit Efficiency;Max # e-",          50,  0.,  20000., 0., 1.);
        fHitEfficXZVec.at(plane)         = dir.make<TProfile>  (("HitEfficXZ"  + std::to_string(plane)).c_str(), "Hit Efficiency;cos(thetaXZ)",      50, -1.,      1., 0., 1.);
        fHitEfficRMSVec.at(plane)        = dir.make<TProfile>  (("HitEfficRMS" + std::to_string(plane)).c_str(), "Hit Efficiency;MC Length (ticks)", 50,  0.,    100., 0., 1.);
        fCosXZvRMSVec.at(plane)          = dir.make<TProfile>  (("CosXZVRMS"   + std::to_string(plane)).c_str(), "CosXZ v. RMS;Cos(XZ);Ticks",       50, -1.,      1., 0., 100.);
        fHitENEvXZVec.at(plane)          = dir.make<TProfile2D>(("HitENEvXZ"   + std::to_string(plane)).c_str(), "XZ v # e;cos(thetaXZ);#electrons", 50, -1.,      1.,
                                                                50, 0., 100000., 0., 1.);
    }
    
    return;
}

void HitFinderAnalysis::HitFinderAnalysis::initializeTuple ( TTree *  tree )

overridevirtual

Interface for initializing the tuple variables.

Parameters

TTree

pointer to a TTree object to which to add variables

Implements IHitEfficiencyHistogramTool.

Definition at line 311 of file HitFinderAnalysis_tool.cc.

{
    fTree = tree;
    
    fTree->Branch("CryostataVec",      "std::vector<int>",   &fCryoVec);
    fTree->Branch("TPCVec",            "std::vector<int>",   &fTPCVec);
    fTree->Branch("PlaneVec",          "std::vector<int>",   &fPlaneVec);
    fTree->Branch("WireVec",           "std::vector<int>",   &fWireVec);

    fTree->Branch("TotalElectronsVec", "std::vector<float>", &fTotalElectronsVec);
    fTree->Branch("MaxElectronsVec",   "std::vector<float>", &fMaxElectronsVec);
    fTree->Branch("StartTick",         "std::vector<int>",   &fStartTickVec);
    fTree->Branch("StopTick",          "std::vector<int>",   &fStopTickVec);
    fTree->Branch("MaxETick",          "std::vector<int>",   &fMaxETickVec);
    fTree->Branch("PartDirX",          "std::vector<float>", &fPartDirX);
    fTree->Branch("PartDirY",          "std::vector<float>", &fPartDirY);
    fTree->Branch("PartDirZ",          "std::vector<float>", &fPartDirZ);

    fTree->Branch("NMatchedWires",     "std::vector<int>",   &fNMatchedWires);
    fTree->Branch("NMatchedHits",      "std::vector<int>",   &fNMatchedHits);
    
    fTree->Branch("HitPeakTimeVec",    "std::vector<float>", &fHitPeakTimeVec);
    fTree->Branch("HitPeakAmpVec",     "std::vector<float>", &fHitPeakAmpVec);
    fTree->Branch("HitPeakRMSVec",     "std::vector<float>", &fHitPeakRMSVec);
    fTree->Branch("HitBaselineVec",    "std::vector<float>", &fHitBaselinevec);
    fTree->Branch("HitSummedADCVec",   "std::vector<float>", &fHitSummedADCVec);
    fTree->Branch("HitIntegralVec",    "std::vector<float>", &fHitIntegralVec);
    fTree->Branch("HitStartTickVec",   "std::vector<int>",   &fHitStartTickVec);
    fTree->Branch("HitStopTickVec",    "std::vector<int>",   &fHitStopTickVec);
    fTree->Branch("HitMultiplicity",   "std::vector<int>",   &fHitMultiplicityVec);
    fTree->Branch("HitLocalIndex",     "std::vector<int>",   &fHitLocalIndexVec);
    fTree->Branch("HitGoodness",       "std::vector<float>", &fHitGoodnessVec);
    fTree->Branch("HitNumDegrees",     "std::vector<int>",   &fNumDegreesVec);

    clear();

    return;
}

Member Data Documentation

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fBadChannelProducerLabel

private

Definition at line 115 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fCosXZvRMSVec

private

Definition at line 141 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fCryoVec

mutableprivate

Definition at line 157 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fDeltaMidTDCVec

private

Definition at line 134 of file HitFinderAnalysis_tool.cc.

const geo::GeometryCore* HitFinderAnalysis::HitFinderAnalysis::fGeometry

private

pointer to Geometry service

Definition at line 187 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitBaselinevec

mutableprivate

Definition at line 176 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitEfficiencyVec

private

Definition at line 151 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fHitEfficPHVec

private

Definition at line 138 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fHitEfficRMSVec

private

Definition at line 140 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fHitEfficVec

private

Definition at line 137 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fHitEfficXZVec

private

Definition at line 139 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitElectronsVec

private

Definition at line 125 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile2D*> HitFinderAnalysis::HitFinderAnalysis::fHitENEvXZVec

private

Definition at line 142 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitGoodnessVec

mutableprivate

Definition at line 183 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitIntegralHistVec

private

Definition at line 127 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitIntegralVec

mutableprivate

Definition at line 178 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fHitLocalIndexVec

mutableprivate

Definition at line 182 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fHitMultiplicityVec

mutableprivate

Definition at line 181 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitNumTDCVec

private

Definition at line 131 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitPeakAmpVec

mutableprivate

Definition at line 174 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitPeakRMSVec

mutableprivate

Definition at line 175 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitPeakTimeVec

mutableprivate

Definition at line 173 of file HitFinderAnalysis_tool.cc.

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fHitProducerLabel

private

Definition at line 112 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitPulseHeightVec

private

Definition at line 128 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitPulseWidthVec

private

Definition at line 129 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fHitStartTickVec

mutableprivate

Definition at line 179 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fHitStopTickVec

mutableprivate

Definition at line 180 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fHitSumADCVec

private

Definition at line 126 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fHitSummedADCVec

mutableprivate

Definition at line 177 of file HitFinderAnalysis_tool.cc.

std::vector<TH2F*> HitFinderAnalysis::HitFinderAnalysis::fHitVsSimChgVec

private

Definition at line 145 of file HitFinderAnalysis_tool.cc.

std::vector<TH2F*> HitFinderAnalysis::HitFinderAnalysis::fHitVsSimIntVec

private

Definition at line 146 of file HitFinderAnalysis_tool.cc.

std::string HitFinderAnalysis::HitFinderAnalysis::fLocalDirName

private

Fraction for truncated mean.

Definition at line 117 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fMaxElectronsHistVec

private

Definition at line 124 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fMaxElectronsVec

mutableprivate

Definition at line 162 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fMaxETickVec

mutableprivate

Definition at line 165 of file HitFinderAnalysis_tool.cc.

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fMCParticleProducerLabel

private

Definition at line 113 of file HitFinderAnalysis_tool.cc.

int HitFinderAnalysis::HitFinderAnalysis::fMinAllowedChanStatus

private

Don't consider channels with lower status.

Definition at line 120 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fNMatchedHits

mutableprivate

Definition at line 171 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fNMatchedHitVec

private

Definition at line 133 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fNMatchedWires

mutableprivate

Definition at line 170 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fNRecobHitVec

private

Definition at line 150 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fNSimChannelHitsVec

private

Definition at line 149 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fNumDegreesVec

mutableprivate

Definition at line 184 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fOffsetVec

private

Allow offsets for each plane.

Definition at line 118 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fPartDirX

mutableprivate

Definition at line 166 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fPartDirY

mutableprivate

Definition at line 167 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fPartDirZ

mutableprivate

Definition at line 168 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fPlaneVec

mutableprivate

Definition at line 158 of file HitFinderAnalysis_tool.cc.

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fRawDigitProducerLabel

private

Definition at line 110 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fSigmaVec

private

Window size for matching to SimChannels.

Definition at line 119 of file HitFinderAnalysis_tool.cc.

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fSimChannelProducerLabel

private

Definition at line 114 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fSimDivHitChg1Vec

private

Definition at line 144 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fSimDivHitChgVec

private

Definition at line 143 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fSimNumTDCVec

private

Definition at line 130 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fSnippetLenVec

private

Definition at line 132 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fStartTickVec

mutableprivate

Definition at line 163 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fStopTickVec

mutableprivate

Definition at line 164 of file HitFinderAnalysis_tool.cc.

std::vector<TH1F*> HitFinderAnalysis::HitFinderAnalysis::fTotalElectronsHistVec

private

Definition at line 123 of file HitFinderAnalysis_tool.cc.

std::vector<float> HitFinderAnalysis::HitFinderAnalysis::fTotalElectronsVec

mutableprivate

Definition at line 161 of file HitFinderAnalysis_tool.cc.

std::vector<TH2F*> HitFinderAnalysis::HitFinderAnalysis::fToteVHitEIntVec

private

Definition at line 147 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fTPCVec

mutableprivate

Definition at line 156 of file HitFinderAnalysis_tool.cc.

TTree* HitFinderAnalysis::HitFinderAnalysis::fTree

mutableprivate

Definition at line 154 of file HitFinderAnalysis_tool.cc.

bool HitFinderAnalysis::HitFinderAnalysis::fUseBadChannelDB

private

Definition at line 116 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fWireEfficPHVec

private

Definition at line 136 of file HitFinderAnalysis_tool.cc.

std::vector<TProfile*> HitFinderAnalysis::HitFinderAnalysis::fWireEfficVec

private

Definition at line 135 of file HitFinderAnalysis_tool.cc.

art::InputTag HitFinderAnalysis::HitFinderAnalysis::fWireProducerLabel

private

Definition at line 111 of file HitFinderAnalysis_tool.cc.

std::vector<int> HitFinderAnalysis::HitFinderAnalysis::fWireVec

mutableprivate

Definition at line 159 of file HitFinderAnalysis_tool.cc.

---

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

• HitFinderAnalysis_tool.cc