primary_particle.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-04-11
 * Last modified: 2015-06-19
 *
 * License:
 * Copyright 2007-2015 F. Mauger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   Primary particle for MC generators
 *
 */

#ifndef GENBB_HELP_PRIMARY_PARTICLE_H
#define GENBB_HELP_PRIMARY_PARTICLE_H 1

// Standard library:
#include <cstdlib>
#include <cmath>
#include <stdexcept>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <list>

// Third party:
// - Boost:
#include <boost/cstdint.hpp>
// - CLHEP:
#include <CLHEP/Vector/LorentzVector.h>
// - Bayeux/datatools:
#include <datatools/properties.h>
#include <datatools/utils.h>
#include <datatools/units.h>
#include <datatools/i_tree_dump.h>
#include <datatools/i_serializable.h>
// - Bayeux/geomtools:
#include <geomtools/utils.h>
// - Bayeux/genbb_help:
#include <genbb_help/genbb_help_config.h>

namespace genbb {

  class primary_particle
    : public datatools::i_serializable,
      public datatools::i_tree_dumpable
  {
  public:

    static const int INVALID_GENERATION_ID = -1;

    enum particle_type {
      // UNDEF              = -1, //!< @deprecated Undefined particle type
      PARTICLE_UNDEFINED = -1, 
      PARTICLE_UNKNOWN   = 0,  
      GAMMA              = 1,
      POSITRON           = 2,
      ELECTRON           = 3,
      NEUTRINO           = 4,
      MUON_PLUS          = 5,
      MUON_MINUS         = 6,
      PION_0             = 7,
      PION_PLUS          = 8,
      PION_MINUS         = 9,
      KAON_0_LONG        = 10,
      KAON_PLUS          = 11,
      KAON_MINUS         = 12,
      NEUTRON            = 13,
      PROTON             = 14,
      ANTI_PROTON        = 15,
      KAON_0_SHORT       = 16,
      ETA                = 17,
      LAMBDA             = 18,
      SIGMA_PLUS         = 19,
      SIGMA_0            = 20,
      SIGMA_MINUS        = 21,
      XI_0               = 22,
      XI_MINUS           = 23,
      OMEGA_MINUS        = 24,
      ANTI_NEUTRON       = 25,
      ANTI_LAMBDA        = 26,
      ANTI_SIGMA_MINUS   = 27, // BEWARE: same as Geant4 "anti_sigma+"
      ANTI_SIGMA_0       = 28, // BEWARE: same as Geant4 "anti_sigma0"
      ANTI_SIGMA_PLUS    = 29, // BEWARE: same as Geant4 "anti_sigma-"
      ANTI_XI_0          = 30, // BEWARE: same as Geant4 "anti_xi0"
      ANTI_XI_PLUS       = 31, // BEWARE: same as Geant4 "anti_xi-"
      ANTI_OMEGA_PLUS    = 32, // BEWARE: same as Geant4 "anti_omega-"
      DEUTERON           = 45,
      TRITIUM            = 46,
      TRITON             = 46,
      ALPHA              = 47,
      GEANTINO           = 48,
      HE3                = 49,
      CERENKOV           = 50, // Optical photon/scintillation/Cerenkov
      // Additional codes:
      NUCLEUS            = 1000000000, 
      ION                = 1100000000  
    };

    static const int32_t PDG_CODE_UNDEFINED = 0;

    static std::string nucleus_to_label(int z_, int a_, double excitation_energy_ = 0.0);

    static std::string ion_to_label(int z_, int a_, double excitation_energy_ = 0.0, int charge_ = 0);

    static bool label_to_ion(const std::string label_, int & z_, int & a_, double & excitation_energy_, int & charge_);

    static bool label_to_nucleus(const std::string label_, int & z_, int & a_, double & excitation_energy_);

    void reset();

    bool has_generation_id() const;

    void set_generation_id(int);

    void reset_generation_id();

    int get_generation_id() const;

    bool has_type() const;

    int get_type() const;

    void set_type(int type_);

    void set_nucleus(int z_, int a_, double excitation_energy_ = 0.0, bool pdg_ = false);

    void set_ion(int z_, int a_, double excitation_energy_ = 0.0, int charge_ = 0, bool pdg_ = false);

    void set_neutrino(const std::string & label_);

    void set_neutrino(const std::string & flavour_, bool antineutrino_);

    bool has_pdg_code() const;

    int get_pdg_code() const;

    void set_pdg_code(int);

    int fetch_pdg_code() const;

    bool has_time() const;

    double get_time() const;

    double & grab_time();

    bool needs_particle_label() const;

    bool has_particle_label() const;

    const std::string & get_particle_label() const;

    void set_particle_label(const std::string &);

    void set_time(double time_);

    void shift_time(double delta_time_);


    bool is_valid() const;

    bool is_unknown() const;

    bool is_gamma() const;

    bool is_positron() const;

    bool is_electron() const;

    bool is_neutrino() const;

    bool is_alpha() const;

    bool is_deuteron() const;

    bool is_tritium() const;

    bool is_proton() const;

    bool is_neutron() const;

    bool is_muon_plus() const;

    bool is_muon_minus() const;

    bool is_pion_plus() const;

    bool is_pion_minus() const;

    bool is_pion_zero() const;

    bool is_nucleus() const;

    bool is_ion() const;

    void set_momentum(const geomtools::vector_3d & m_);

    const geomtools::vector_3d & get_momentum() const;

    geomtools::vector_3d & grab_momentum();

    void compute_four_momentum(CLHEP::HepLorentzVector &) const;

    void set_vertex(const geomtools::vector_3d & v_);

    const geomtools::vector_3d & get_vertex() const;

    geomtools::vector_3d & grab_vertex();

    bool has_vertex() const;

    void invalidate_vertex();

    bool charge_is_known() const;

    double get_charge() const;

    void set_mass(double);

    void reset_mass();

    double get_mass() const;

    bool mass_is_known() const;

    double get_total_energy() const;

    double get_kinetic_energy() const;

    double get_beta() const;

    const datatools::properties & get_auxiliaries() const;

    datatools::properties & grab_auxiliaries();

    primary_particle();

    primary_particle(int32_t a_type,
                     double a_time,
                     const geomtools::vector_3d &);

    virtual ~primary_particle();

    virtual void
    tree_dump(std::ostream      & out_    = std::clog,
              const std::string & title_  = "",
              const std::string & indent_ = "",
              bool inherit_               = false) const;

    void dump(std::ostream & out_ = std::clog,
              const std::string & a_indent = "") const;

    static std::string particle_label_from_type(int a_type);

    static int particle_type_from_label(const std::string & a_label);

  protected:

    void _set_defaults();

  private:

    int                  _generation_id_;  
    int32_t              _type_;           
    int32_t              _pdg_code_;       
    std::string          _particle_label_; 
    double               _mass_;           
    double               _time_;           
    geomtools::vector_3d _momentum_;       
    geomtools::vector_3d _vertex_;         
    datatools::properties _auxiliaries_;   

    DATATOOLS_SERIALIZATION_DECLARATION_ADVANCED(primary_particle)

    
    DATATOOLS_SERIALIZATION_BACKWARD_SERIAL_TAG_SUPPORT()

    
    DR_CLASS_RTTI()

  };

} // end of namespace genbb

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(genbb::primary_particle, "genbb::primary_particle")

DATATOOLS_SERIALIZATION_EXT_BACKWARD_SERIAL_TAG_DECLARATION(::genbb::primary_particle)

// Activate reflection layer for the genbb::primary_particle class :
DR_CLASS_INIT(::genbb::primary_particle)

// Explicit class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(genbb::primary_particle, 4)

#endif // GENBB_HELP_PRIMARY_PARTICLE_H

// Local Variables: --
// mode: c++ --
// End: --