JVisibleEnergyToolkit.hh

Go to the documentation of this file.

#ifndef __JSIRENE__JVISIBLEENERGYTOOLKIT__
#define __JSIRENE__JVISIBLEENERGYTOOLKIT__

#include "km3net-dataformat/definitions/trkmembers.hh"
#include "km3net-dataformat/offline/Vec.hh"
#include "km3net-dataformat/offline/Trk.hh"
#include "km3net-dataformat/offline/Evt.hh"

#include "JAAnet/JAAnetToolkit.hh"
#include "JAAnet/JParticleTypes.hh"
#include "JAAnet/JPDB.hh"

#include "JGeometry2D/JVector2D.hh"
#include "JGeometry2D/JCircle2D.hh"

#include "JGeometry3D/JCylinder3D.hh"
#include "JGeometry3D/JGeometry3DToolkit.hh"

#include "JPhysics/JConstants.hh"
#include "JPhysics/JGeane.hh"

#include "JSirene/pythia.hh"


/**
 * \file
 *
 * Auxiliary methods for evaluating visible energies.
 * \author bjung
 */
namespace JSIRENE {}
namespace JPP { using namespace JSIRENE; }

namespace JSIRENE {
  
  using JGEOMETRY3D::JCylinder3D;
  using JGEOMETRY3D::getMaximumContainmentVolume;


  /**
   * Get the visible energy of a track.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  track         track
   * \param  can           detector can  
   * \return               visible energy [GeV]
   */
  double getVisibleEnergy(const Trk&         track,
                          const JCylinder3D& can = getMaximumContainmentVolume())
  {
    using namespace std;
    using namespace JPP;

    double Evis = 0.0;
    
    if (is_finalstate(track)) {
      
      if (is_muon(track)) {

        // Determine muon pathlength inside detector [m]

        const JCylinder3D::intersection_type& intersection = can.getIntersection(getAxis(track));

        const double Lmuon = gWater.getX(track.E, MASS_MUON / getSinThetaC()); 
        const double Leff  = (intersection.first < 0.0        ? 
                              min(Lmuon, intersection.second) : 
                              min(Lmuon, intersection.second) - intersection.first);

        // Determine visible energy deposition [GeV]
      
        const double dEb = gWater.getEb(track.E, Leff);
        const double dEc = Leff / geanc();
      
        Evis = dEb + dEc;
          
      } else if (!is_neutrino(track) && JPDB::getInstance().hasPDG(track.type)) {

        Evis = pythia(track.type, getKineticEnergy(track));
      }
    }

    return Evis;
  }
  
  
  /**
   * Get the visible energy vector of a track.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  track         track
   * \param  can           detector can  
   * \return               visible energy vector [GeV]
   */
  inline Vec getVisibleEnergyVector(const Trk&         track,
                                    const JCylinder3D& can = getMaximumContainmentVolume()) {
    return getVisibleEnergy(track, can) * track.dir;
  }


  /**
   * Get the visible energy of a given range of tracks.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  __begin       start of track data
   * \param  __end         end of track data
   * \param  can           detector can  
   * \return               visible energy [GeV]
   */
  inline double getVisibleEnergy(std::vector<Trk>::const_iterator __begin,
                                 std::vector<Trk>::const_iterator __end,
                                 const JCylinder3D&               can = getMaximumContainmentVolume())
  {
    using namespace std;
    
    double Evis = 0.0;
    
    for (vector<Trk>::const_iterator track = __begin; track != __end; ++track) {
      Evis += getVisibleEnergy(*track, can);
    }
    
    return Evis;
  }


  /**
   * Get the visible energy vector of a given range of tracks.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  __begin       start of track data
   * \param  __end         end of track data
   * \param  can           detector can  
   * \return               visible energy vector [GeV]
   */
  inline Vec getVisibleEnergyVector(std::vector<Trk>::const_iterator __begin,
                                    std::vector<Trk>::const_iterator __end,
                                    const JCylinder3D&               can = getMaximumContainmentVolume())
  {
    using namespace std;
    
    Vec Evis(0.0, 0.0, 0.0);    

    for (vector<Trk>::const_iterator track = __begin; track != __end; ++track) {
      Evis += getVisibleEnergyVector(*track, can);
    }

    return Evis;
  }


  /**
   * Get the visible energy vector of an event.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  evt           event
   * \param  can           detector can  
   * \return               visible energy [GeV]
   */
  inline double getVisibleEnergy(const Evt&         evt,
                                 const JCylinder3D& can  = getMaximumContainmentVolume())
  {
    return getVisibleEnergy(evt.mc_trks.begin(), evt.mc_trks.end(), can);
  }
  

  /**
   * Get the visible energy vector of an event.\n
   * This method accounts for muon radiative energy losses.
   *
   * \param  evt           event
   * \param  can           detector can  
   * \return               visible energy vector [GeV]
   */
  inline Vec getVisibleEnergyVector(const Evt&         evt,
                                    const JCylinder3D& can  = getMaximumContainmentVolume())
  {
    return getVisibleEnergyVector(evt.mc_trks.begin(), evt.mc_trks.end(), can);
  }
}

#endif