NuEEnergyAlg.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////                                               
/// \file    NuEEnergyAlg.h                                                                                           
/// \brief   Calculates deposited and corrected energy of the electron 
///          shower and of electron flavoured neutrino.
///                                                                                                                     
/// \author  ksachdev@physics.umn.edu                                                                                   
////////////////////////////////////////////////////////////////////////                                               


#ifndef NuEEnergyAlg_h
#define NuEEnergyAlg_h


#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Provenance/EventID.h"

#include "Geometry/Geometry.h"

namespace rb {
  class Cluster;
  class Shower;
  class CellHit;
  class Vertex;
}


namespace slid {

  class NuEEnergyAlg {
  public:

    explicit NuEEnergyAlg(fhicl::ParameterSet const& pset);

    ~NuEEnergyAlg();

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


    /// \brief Returns the energy deposited in a cell.
    /// Used in computation of total shower energy.
    /// Only used if fUseStdCellE is false.
    double CellEnergy(const rb::Shower* shower,
                      const std::vector< const rb::Shower* > showercol,
                      const int  & index,
                      const art::EventID & evtid,
                      bool useweight = true,
                      bool* isCalibrated = NULL
                      );


    /// \brief Correct cell DATA/MC difference in
    /// cell energy computation. Only used if 
    /// fCorDataCell is true
    double CellEDataMC(double gev, double w,
                       geo::View_t view);


    /// \brief Convert ADC to GeV based on JM
    /// attenuation fits
    double CellADCToGeV(double d, geo::View_t view);


    /// \brief EM shower energy correction for MC
    /// Only used if fCorAbsCell is false
    double ECorrMC(double gev);


    /// \brief Returns the deposited energy of a shower.
    /// Does not contain corrections due to dead material
    /// or threshold effects.
    double ShowerDepEnergy(const rb::Shower* shower,
                           const std::vector< const rb::Shower* > showercol,
                           const art::Event& evt);


    /// \brief Returns the total  energy of a shower.
    /// along with corrections due to dead material
    /// and threshold effects (position correction).
    double ShowerEnergy(const rb::Shower* shower,
                        const std::vector< const rb::Shower* > showercol,
                        const art::Event& evt);



    /// \brief Returns the deposited hadronic energy
    double HadronicDepEnergy(const std::vector< const rb::Shower* > showercol,
                             const rb::Cluster* slice,
                             const int & elecShowerIndex,
                             const art::Event& evt);


    /// \brief Returns the hadronic energy in the 
    /// slice, assuming 'shower' is the electron
    /// shower
    double HadronicEnergy(const std::vector< const rb::Shower* > showercol,
                          const rb::Cluster* slice,
                          const int & elecShowerIndex,
                          const art::Event& evt);
        

    /// \brief Returns the neutrino energy, assuming 
    /// 'shower' is electron shower.
    double NuEEnergy(const std::vector< const rb::Shower* > shower,
                     const rb::Cluster* slice,
                     const int & elecShowerIndex,
                     const art::Event& evt);

    /// \brief Returns energy within 8 planes of the start of the shower 
    double VertexEnergy( const rb::Shower * shower,
                         const std::vector< const rb::Shower* > showercol,
                         const rb::Vertex *  vertex,
                         const rb::Cluster * slice,
                         const art::Event& evt);
    
    /// \brief Returns sum of ShowerEnergy of all showers in showercol
    double ShowerSumEnergy(const std::vector< const rb::Shower* > shower,
                           const art::Event& evt);
    
    
  private:

    art::ServiceHandle<geo::Geometry> fGeom;

    bool fCorDataCell;  ///< Should Data MC cell energy correction be used?
    bool fCorAbsCell;   ///< Should non-standard absolute energy calibration be used?
    bool fUseStdCellE;  ///< Should standard recoHit function, GeV(), be used to compute cell energy?
    float fPEThreshold; ///< PE threshold for considering a hit in hadronic energy calculation
    
    bool fUseUncalibHits; ///< Do we want to use uncalibrated hits in the energy calculations?

    /// This map holds info about the cells that are shared by                                                                    
    /// multiple prongs. The key is the channel, and the value                                                                    
    /// is another map. In the inner map, the key is the index                                                                    
    /// of the prong and the value is the index of the cell in                                                                  
    /// that prong. Therefore, fHitShowerMap[chan][prgIdx] = [cellIdx] 
    std::map< uint32_t , std::map< int,  int > > fHitShowerMap;

    /// \brief Fills fHitShowerMap
    void GetHitShowerMap( std::vector< const rb::Shower *>  showercol);

    /// 
    std::vector< const rb::Shower* > fShowerCol;
    
    /// Function to determine whether or not fHitShowerMap is filled for 
    /// the current shower collection?
    bool MapFilled(std::vector< const rb::Shower *>  showercol);

    /// Is fHitShowerMap filled for the current shower collection?
    bool fMapIsFilled;

    /// Event number 
    art::EventID fEvtId;

    /// This function calculates the cell energy that doesn't
    /// use the standard calibration. This gets used in CellEnergy
    /// function, if fUseStdCellE is set to false.
    double NonStdCellEnergy( const rb::CellHit *  cHit,
                             const int    & detid,
                             const double & readoutD,
                             const double & w,
                             const double & norm,
                             const double & weight);
    
    /// Clears the privately owned variables of this class.
    void ClearVars(const art::EventID& evtid);

  }; // end of NuEEnergyAlg class definition

} // end of slid namespace

#endif //NuEEnergyAlg_h