ECLLocalMaximumFinderModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Belle II Local Maximum Finder (LMF). Two stage procedure: First it     *
 * searches a local maximum (energy higher than all neighbours and above  *
 * threshold) and second it uses a method  for different                  *
 * particle types to decide if the local maximum is a candidate. Each     *
 * candidate will result in one shower/cluster in the end.                *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (ferber@physics.ubc.ca)                    *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
// FRAMEWORK
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <framework/gearbox/Unit.h>
#include <framework/geometry/B2Vector3.h> // faster than TVector3
 
class TTree;
class TFile;
 
namespace Belle2 {
  class MCParticle;
  class ECLHit;
  class ECLDigit;
  class ECLCalDigit;
  class ECLLocalMaximum;
  class ECLConnectedRegion;
 
  namespace ECL {
    class ECLNeighbours;
    class ECLGeometryPar;
  }
 
  class ECLLocalMaximumFinderModule : public Module {
 
  public:
    ECLLocalMaximumFinderModule();
 
    virtual ~ECLLocalMaximumFinderModule();
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() override;
 
    StoreArray<MCParticle> m_mcParticles;
 
    StoreArray<ECLHit> m_eclHits;
 
    StoreArray<ECLDigit> m_eclDigits;
 
    StoreArray<ECLCalDigit> m_eclCalDigits;
 
    StoreArray<ECLConnectedRegion> m_eclConnectedRegions;
 
    StoreArray<ECLLocalMaximum> m_eclLocalMaximums;
 
    virtual const char* mcParticleArrayName() const
    { return "MCParticles" ; }
 
    virtual const char* eclHitArrayName() const
    { return "ECLHits" ; }
 
    virtual const char* eclDigitArrayName() const
    { return "ECLDigits" ; }
 
    virtual const char* eclCalDigitArrayName() const
    { return "ECLCalDigits" ; }
 
    virtual const char* eclConnectedRegionArrayName() const
    { return "ECLConnectedRegions" ; }
 
    virtual const char* eclLocalMaximumArrayName() const
    { return "ECLLocalMaximums" ; }
 
    void resetClassifierVariables();
 
    void resetTrainingVariables();
 
    void makeLocalMaximum(const ECLConnectedRegion& aCR, const int cellId, const int lmId);
 
    void addToSignalEnergy(int& motherpdg, int& motherindex, int& pi0index, const double& weight);
 
    bool isEnteringECL(const B2Vector3D& vec);
 
    void getEnteringMother(const MCParticle& particle, int& pdg, int& arrayindex, int& pi0arrayindex);
 
    int getIdPosition(const int type, const int id);
 
    void getMax(int& maxtype, int& maxpos);
 
  private:
 
    // Module parameters
    double m_energyCut; 
    int m_isTrainingMode; 
    std::string m_outfileName; 
    std::string m_method; 
    double m_truthFraction; 
    double m_cutOffset; 
    double m_cutSlope; 
    double m_cutRatioCorrection; 
    // Constants
    const double c_minEnergyCut = 5.0 * Belle2::Unit::MeV; 
    std::vector< int > m_StoreArrPosition;
 
    ECL::ECLNeighbours* m_neighbourMap{nullptr};
 
    ECL::ECLGeometryPar* m_geom{nullptr};
 
    TFile* m_outfile{nullptr}; 
    TTree* m_tree{nullptr}; 
    const static unsigned c_nMaxNeighbours = 12; 
    float m_energyRatioNeighbour[c_nMaxNeighbours] {}; 
    float m_time = 0.0;  
    float m_energy = 0.0; 
    float m_thetaId = 0.0;  
    float m_phiId = 0.0;  
    float m_cellId = 0.0;  
    float m_maxNeighbourEnergy = 0.0;  
    float m_timeResolution = 0.0;  
    float m_timeFitFailed = 0.0;  
    float m_CRId = 0.0; 
    float m_LMId = 0.0; 
    float m_target = 0.0; 
    float m_targetindex = 0.0; 
    float m_targetpi0index = 0.0; 
    float m_nNeighbours10 = 0.0;  
    float m_maxEnergyRatio = 0.0;  
    double m_totalSignalEnergy = 0.0; 
    double m_signalEnergy[10][5] {}; 
    int m_signalId[10][5] {}; 
  };
 
  class ECLLocalMaximumFinderPureCsIModule : public ECLLocalMaximumFinderModule {
  public:
    //virtual const char* eclHitArrayName() const override
    //{ return "ECLHitsPureCsI" ; }
 
    virtual const char* eclDigitArrayName() const override
    { return "ECLDigitsPureCsI" ; }
 
    virtual const char* eclCalDigitArrayName() const override
    { return "ECLCalDigitsPureCsI" ; }
 
    virtual const char* eclConnectedRegionArrayName() const override
    { return "ECLConnectedRegionsPureCsI" ; }
 
    virtual const char* eclLocalMaximumArrayName() const override
    { return "ECLLocalMaximumsPureCsI" ; }
 
  }; // end of ECLLocalMaximumFinderPureCsIModule
 
} // end of Belle2 namespace