Line data    Source code

       1             : #ifndef CRPROPA_PHOTODISINTEGRATION_H
       2             : #define CRPROPA_PHOTODISINTEGRATION_H
       3             : 
       4             : #include "crpropa/Module.h"
       5             : #include "crpropa/PhotonBackground.h"
       6             : 
       7             : #include <vector>
       8             : #include <map>
       9             : 
      10             : namespace crpropa {
      11             : /**
      12             :  * \addtogroup EnergyLosses
      13             :  * @{
      14             :  */
      15             :  
      16             : /**
      17             :  @class PhotoDisintegration
      18             :  @brief Photodisintegration of nuclei by background photons.
      19             :  */
      20             : class PhotoDisintegration: public Module {
      21             : private:
      22             :         ref_ptr<PhotonField> photonField;
      23             :         double limit; // fraction of mean free path for limiting the next step
      24             :         bool havePhotons;
      25             :         std::string interactionTag = "PD";
      26             : 
      27      203566 :         struct Branch {
      28             :                 int channel; // number of emitted (n, p, H2, H3, He3, He4)
      29             :                 std::vector<double> branchingRatio; // branching ratio as function of nucleus Lorentz factor
      30             :         };
      31             : 
      32      858506 :         struct PhotonEmission {
      33             :                 double energy; // energy of emitted photon [J]
      34             :                 std::vector<double> emissionProbability; // emission probability as function of nucleus Lorentz factor
      35             :         };
      36             : 
      37             :         std::vector<std::vector<double> > pdRate; // pdRate[Z * 31 + N] = total interaction rate
      38             :         std::vector<std::vector<Branch> > pdBranch; // pdTable[Z * 31 + N] = branching ratios
      39             :         mutable std::map<int, std::vector<PhotonEmission> > pdPhoton; // map of emitted photon energies and photon emission probabilities
      40             : 
      41             :         static const double lgmin; // minimum log10(Lorentz-factor)
      42             :         static const double lgmax; // maximum log10(Lorentz-factor)
      43             :         static const size_t nlg; // number of Lorentz-factor steps
      44             : 
      45             : public:
      46             :         /** Constructor.
      47             :          @param photonField             target photon field
      48             :          @param havePhotons             if true, add secondary photons as candidates
      49             :          @param limit                   step size limit as fraction of mean free path
      50             :          */
      51             :         PhotoDisintegration(ref_ptr<PhotonField> photonField, bool havePhotons = false, double limit = 0.1);
      52             : 
      53             :         // set the target photon field
      54             :         void setPhotonField(ref_ptr<PhotonField> photonField);
      55             : 
      56             :         // decide if secondary photons are added to the simulation
      57             :         void setHavePhotons(bool havePhotons);
      58             : 
      59             :         /** Limit the propagation step to a fraction of the mean free path
      60             :          * @param limit fraction of the mean free path
      61             :          */
      62             :         void setLimit(double limit);
      63             : 
      64             :         /** set a custom interaction tag to trace back this interaction
      65             :          * @param tag string that will be added to the candidate and output
      66             :          */
      67             :         void setInteractionTag(std::string tag);
      68             :         std::string getInteractionTag() const;
      69             : 
      70             :         void initRate(std::string filename);
      71             :         void initBranching(std::string filename);
      72             :         void initPhotonEmission(std::string filename);
      73             : 
      74             :         void process(Candidate *candidate) const;
      75             :         void performInteraction(Candidate *candidate, int channel) const;
      76             : 
      77             :         /**
      78             :          Calculates the loss length E dx/dE in [m] physical distance.
      79             :          This is not used in the simulation.
      80             :          @param id              PDG particle id
      81             :          @param gamma   Lorentz factor of particle
      82             :          @param z               redshift
      83             :          @returns E dx/dE [in meters]
      84             :          */
      85             :         double lossLength(int id, double gamma, double z = 0);
      86             : };
      87             : 
      88             : /** @}*/
      89             : } // namespace crpropa
      90             : 
      91             : #endif // CRPROPA_PHOTODISINTEGRATION_H