JPDB.hh

Go to the documentation of this file.

#ifndef __JAANET__JPDB__
#define __JAANET__JPDB__

#include <string>
#include <ostream>
#include <iomanip>
#include <vector>
#include <algorithm>

#include "JAAnet/JParticleTypes.hh"
#include "JTools/JConstants.hh"

#include "JLang/JPredicate.hh"
#include "JLang/JException.hh"

#include "Jeep/JPrint.hh"


/**
 * \author mdejong
 */

namespace JAANET {}
namespace JPP { using namespace JAANET; }

namespace JAANET {

  using JLANG::JException;

  /**
   * Auxiliary class to handle particle name, codes and mass.
   */
  struct JParticle {
    /**
     * Default constructor.
     */
    JParticle()
    {
      this->name  = "";
      this->pdg   = 0;
      this->geant = 0;
      this->mass  = 0.0;
    }

    
    /**
     * Constructor.
     *
     * \param  name              name       of particle
     * \param  pdg               PDG   code of particle
     * \param  geant             GEANT code of particle
     * \param  mass              mass       of particle
     */
    JParticle(const std::string& name,
              const int          pdg,
              const int          geant,
              const double       mass)
    {
      this->name  = name;
      this->pdg   = pdg;
      this->geant = geant;
      this->mass  = mass;
    }


    /**
     * Print particle.
     *
     * \param  out               output stream
     * \param  particle          particle
     * \return                   output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JParticle& particle) 
    {
      using namespace std;
      using namespace JEEP;
      
      return out << setw(32) << left  << particle.name  << "  "
                 << setw( 6) << right << particle.pdg   << "  "
                 << setw( 6) << right << particle.geant << "  "
                 << FIXED(12,10)      << particle.mass;
    }

    
    std::string name;     //!< name       of particle
    int         pdg;      //!< PDG   code of particle
    int         geant;    //!< GEANT code of particle
    double      mass;     //!< mass       of particle [GeV]
  };


  /**
   * Auxiliary macro for particle creation.
   *
   * \param  PDG               PDG   code
   * \param  GEANT             GEANT code
   * \param  MASS              mass
   */
#define MAKE_PARTICLE(PDG, GEANT, MASS) JParticle(#PDG, PDG, GEANT, MASS)

  
  /**
   * Collection of particles.
   */
  struct JPDB :
    public std::vector<JParticle>
  {
    /**
     * Default constructor.
     */
    JPDB()
    {}


    /**
     * Get particle data book.
     * This particle data book contains all known GEANT particle codes.
     *
     * \return                   particle data book
     */
    static const JPDB& getInstance()
    {
      using namespace JAANET;
      using namespace JTOOLS;
      
      static JPDB pdb;

      if (pdb.empty()) {
        
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ELECTRON,          GEANT4_TYPE_ELECTRON,         MASS_ELECTRON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NUE,               GEANT4_TYPE_NEUTRINO,         MASS_ELECTRON_NEUTRINO));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_MUON,              GEANT4_TYPE_MUON,             MASS_MUON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NUMU,              GEANT4_TYPE_NEUTRINO,         MASS_MUON_NEUTRINO));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_TAU,               GEANT4_TYPE_TAU,              MASS_TAU));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NUTAU,             GEANT4_TYPE_NEUTRINO,         MASS_TAU_NEUTRINO));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_PHOTON,            GEANT4_TYPE_PHOTON,           MASS_PHOTON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NEUTRAL_PION,      GEANT4_TYPE_NEUTRAL_PION,     MASS_NEUTRAL_PION));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_PION_PLUS,         GEANT4_TYPE_PION_PLUS,        MASS_CHARGED_PION));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_K_LONG,            GEANT4_TYPE_KAON_LONG,        MASS_NEUTRAL_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_K_SHORT,           GEANT4_TYPE_KAON_SHORT,       MASS_NEUTRAL_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_K_PLUS,            GEANT4_TYPE_KAON_PLUS,        MASS_CHARGED_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_PROTON,            GEANT4_TYPE_PROTON,           MASS_PROTON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NEUTRON,           GEANT4_TYPE_NEUTRON,          MASS_NEUTRON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_LAMBDA,            GEANT4_TYPE_LAMBDA,           MASS_LAMBDA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_SIGMA_PLUS,        GEANT4_TYPE_SIGMA_PLUS,       MASS_CHARGED_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NEUTRAL_SIGMA,     GEANT4_TYPE_NEUTRAL_SIGMA,    MASS_NEUTRAL_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_SIGMA_MINUS,       GEANT4_TYPE_SIGMA_MINUS,      MASS_CHARGED_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_NEUTRAL_XI,        GEANT4_TYPE_NEUTRAL_XI,       MASS_NEUTRAL_XI));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_XI_MINUS,          GEANT4_TYPE_XI_MINUS,         MASS_CHARGED_XI));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_OMEGA_MINUS,       GEANT4_TYPE_OMEGA_MINUS,      MASS_CHARGED_OMEGA));

        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIELECTRON,      GEANT4_TYPE_ANTIELECTRON,     MASS_ELECTRON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINUE,           GEANT4_TYPE_NEUTRINO,         MASS_ELECTRON_NEUTRINO));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIMUON,          GEANT4_TYPE_ANTIMUON,         MASS_MUON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINUMU,          GEANT4_TYPE_NEUTRINO,         MASS_MUON_NEUTRINO));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTITAU,           GEANT4_TYPE_ANTITAU,          MASS_TAU));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINUTAU,         GEANT4_TYPE_NEUTRINO,         MASS_TAU_NEUTRINO));
        // anti-photon does not exist
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_PION_MINUS,        GEANT4_TYPE_PION_MINUS,       MASS_CHARGED_PION));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIK_LONG,        GEANT4_TYPE_KAON_LONG,        MASS_NEUTRAL_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIK_SHORT,       GEANT4_TYPE_KAON_SHORT,       MASS_NEUTRAL_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_K_MINUS,           GEANT4_TYPE_KAON_MINUS,       MASS_CHARGED_KAON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIPROTON,        GEANT4_TYPE_ANTIPROTON,       MASS_PROTON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINEUTRON,       GEANT4_TYPE_ANTINEUTRON,      MASS_NEUTRON));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTILAMBDA,        GEANT4_TYPE_ANTILAMBDA,       MASS_LAMBDA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTISIGMA_PLUS,    GEANT4_TYPE_ANTISIGMA_PLUS,   MASS_CHARGED_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINEUTRAL_SIGMA, GEANT4_TYPE_NEUTRAL_SIGMA,    MASS_NEUTRAL_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTISIGMA_MINUS,   GEANT4_TYPE_ANTISIGMA_MINUS,  MASS_CHARGED_SIGMA));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTINEUTRAL_XI,    GEANT4_TYPE_NEUTRAL_XI,       MASS_NEUTRAL_XI));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIXI_MINUS,      GEANT4_TYPE_ANTIXI_PLUS,      MASS_CHARGED_XI));
        pdb.push_back(MAKE_PARTICLE(TRACK_TYPE_ANTIOMEGA_MINUS,   GEANT4_TYPE_ANTIOMEGA_PLUS,   MASS_CHARGED_OMEGA));
      }

      return pdb;
    }

    
    /**
     * Check if PDB has particle corresponding to given GEANT code.
     *
     * \param  geant             GEANT code
     * \return                   true if available; else false
     */
    bool hasGEANT(const int geant) const
    {
      return (find_if(this->begin(), this->end(), JLANG::make_predicate(&JParticle::geant, geant)) != this->end());
    }

    
    /**
     * Get particle corresponding to given GEANT code.\n
     * This method throws an error if the particle cannot be found.
     *
     * \param  geant             GEANT code
     * \return                   particle
     */
    const JParticle& getGEANT(const int geant) const
    {
      const_iterator p = find_if(this->begin(), this->end(), JLANG::make_predicate(&JParticle::geant, geant));

      if (p != this->end())
        return *p;
      else
        THROW(JException, "Invalid GEANT particle code " << geant);
    }

    
    /**
     * Check if PDB has particle corresponding to given PDG code.
     *
     * \param  pdg               PDG code
     * \return                   true if available; else false
     */
    bool hasPDG(const int pdg) const
    {
      return (find_if(this->begin(), this->end(), JLANG::make_predicate(&JParticle::pdg, pdg)) != this->end());
    }

    
    /**
     * Get particle corresponding to given PDG code.\n
     * This method throws an error if the particle cannot be found.
     *
     * \param  pdg               PDG code
     * \return                   particle
     */
    const JParticle& getPDG(const int pdg) const
    {
      const_iterator p = find_if(this->begin(), this->end(), JLANG::make_predicate(&JParticle::pdg, pdg));

      if (p != this->end())
        return *p;
      else
        THROW(JException, "Invalid PDG particle code " << pdg);
    }


    /**
     * Print particle data book.
     *
     * \param  out               output stream
     * \param  pdb               particle data book
     * \return                   output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPDB& pdb) 
    {
      using namespace std;

      out << setw(32) << left  << "particle"     << "  "
          << setw( 6) << right << "PDG"          << "  "
          << setw( 6) << right << "GEANT"        << "  "
          << setw(12) << right << "Mass [GeV]"   << endl;

      for (JPDB::const_iterator i = pdb.begin(); i != pdb.end(); ++i) {
        out << *i << endl;
      }

      return out;
    }
  };
}

#endif