ECLShowerShapeModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * This module calculates shower shape variables.                         *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (ferber@physics.ubc.ca)                    *
 *               Guglielmo De Nardo (denardo@na.infn.it)                  *
 *               Alon Hershenhorn   (hershen@phas.ubc.ca)                 *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
//STL
#include <complex>
 
//ROOT
#include <TGraph.h>
 
// FRAMEWORK
#include <framework/core/Module.h>
#include <framework/database/DBArray.h>
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/gearbox/Unit.h>
 
namespace Belle2 {
  class DatabaseRepresentationOfWeightfile;
  class ECLConnectedRegion;
  class ECLShower;
  class ECLShowerShapeSecondMomentCorrection;
 
  namespace MVA {
    class Expert;
    class SingleDataset;
  }
 
  namespace ECL {
    class ECLNeighbours;
  }
 
  class ECLShowerShapeModule : public Module {
 
  public:
 
    enum {
      c_thetaType = 0, 
      c_phiType = 1, 
    };
 
 
    ECLShowerShapeModule();
 
    ~ECLShowerShapeModule();
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() override;
 
  private:
 
    struct ProjectedECLDigit {
 
      double energy;
 
      double rho;
 
      double alpha;
    };
 
    StoreArray<ECLConnectedRegion> m_eclConnectedRegions;
 
    // Module Parameters
    double m_zernike_n1_rho0; 
    double m_zernike_n2_rho0; 
    bool m_zernike_useFarCrystals; 
    double m_avgCrystalDimension; 
    const double m_BRLthetaMin = 32.2 * Unit::deg; 
    const double m_BRLthetaMax = 128.7 * Unit::deg; 
    const unsigned int m_numZernikeMVAvariables = 22; 
    std::string m_zernike_MVAidentifier_FWD; 
    std::string m_zernike_MVAidentifier_BRL; 
    std::string m_zernike_MVAidentifier_BWD; 
    std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>
                                                               m_weightfile_representation_FWD; 
    std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>
                                                               m_weightfile_representation_BRL; 
    std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>
                                                               m_weightfile_representation_BWD; 
    std::unique_ptr<MVA::Expert> m_expert_FWD; 
    std::unique_ptr<MVA::Expert> m_expert_BRL; 
    std::unique_ptr<MVA::Expert> m_expert_BWD; 
    std::unique_ptr<MVA::SingleDataset>
    m_dataset; 
    std::unique_ptr<ECL::ECLNeighbours> m_neighbourMap9;
 
    std::unique_ptr<ECL::ECLNeighbours> m_neighbourMap21;
 
    void initializeMVAweightFiles(const std::string& identifier,
                                  std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>& weightFileRepresentation);
 
    void initializeMVA(const std::string& identifier,
                       std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>& weightFileRepresentation, std::unique_ptr<MVA::Expert>& expert);
 
    void setShowerShapeVariables(ECLShower* eclShower, const bool calculateZernikeMVA) const;
 
    double computeLateralEnergy(const std::vector<ProjectedECLDigit>& projectedDigits, const double avgCrystalDimension) const;
 
    double computeAbsZernikeMoment(const std::vector<ProjectedECLDigit>& projectedDigits, const double totalEnergy, const int n,
                                   const int m,
                                   const double rho) const;
 
    double computeSecondMoment(const std::vector<ProjectedECLDigit>& shower, const double totalEnergy) const;
 
    std::vector<ProjectedECLDigit> projectECLDigits(const ECLShower& shower) const;
 
    double Rnm(const int n, const int m, const double rho) const;
 
    std::complex<double> zernikeValue(const double rho, const double alpha, const int n, const int m) const;
 
    double computeE9oE21(const ECLShower&) const;
 
    double computeE1oE9(const ECLShower&) const;
 
    DBArray<ECLShowerShapeSecondMomentCorrection> m_secondMomentCorrectionArray;  
    TGraph m_secondMomentCorrections[2][10];
 
    void prepareSecondMomentCorrectionsCallback();
 
    double getSecondMomentCorrection(const double theta, const double phi, const int hypothesis) const;
 
  public:
    virtual const char* eclShowerArrayName() const
    { return "ECLShowers" ; }
 
    virtual const char* eclCalDigitArrayName() const
    { return "ECLCalDigits" ; }
 
    virtual const char* eclConnectedRegionArrayName() const
    { return "ECLConnectedRegions" ; }
 
  }; // end of ECLShowerShapeModule
 
 
  class ECLShowerShapePureCsIModule : public ECLShowerShapeModule {
  public:
 
    virtual const char* eclShowerArrayName() const override
    { return "ECLShowersPureCsI" ; }
 
    virtual const char* eclCalDigitArrayName() const override
    { return "ECLCalDigitsPureCsI" ; }
 
    virtual const char* eclConnectedRegionArrayName() const override
    { return "ECLConnectedRegionsPureCsI" ; }
 
  }; // end of ECLShowerShapePureCsIModule
 
} // end of Belle2 namespace