ECLDataAnalysisModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
/* Basf2 headers. */
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
 
/* C++ headers. */
#include <string>
 
class TFile;
class TTree;
 
namespace Belle2 {
 
  //MDST
  class MCParticle;
  class ECLCluster;
  class Track;
  class TrackFitResult;
  class EventLevelClusteringInfo;
  class EventMetaData;
 
  //ECL
  class ECLShower;
  class ECLPidLikelihood;
  class ECLLocalMaximum;
  class ECLConnectedRegion;
  class ECLCalDigit;
  class ECLDigit;
  class ECLHit;
  class ECLSimHit;

 
  class ECLDataAnalysisModule : public Module {
 
  public:

    ECLDataAnalysisModule();

    virtual ~ECLDataAnalysisModule();

    virtual void initialize() override;
    virtual void beginRun() override;
    virtual void event() override;
    virtual void endRun() override;

    virtual void terminate() override;
 
  private:

    TFile* m_rootFilePtr; 
    std::string m_rootFileName; 
    bool m_writeToRoot; 
    bool m_doTracking; 
    bool m_doPureCsI; 
    bool m_doHits; 
    bool m_doDigits; 
 
    //dataStore objects
    StoreArray<Track> m_tracks;  
    StoreArray<TrackFitResult> m_trackFitResults;  
    StoreArray<ECLPidLikelihood> m_eclPidLikelihoods; 
    StoreArray<ECLSimHit> m_eclSimHits; 
    StoreArray<ECLHit> m_eclHits; 
    StoreArray<ECLDigit> m_eclDigits; 
    StoreArray<ECLCalDigit> m_eclCalDigits; 
    StoreArray<ECLConnectedRegion> m_eclConnectedRegions; 
    StoreArray<ECLShower> m_eclShowers; 
    StoreArray<ECLCluster> m_eclClusters; 
    StoreArray<ECLLocalMaximum> m_eclLocalMaximums; 
    StoreObjPtr<EventLevelClusteringInfo> m_eventLevelClusteringInfo; 
    StoreObjPtr<EventMetaData> m_eventmetadata; 

    virtual const char* eclSimHitArrayName() const
    { return "ECLSimHits" ; }

    virtual const char* eclHitArrayName() const
    { return "ECLHits" ; }

    virtual const char* eclDigitArrayName() const
    { return "ECLDigits" ; }

    virtual const char* eclCalDigitArrayName() const
    { return "ECLCalDigits" ; }

    virtual const char* eclShowerArrayName() const
    { return "ECLShowers" ; }

    virtual const char* eclClusterArrayName() const
    { return "ECLClusters" ; }

    virtual const char* eclConnectedRegionArrayName() const
    { return "ECLConnectedRegions" ; }

    virtual const char* eclLocalMaximumArrayName() const
    { return "ECLLocalMaximums" ; }
 

    StoreArray<ECLDigit> m_eclPureDigits;
    StoreArray<ECLCalDigit> m_eclPureCalDigits;
    StoreArray<ECLConnectedRegion> m_eclPureConnectedRegions;
    StoreArray<ECLShower> m_eclPureShowers;
    StoreArray<ECLCluster> m_eclPureClusters;
    StoreArray<ECLLocalMaximum> m_eclPureLocalMaximums;

    virtual const char* eclPureDigitArrayName() const
    { return "ECLDigitsPureCsI" ; }

    virtual const char* eclPureCalDigitArrayName() const
    { return "ECLCalDigitsPureCsI" ; }

    virtual const char* eclPureShowerArrayName() const
    { return "ECLShowersPureCsI" ; }

    virtual const char* eclPureClusterArrayName() const
    { return "ECLClustersPureCsI" ; }

    virtual const char* eclPureConnectedRegionArrayName() const
    { return "ECLConnectedRegionsPureCsI" ; }

    virtual const char* eclPureLocalMaximumArrayName() const
    { return "ECLLocalMaximumsPureCsI" ; }
 
    StoreArray<MCParticle> m_mcParticles; 
 
    TTree* m_tree; 
 
    // variables
    int m_iExperiment; 
    int m_iRun; 
    int m_iEvent; 
 
    //EventLevelClusteringInfo
    uint16_t m_nECLCalDigitsOutOfTimeFWD {0};
    uint16_t m_nECLCalDigitsOutOfTimeBarrel {0};
    uint16_t m_nECLCalDigitsOutOfTimeBWD {0};
    uint8_t m_nECLShowersRejectedFWD {0};
    uint8_t m_nECLShowersRejectedBarrel {0};
    uint8_t m_nECLShowersRejectedBWD {0};
 
    int m_eclDigitMultip; 
    std::vector<int>* m_eclDigitIdx; 
    std::vector<int>* m_eclDigitToMC; 
    std::vector<int>* m_eclDigitCellId; 
    std::vector<int>* m_eclDigitAmp;  
    std::vector<int>* m_eclDigitTimeFit;  
    std::vector<int>* m_eclDigitFitQuality;  
    std::vector<int>* m_eclDigitToCalDigit; 
 
    int m_eclCalDigitMultip; 
    std::vector<int>* m_eclCalDigitIdx; 
    std::vector<int>* m_eclCalDigitToMC1; 
    std::vector<int>* m_eclCalDigitToMC1PDG; 
    std::vector<double>* m_eclCalDigitToMCWeight1; 
    std::vector<int>* m_eclCalDigitToMC2; 
    std::vector<int>* m_eclCalDigitToMC2PDG; 
    std::vector<double>* m_eclCalDigitToMCWeight2; 
    std::vector<int>* m_eclCalDigitToMC3; 
    std::vector<int>* m_eclCalDigitToMC3PDG; 
    std::vector<double>* m_eclCalDigitToMCWeight3; 
    std::vector<int>* m_eclCalDigitToMC4; 
    std::vector<int>* m_eclCalDigitToMC4PDG; 
    std::vector<double>* m_eclCalDigitToMCWeight4; 
    std::vector<int>* m_eclCalDigitToMC5; 
    std::vector<int>* m_eclCalDigitToMC5PDG; 
    std::vector<double>* m_eclCalDigitToMCWeight5; 
    std::vector<double>*
    m_eclCalDigitToBkgWeight; 
    std::vector<double>* m_eclCalDigitSimHitSum; 
    std::vector<int>* m_eclCalDigitToShower; 
    std::vector<int>* m_eclCalDigitCellId; 
    std::vector<double>* m_eclCalDigitAmp;  
    std::vector<double>* m_eclCalDigitTimeFit;  
    std::vector<int>* m_eclCalDigitFitQuality;  
    std::vector<int>* m_eclCalDigitToCR; 
    std::vector<int>* m_eclCalDigitToLM; 
 
    std::vector<int>*    m_eclCRIdx; 
    std::vector<int>*    m_eclCRIsTrack;  
    std::vector<double>* m_eclCRLikelihoodMIPNGamma;  
    std::vector<double>*    m_eclCRLikelihoodChargedHadron;  
    std::vector<double>*    m_eclCRLikelihoodElectronNGamma;  
    std::vector<double>*    m_eclCRLikelihoodNGamma;  
    std::vector<double>*    m_eclCRLikelihoodNeutralHadron;  
    std::vector<double>*    m_eclCRLikelihoodMergedPi0;  
 
    int m_eclLMMultip;  
    std::vector<int>* m_eclLMId; 
    std::vector<int>* m_eclLMType; 
    std::vector<int>* m_eclLMCellId; 
 
    int m_eclSimHitMultip;  
    std::vector<int>* m_eclSimHitIdx;  
    std::vector<int>* m_eclSimHitToMC; 
    std::vector<int>* m_eclSimHitCellId; 
    std::vector<int>* m_eclSimHitPdg; 
    std::vector<double>* m_eclSimHitEnergyDep; 
    std::vector<double>* m_eclSimHitFlightTime; 
    std::vector<double>* m_eclSimHitX; 
    std::vector<double>* m_eclSimHitY; 
    std::vector<double>* m_eclSimHitZ; 
    std::vector<double>* m_eclSimHitPx; 
    std::vector<double>* m_eclSimHitPy; 
    std::vector<double>* m_eclSimHitPz; 
 
    int m_eclHitMultip; 
    std::vector<int>* m_eclHitIdx; 
    std::vector<int>* m_eclHitToMC; 
    std::vector<int>* m_eclHitToDigit; 
    std::vector<int>* m_eclHitToDigitAmp; 
    std::vector<int>* m_eclHitToPureDigit; 
    std::vector<int>* m_eclHitToPureDigitAmp; 
    std::vector<int>* m_eclHitCellId; 
    std::vector<double>* m_eclHitEnergyDep; 
    std::vector<double>* m_eclHitTimeAve; 
 
    int m_eclClusterMultip;  
    int m_eclClusterTrueMultip;  
    int m_eclClusterGammaMultip;  
    std::vector<int>* m_eclClusterIdx;  
    std::vector<int>* m_eclClusterToMC1; 
    std::vector<double>* m_eclClusterToMCWeight1; 
    std::vector<int>* m_eclClusterToMC1PDG; 
    std::vector<int>* m_eclClusterToMC2; 
    std::vector<double>* m_eclClusterToMCWeight2; 
    std::vector<int>* m_eclClusterToMC2PDG; 
    std::vector<int>* m_eclClusterToMC3; 
    std::vector<double>* m_eclClusterToMCWeight3; 
    std::vector<int>* m_eclClusterToMC3PDG; 
    std::vector<int>* m_eclClusterToMC4; 
    std::vector<double>* m_eclClusterToMCWeight4; 
    std::vector<int>* m_eclClusterToMC4PDG; 
    std::vector<int>* m_eclClusterToMC5; 
    std::vector<double>* m_eclClusterToMCWeight5; 
    std::vector<int>* m_eclClusterToMC5PDG; 
    std::vector<double>*
    m_eclClusterToBkgWeight; 
    std::vector<double>* m_eclClusterSimHitSum; 
    std::vector<int>* m_eclClusterToShower; 
    std::vector<double>* m_eclClusterEnergy; 
    std::vector<double>* m_eclClusterEnergyError; 
    std::vector<double>* m_eclClusterTheta;  
    std::vector<double>* m_eclClusterThetaError;  
    std::vector<double>* m_eclClusterPhi;  
    std::vector<double>* m_eclClusterPhiError;  
    std::vector<double>* m_eclClusterR;  
    std::vector<double>* m_eclClusterEnergyDepSum;  
    std::vector<double>* m_eclClusterTiming;  
    std::vector<double>* m_eclClusterTimingError;  
    std::vector<double>* m_eclClusterE9oE21;  
    std::vector<double>* m_eclClusterHighestE; 
    std::vector<int>* m_eclClusterCellId; 
    std::vector<int>* m_eclClusterNofCrystals;  
    std::vector<int>* m_eclClusterCrystalHealth;  
    std::vector<bool>* m_eclClusterIsTrack; 
    std::vector<double>* m_eclClusterClosestTrackDist; 
    std::vector<double>* m_eclClusterDeltaL; 
    std::vector<double>* m_eclClusterAbsZernike40; 
    std::vector<double>* m_eclClusterAbsZernike51; 
    std::vector<double>* m_eclClusterZernikeMVA; 
    std::vector<double>* m_eclClusterE1oE9; 
    std::vector<double>* m_eclClusterSecondMoment; 
    std::vector<double>* m_eclClusterLAT; 
    std::vector<double>* m_eclClusterDeltaTime99; 
    std::vector<int>* m_eclClusterDetectorRegion; 
    std::vector<int>* m_eclClusterHasNPhotonHypothesis; 
    std::vector<int>* m_eclClusterHasNeutralHadronHypothesis; 
 
    int m_eclPureDigitMultip; 
    std::vector<int>* m_eclPureDigitIdx; 
    std::vector<int>* m_eclPureDigitToMC; 
    std::vector<int>* m_eclPureDigitCellId; 
    std::vector<int>* m_eclPureDigitAmp;  
    std::vector<int>* m_eclPureDigitTimeFit;  
    std::vector<int>* m_eclPureDigitFitQuality;  
    std::vector<int>* m_eclPureDigitToCluster;  
 
    int m_eclPureCalDigitMultip; 
    std::vector<int>* m_eclPureCalDigitIdx; 
    std::vector<int>* m_eclPureCalDigitToMC1; 
    std::vector<int>* m_eclPureCalDigitToMC1PDG; 
    std::vector<double>*
    m_eclPureCalDigitToMCWeight1; 
    std::vector<int>* m_eclPureCalDigitToMC2; 
    std::vector<int>* m_eclPureCalDigitToMC2PDG; 
    std::vector<double>*
    m_eclPureCalDigitToMCWeight2; 
    std::vector<int>* m_eclPureCalDigitToMC3; 
    std::vector<int>* m_eclPureCalDigitToMC3PDG; 
    std::vector<double>*
    m_eclPureCalDigitToMCWeight3; 
    std::vector<int>* m_eclPureCalDigitToMC4; 
    std::vector<int>* m_eclPureCalDigitToMC4PDG; 
    std::vector<double>*
    m_eclPureCalDigitToMCWeight4; 
    std::vector<int>* m_eclPureCalDigitToMC5; 
    std::vector<int>* m_eclPureCalDigitToMC5PDG; 
    std::vector<double>*
    m_eclPureCalDigitToMCWeight5; 
    std::vector<double>*
    m_eclPureCalDigitToBkgWeight; 
    std::vector<double>* m_eclPureCalDigitSimHitSum; 
    std::vector<int>* m_eclPureCalDigitToShower; 
    std::vector<int>* m_eclPureCalDigitCellId; 
    std::vector<double>* m_eclPureCalDigitAmp;  
    std::vector<double>* m_eclPureCalDigitTimeFit;  
    std::vector<int>* m_eclPureCalDigitFitQuality;  
    std::vector<int>* m_eclPureCalDigitToCR; 
    std::vector<int>* m_eclPureCalDigitToLM; 
 
    std::vector<int>*    m_eclPureCRIdx; 
    std::vector<int>*    m_eclPureCRIsTrack;  
    std::vector<double>* m_eclPureCRLikelihoodMIPNGamma;  
    std::vector<double>*    m_eclPureCRLikelihoodChargedHadron;  
    std::vector<double>*    m_eclPureCRLikelihoodElectronNGamma;  
    std::vector<double>*    m_eclPureCRLikelihoodNGamma;  
    std::vector<double>*    m_eclPureCRLikelihoodNeutralHadron;  
    std::vector<double>*    m_eclPureCRLikelihoodMergedPi0;  
 
    int m_eclPureLMMultip;  
    std::vector<int>* m_eclPureLMId; 
    std::vector<int>* m_eclPureLMType; 
    std::vector<int>* m_eclPureLMCellId; 
 
    int m_eclPureClusterMultip;  
    std::vector<int>* m_eclPureClusterIdx;  
    std::vector<int>* m_eclPureClusterToMC1; 
    std::vector<double>*
    m_eclPureClusterToMCWeight1; 
    std::vector<int>* m_eclPureClusterToMC1PDG; 
    std::vector<int>* m_eclPureClusterToMC2; 
    std::vector<double>*
    m_eclPureClusterToMCWeight2; 
    std::vector<int>* m_eclPureClusterToMC2PDG; 
    std::vector<int>* m_eclPureClusterToMC3; 
    std::vector<double>*
    m_eclPureClusterToMCWeight3; 
    std::vector<int>* m_eclPureClusterToMC3PDG; 
    std::vector<int>* m_eclPureClusterToMC4; 
    std::vector<double>*
    m_eclPureClusterToMCWeight4; 
    std::vector<int>* m_eclPureClusterToMC4PDG; 
    std::vector<int>* m_eclPureClusterToMC5; 
    std::vector<double>*
    m_eclPureClusterToMCWeight5; 
    std::vector<int>* m_eclPureClusterToMC5PDG; 
    std::vector<double>*
    m_eclPureClusterToBkgWeight; 
    std::vector<double>* m_eclPureClusterEnergy; 
    std::vector<double>* m_eclPureClusterEnergyError; 
    std::vector<double>* m_eclPureClusterTheta;  
    std::vector<double>* m_eclPureClusterThetaError;  
    std::vector<double>* m_eclPureClusterPhi;  
    std::vector<double>* m_eclPureClusterPhiError;  
    std::vector<double>* m_eclPureClusterR;  
    std::vector<double>* m_eclPureClusterEnergyDepSum;  
    std::vector<double>* m_eclPureClusterTiming;  
    std::vector<double>* m_eclPureClusterTimingError;  
    std::vector<double>* m_eclPureClusterE9oE21;  
    std::vector<double>* m_eclPureClusterHighestE; 
    std::vector<int>* m_eclPureClusterCellId; 
    std::vector<double>* m_eclPureClusterLat; 
    std::vector<int>* m_eclPureClusterNofCrystals;  
    std::vector<int>* m_eclPureClusterCrystalHealth;  
    std::vector<bool>* m_eclPureClusterIsTrack; 
    std::vector<double>* m_eclPureClusterDeltaL; 
    std::vector<double>* m_eclPureClusterClosestTrackDist;  
    std::vector<double>* m_eclPureClusterAbsZernike40;  
    std::vector<double>* m_eclPureClusterAbsZernike51;  
    std::vector<double>* m_eclPureClusterZernikeMVA;  
    std::vector<double>* m_eclPureClusterSecondMoment;  
    std::vector<double>* m_eclPureClusterE1oE9;  
    std::vector<double>* m_eclPureClusterDeltaTime99;  
    std::vector<int>* m_eclPureClusterDetectorRegion; 
    std::vector<int>* m_eclPureClusterHasNPhotonHypothesis; 
    std::vector<int>* m_eclPureClusterHasNeutralHadronHypothesis; 
 
    int m_eclShowerMultip; 
    std::vector<int>* m_eclShowerIdx; 
    std::vector<int>* m_eclShowerToMC1; 
    std::vector<double>* m_eclShowerToMCWeight1; 
    std::vector<int>* m_eclShowerToMC1PDG; 
    std::vector<int>* m_eclShowerToMC1Moth; 
    std::vector<int>* m_eclShowerToMC1MothPDG; 
    std::vector<int>* m_eclShowerToMC1GMoth; 
    std::vector<int>* m_eclShowerToMC1GMothPDG; 
    std::vector<int>* m_eclShowerToMC2; 
    std::vector<double>* m_eclShowerToMCWeight2; 
    std::vector<int>* m_eclShowerToMC2PDG; 
    std::vector<int>* m_eclShowerToMC2Moth; 
    std::vector<int>* m_eclShowerToMC2MothPDG; 
    std::vector<int>* m_eclShowerToMC2GMoth; 
    std::vector<int>* m_eclShowerToMC2GMothPDG; 
    std::vector<int>* m_eclShowerToMC3; 
    std::vector<double>* m_eclShowerToMCWeight3; 
    std::vector<int>* m_eclShowerToMC3PDG; 
    std::vector<int>* m_eclShowerToMC3Moth; 
    std::vector<int>* m_eclShowerToMC3MothPDG; 
    std::vector<int>* m_eclShowerToMC3GMoth; 
    std::vector<int>* m_eclShowerToMC3GMothPDG; 
    std::vector<int>* m_eclShowerToMC4; 
    std::vector<double>* m_eclShowerToMCWeight4; 
    std::vector<int>* m_eclShowerToMC4PDG; 
    std::vector<int>* m_eclShowerToMC4Moth; 
    std::vector<int>* m_eclShowerToMC4MothPDG; 
    std::vector<int>* m_eclShowerToMC4GMoth; 
    std::vector<int>* m_eclShowerToMC4GMothPDG; 
    std::vector<int>* m_eclShowerToMC5; 
    std::vector<double>* m_eclShowerToMCWeight5; 
    std::vector<int>* m_eclShowerToMC5PDG; 
    std::vector<int>* m_eclShowerToMC5Moth; 
    std::vector<int>* m_eclShowerToMC5MothPDG; 
    std::vector<int>* m_eclShowerToMC5GMoth; 
    std::vector<int>* m_eclShowerToMC5GMothPDG; 
    std::vector<double>*
    m_eclShowerToBkgWeight; 
    std::vector<int>* m_eclShowerToLM1; 
    std::vector<int>* m_eclShowerToLM2; 
    std::vector<int>* m_eclShowerToLM3; 
    std::vector<int>* m_eclShowerToLM4; 
    std::vector<int>* m_eclShowerToLM5; 
    std::vector<double>* m_eclShowerSimHitSum; 
    std::vector<double>* m_eclShowerUncEnergy; 
    std::vector<double>* m_eclShowerEnergy; 
    std::vector<double>* m_eclShowerTheta; 
    std::vector<double>* m_eclShowerPhi; 
    std::vector<double>* m_eclShowerR; 
    std::vector<double>* m_eclShowerNHits; 
    std::vector<double>* m_eclShowerE9oE21; 
    std::vector<double>* m_eclShowerTime;  
    std::vector<double>* m_eclShowerT99;  
    std::vector<int>* m_eclShowerConnectedRegionId; 
    std::vector<int>* m_eclShowerHypothesisId; 
    std::vector<int>* m_eclShowerCentralCellId; 
    std::vector<double>* m_eclShowerEnergyError; 
    std::vector<double>* m_eclShowerThetaError; 
    std::vector<double>* m_eclShowerPhiError; 
    std::vector<double>* m_eclShowerTimeResolution; 
    std::vector<double>* m_eclShowerHighestEnergy; 
    std::vector<double>* m_eclShowerLateralEnergy; 
    std::vector<double>* m_eclShowerMinTrkDistance; 
    std::vector<double>* m_eclShowerTrkDepth; 
    std::vector<double>* m_eclShowerShowerDepth; 
    std::vector<double>* m_eclShowerAbsZernike40; 
    std::vector<double>* m_eclShowerAbsZernike51; 
    std::vector<double>* m_eclShowerZernikeMVA; 
    std::vector<double>* m_eclShowerSecondMoment; 
    std::vector<double>* m_eclShowerE1oE9; 
    std::vector<int>* m_eclShowerIsTrack; 
    std::vector<bool>* m_eclShowerIsCluster; 
    std::vector<int>*   m_eclShowerMCVtxInEcl; 
    std::vector<int>*   m_eclShowerMCFlightMatch; 
    std::vector<int>*
    m_eclShowerMCFFlightMatch; 
    std::vector<double>*   m_eclShowerHighestE1mE2; 
    std::vector<double>*   m_eclShowerNumberOfCrystalsForEnergy; 
 
    int m_mcMultip; 
    std::vector<int>* m_mcIdx; 
    std::vector<int>* m_mcPdg; 
    std::vector<int>* m_mcMothPdg; 
    std::vector<int>* m_mcGMothPdg; 
    std::vector<int>* m_mcGGMothPdg; 
    std::vector<double>* m_mcEnergy; 
    std::vector<double>* m_mcPx; 
    std::vector<double>* m_mcPy; 
    std::vector<double>* m_mcPz; 
    std::vector<double>* m_mcDecayVtxX; 
    std::vector<double>* m_mcDecayVtxY; 
    std::vector<double>* m_mcDecayVtxZ; 
    std::vector<double>* m_mcProdVtxX; 
    std::vector<double>* m_mcProdVtxY; 
    std::vector<double>* m_mcProdVtxZ; 
    std::vector<int>* m_mcSecondaryPhysProc; 
 
    int m_trkMultip; 
    std::vector<int>* m_trkPdg; 
    std::vector<int>* m_trkIdx; 
    std::vector<int>* m_trkCharge; 
    std::vector<double>* m_trkPx; 
    std::vector<double>* m_trkPy; 
    std::vector<double>* m_trkPz; 
    std::vector<double>* m_trkP; 
    std::vector<double>* m_trkTheta; 
    std::vector<double>* m_trkPhi; 
    std::vector<double>* m_trkX; 
    std::vector<double>* m_trkY; 
    std::vector<double>* m_trkZ; 
 
    std::vector<int>* m_eclpidtrkIdx; 
    std::vector<double>* m_eclpidEnergy; 
    std::vector<double>* m_eclpidEop; 
    std::vector<double>* m_eclpidE9E21; 
    std::vector<int>* m_eclpidNCrystals; 
    std::vector<int>* m_eclpidNClusters; 
    std::vector<double>* m_eclLogLikeEl; 
    std::vector<double>* m_eclLogLikeMu; 
    std::vector<double>* m_eclLogLikePi; 
  };

}