marley::Reaction Class Reference

Abstract base class that represents a 2 → 2 scattering reaction. More...

#include <Reaction.hh>

Inheritance diagram for marley::Reaction:

Public Types
enum	DataFormat { DiscreteStrengths = 0 , MultipoleResponses = 1 }
	Enumerated type describing the file format for reaction data. More...
enum	ProcessType {   Unknown = -1 , NeutrinoCC_Discrete = 0 , AntiNeutrinoCC_Discrete = 1 , NC_Discrete = 2 ,   NuElectronElastic = 3 , NeutrinoCC_Continuum = 4 , AntiNeutrinoCC_Continuum = 5 , NC_Continuum = 6 ,   StandaloneDecay = 7 }
	Enumerated type describing the kind of scattering process represented by a Reaction. More...

Public Member Functions
	Reaction (const std::string &source_file)
	Construct a Reaction with the resolved path of the data file.
virtual marley::TargetAtom	atomic_target () const =0
	Returns the target atom involved in this reaction.
virtual std::shared_ptr< HepMC3::GenEvent >	create_event (int pdg_a, double KEa, marley::Generator &gen) const =0
	Create an event object for this reaction.
const std::string &	get_description () const
	Get a string that contains the formula for this reaction.
int	pdg_a () const
	Get the projectile PDG code.
int	pdg_b () const
	Get the target PDG code.
ProcessType	process_type () const
	Get the process type for this reaction.
const std::string &	source_file () const
	Get the resolved path of the reaction data file used to construct this Reaction.
virtual double	threshold_kinetic_energy () const =0
	Get the minimum lab-frame kinetic energy (MeV) of the projectile that allows this reaction to proceed via a transition to the residue's ground state.
virtual double	total_xs (int pdg_a, double KEa) const =0
	Compute the reaction's total cross section (MeV -2)

Static Public Member Functions
static int	get_ejectile_pdg (int pdg_a, ProcessType proc_type)
static void	get_residue_pdg_and_charge (ProcessType proc_type, int pdg_b, int &pdg_d, int &q_d)
static std::vector< std::unique_ptr< Reaction > >	load_from_file (const std::string &filename, StructureDatabase &db, CoulombCorrector::CoulombMode coulomb_mode, const JSON &ff_config)
static std::string	proc_type_to_string (const ProcessType &pt)

Protected Member Functions
virtual std::shared_ptr< HepMC3::GenEvent >	make_event_object (double KEa, const std::shared_ptr< HepMC3::GenParticle > &ejectile, const std::shared_ptr< HepMC3::GenParticle > &residue) const
	Helper function that makes an event object.
virtual std::shared_ptr< HepMC3::GenEvent >	make_event_object (double KEa, double pc_cm, double cos_theta_c_cm, double phi_c_cm, double Ec_cm, double Ed_cm, int residue_status) const
	Helper function that makes an event object.
void	two_two_scatter (double KEa, double &s, double &Ec_cm, double &pc_cm, double &Ed_cm) const
	Helper function that handles CM frame kinematics for the reaction.

Static Protected Member Functions
static const std::vector< int > &	get_projectiles (ProcessType proc_type)

Protected Attributes
std::string	description_
	String that contains a formula describing the reaction.
double	ma_
	Projectile mass (MeV)
double	mb_
	Target mass (MeV)
double	mc_
	Ejectile mass (MeV)
double	md_
	Residue mass (MeV)
int	pdg_a_
	PDG code for the projectile.
int	pdg_b_
	PDG code for the target.
int	pdg_c_
	PDG code for the ejectile.
int	pdg_d_
	PDG code for the residue.
ProcessType	process_type_
	Type of scattering process (CC, NC) represented by this reaction.
const std::string	source_file_
	Resolved path of the reaction data file.

Detailed Description

Abstract base class that represents a 2 → 2 scattering reaction.

This class models a reaction of the form a + b → c + d. The projectile (particle a) is taken to have lab-frame kinetic energy KEa and to be traveling toward the target along the positive z direction. The target (particle b) is taken to be at rest in the lab frame.

Todo

Add check that projectile kinetic energy KEa >= 0. for all relevant member functions of Reaction and NuclearReaction

Definition at line 46 of file Reaction.hh.

Member Enumeration Documentation

DataFormat

enum marley::Reaction::DataFormat

Enumerated type describing the file format for reaction data.

Enumerator
DiscreteStrengths	Fermi and Gamow-Teller matrix elements are tabulated for discrete nuclear levels
MultipoleResponses	Continuum nuclear responses are given for one or more multipoles.

Definition at line 71 of file Reaction.hh.

                      {
        DiscreteStrengths = 0,
        MultipoleResponses = 1
      };

ProcessType

enum marley::Reaction::ProcessType

Enumerated type describing the kind of scattering process represented by a Reaction.

Enumerator
Unknown	Dummy value used for error handling.
NeutrinoCC_Discrete	Nuclear matrix elements contain \( t_{-} \) for a transition to a discrete nuclear level.
AntiNeutrinoCC_Discrete	Nuclear matrix elements contain \( t_{+} \) for a transition to a discrete nuclear level.
NC_Discrete	Nuclear matrix elements contain \( t_{3} \) for a transition to a discrete nuclear level.
NuElectronElastic	Neutrino-electron elastic scattering.
NeutrinoCC_Continuum	Nuclear matrix elements contain \( t_{-} \) for a transition to a continuum of nuclear levels.
AntiNeutrinoCC_Continuum	Nuclear matrix elements contain \( t_{+} \) for a transition to a continuum of nuclear levels.
NC_Continuum	Nuclear matrix elements contain \( t_{3} \) for a transition to a continuum of nuclear levels.
StandaloneDecay	Standalone nuclear de-excitation with no simulated primary reaction (used by "marley decay")

Definition at line 58 of file Reaction.hh.

                       {
        Unknown = -1, 
        NeutrinoCC_Discrete = 0,     
        AntiNeutrinoCC_Discrete = 1, 
        NC_Discrete = 2,             
        NuElectronElastic = 3, 
        NeutrinoCC_Continuum = 4,     
        AntiNeutrinoCC_Continuum = 5, 
        NC_Continuum = 6,             
        StandaloneDecay = 7, 
      };

Constructor & Destructor Documentation

Reaction()

marley::Reaction::Reaction

(

const std::string &

source_file

)

Construct a Reaction with the resolved path of the data file.

Parameters

source_file

Resolved path of the reaction data file

Definition at line 362 of file Reaction.cc.

  : source_file_( source_file ) {}

References source_file(), and source_file_.

Referenced by marley::NuclearReaction::NuclearReaction().

Member Function Documentation

atomic_target()

virtual marley::TargetAtom marley::Reaction::atomic_target ( ) const

pure virtual

Returns the target atom involved in this reaction.

For nuclear reactions, this is identical to the pdg_b_ member variable. For electron reactions, it is distinct (since particle b is the initial struck electron).

Implemented in marley::ElectronReaction, and marley::NuclearReaction.

References pdg_a(), and pdg_b().

Referenced by marley::Generator::create_event().

create_event()

virtual std::shared_ptr< HepMC3::GenEvent > marley::Reaction::create_event ( int pdg_a, double KEa, marley::Generator & gen ) const

pure virtual

Create an event object for this reaction.

Parameters

pdg_a	PDG code for the incident projectile
KEa	Lab-frame kinetic energy of the projectile
gen	Reference to the Generator to use for random sampling

Note

Functions that override create_event() should throw an Error if pdg_a != pdg_a_.

Implemented in marley::ContinuumNuclearReaction, marley::DiscreteNuclearReaction, and marley::ElectronReaction.

References pdg_a().

Referenced by marley::Generator::create_event().

get_description()

const std::string & marley::Reaction::get_description ( ) const

inline

Get a string that contains the formula for this reaction.

Definition at line 97 of file Reaction.hh.

{ return description_; }

References description_.

get_ejectile_pdg()

int marley::Reaction::get_ejectile_pdg ( int pdg_a, ProcessType proc_type )

static

Function that returns the ejectile PDG code given the projectile PDG code and the ProcessType

Definition at line 329 of file Reaction.cc.

                                                                  {
  int pdg_c = 0;
 
  // First, check that the projectile PDG code is valid for the
  // given process type
  const auto& vec = proc_type_to_nu_pdg.at( proc_type );
  if ( std::find(vec.cbegin(), vec.cend(), pdg_a) != vec.end() ) {
    if ( proc_type == ProcType::NeutrinoCC_Discrete ||
          proc_type == ProcType::NeutrinoCC_Continuum ) pdg_c = pdg_a - 1;
    else if ( proc_type == ProcType::AntiNeutrinoCC_Discrete ||
              proc_type == ProcType::AntiNeutrinoCC_Continuum ) pdg_c = pdg_a + 1;
    else if ( proc_type == ProcType::NC_Discrete ||
              proc_type == ProcType::NC_Continuum  ) pdg_c = pdg_a;
 
    else if ( proc_type == ProcType::NuElectronElastic ) pdg_c = pdg_a;
    else throw marley::Error("Unrecognized ProcessType encountered in"
      " marley::Reaction::get_ejectile_pdg()");
  }
  else throw marley::Error("A projectile with PDG code "
    + std::to_string(pdg_a) + " cannot participate in reactions of type "
    + proc_type_to_string_map.at(proc_type));
 
  return pdg_c;
}

References pdg_a().

Referenced by marley::TabulatedXSec::compute_integral(), and load_from_file().

get_projectiles()

const std::vector< int > & marley::Reaction::get_projectiles ( ProcessType proc_type )

staticprotected

Returns a vector of PDG codes for projectiles that participate in a particular ProcessType

Definition at line 358 of file Reaction.cc.

                                                                 {
  return proc_type_to_nu_pdg.at( pt );
}

Referenced by load_from_file().

get_residue_pdg_and_charge()

void marley::Reaction::get_residue_pdg_and_charge ( ProcessType proc_type, int pdg_b, int & pdg_d, int & q_d )

static

Determines the PDG code and net charge of the residue given the target PDG code and the process type

Definition at line 573 of file Reaction.cc.

{
  // First, figure out the PDG code for the final nucleus and its ionization
  // state (net atomic charge after the 2->2 scatter)
  int Zi = marley_utils::get_particle_Z( pdg_b );
  int A = marley_utils::get_particle_A( pdg_b );
 
  // NC scattering leaves the target nucleus the same
  if ( proc_type == marley::Reaction::ProcessType::NC_Discrete
    || proc_type == marley::Reaction::ProcessType::NC_Continuum )
  {
    pdg_d = pdg_b;
    q_d = 0;
  }
  // Neutrino CC scattering raises Z by one
  else if ( proc_type == marley::Reaction::ProcessType::NeutrinoCC_Discrete
    || proc_type == marley::Reaction::ProcessType::NeutrinoCC_Continuum )
  {
    // Check that the neutron number of the target is positive
    int Ni = A - Zi;
    if ( Ni <= 0 ) throw marley::Error("A NeutrinoCC process requires"
      " a target nucleus with N > 0");
    int Zf = Zi + 1;
    pdg_d = marley_utils::get_nucleus_pid(Zf, A);
    // Recoil ion has charge +1
    q_d = 1;
  }
  // Antineutrino CC scattering lowers Z by one
  else if ( proc_type == marley::Reaction::ProcessType::AntiNeutrinoCC_Discrete
    || proc_type == marley::Reaction::ProcessType::AntiNeutrinoCC_Continuum )
  {
    // Check that the neutron number of the target is positive
    if ( Zi <= 0 ) throw marley::Error("An AntiNeutrinoCC process requires"
      " a target nucleus with Z > 0");
    int Zf = Zi - 1;
    pdg_d = marley_utils::get_nucleus_pid(Zf, A);
    // Recoil ion has charge -1
    q_d = -1;
  }
  else throw marley::Error( "Unrecognized ProcessType encountered in"
    " marley::Reaction::get_residue_pdg_and_charge()" );
}

References AntiNeutrinoCC_Continuum, AntiNeutrinoCC_Discrete, NC_Continuum, NC_Discrete, NeutrinoCC_Continuum, NeutrinoCC_Discrete, and pdg_b().

Referenced by load_from_file().

load_from_file()

std::vector< std::unique_ptr< marley::Reaction > > marley::Reaction::load_from_file ( const std::string & filename, marley::StructureDatabase & db, CoulombCorrector::CoulombMode coulomb_mode, const JSON & ff_config )

static

Factory method called by JSONConfig to build Reaction objects given a file with matrix element data

Todo

Add error handling for parsing problems

Todo

This can be done more cleanly via iss = std::istringstream( line ); However, GCC 4 does not include the move constructor for string streams. This was fixed for GCC 5. Change this line after MARLEY drops support for GCC < 5. See https://stackoverflow.com/a/27152585 and https://stackoverflow.com/q/7623650 for more details.

Todo

Consider implementing a sorting procedure rather than strictly enforcing that energies must be given in ascending order.

Definition at line 366 of file Reaction.cc.

{
  // Create an empty vector to start
  std::vector< std::unique_ptr<marley::Reaction> > loaded_reactions;
 
  std::regex rx_comment("#.*"); // Matches comment lines
 
  // Open the reaction data file for parsing
  std::ifstream file_in( filename );
 
  // If the file doesn't exist or some other error
  // occurred, complain and give up.
  if ( !file_in.good() ) {
    throw marley::Error("Could not read from the file " + filename);
  }
 
  // String to store the current line of the reaction data file during parsing
  std::string line;

  line = marley_utils::get_next_line( file_in, rx_comment, false );
 
  // Read in the ProcessType code and the target PDG code
  std::istringstream iss( line );
  int integer_proc_type;
  iss >> integer_proc_type;
 
  auto proc_type = static_cast<ProcType>( integer_proc_type );
 
  // For neutrino-electron elastic scattering, we won't have a table of
  // matrix elements. Instead, a table of atomic target PDG codes appears.
  // Make Reaction objects for each atomic target for each of the possible
  // projectiles (every neutrino species) and return the result.
  if ( proc_type == ProcessType::NuElectronElastic ) {
 
    do {
      // Loop over target atoms
      int target_pdg;
      while ( iss >> target_pdg ) {
        // Loop over neutrino species
        for ( const int& pdg_a : get_projectiles(proc_type) ) {
          loaded_reactions.emplace_back(
            std::make_unique<marley::ElectronReaction>(pdg_a, target_pdg,
              filename) );
        }
      }
 
      line = marley_utils::get_next_line( file_in, rx_comment, false );
      iss.str( line );
      iss.clear();
    } while ( !line.empty() );
 
    return loaded_reactions;
  }
 
  // For nuclear reaction modes, there is a single target nucleus PDG code
  // per file.
  int pdg_b;
  iss >> pdg_b;
 
  // Multiple formats are allowed for the nuclear reaction modes. Get the
  // format code from the current line in order to decide what to do next.
  int integer_data_format;
  iss >> integer_data_format;
  auto df = static_cast< DataFormat >( integer_data_format );
 
  if ( df == DiscreteStrengths ) {
 
    // Read in all of the level energy (MeV), squared matrix element (B(F) or
    // B(GT) strength), and matrix element type identifier (0 represents B(F),
    // 1 represents B(GT)) triplets. Create a vector of MatrixElement objects
    // based on this information. Use a shared pointer so that the vector can
    // be re-used by multiple Reaction objects, one for each neutrino species
    // for which the matrix elements are relevant. This avoids unnecessary
    // duplication of storage for the matrix elements.
    auto matrix_elements = std::make_shared<std::vector<
      marley::MatrixElement> >();
 
    // Set the old energy entry to the lowest representable double
    // value. This guarantees that we always read in the first energy
    // value given in the reaction data file
    double old_energy = std::numeric_limits<double>::lowest();
    while (line = marley_utils::get_next_line(file_in, rx_comment, false),
      file_in.good())
    {
      iss.str(line);
      iss.clear();

 
      // The order of the entries is important because later uses of the vector
      // of matrix elements assume that they are sorted in order of ascending
      // final level energy.
      double energy, strength;
      int integer_me_type;
      iss >> energy >> strength >> integer_me_type;
      if ( old_energy >= energy ) throw marley::Error( "Invalid reaction"
        " dataset. Level energies must be unique and must be given in"
        " ascending order." );
 
      // Read optional uncertainty columns:
      //   4 columns: symmetric uncertainty (err_low = err_high = err)
      //   5 columns: asymmetric uncertainties (err_low, err_high)
      //   3 columns (legacy): no uncertainty (both default to zero)
      double err_low = 0., err_high = 0.;
      if ( iss >> err_low ) {
        err_high = err_low; // default to symmetric
        iss >> err_high;    // try for asymmetric (fails silently)
      }
 
      // @todo Right now, 0 corresponds to a Fermi transition, and 1
      // corresponds to a Gamow-Teller transition. As you add new matrix
      // element types, consider changing the convention and its
      // implementation. All of the level pointers owned by the matrix elements
      // will initially be set to nullptr. This may be changed later if
      // discrete level data can be found for the residual nucleus.
      matrix_elements->emplace_back( energy, strength,
        static_cast<ME_Type>(integer_me_type), err_low, err_high,
        nullptr );
      old_energy = energy;
    }
 
    // We now have all the information that we need. Build Reaction objects for
    // all neutrino species that can participate in the process described by
    // the matrix elements in the table. Use the ProcessType code to figure
    // this out
    int pdg_d, q_d;
    get_residue_pdg_and_charge( proc_type, pdg_b, pdg_d, q_d );
 
    // Now that we know the PDG code for the final nucleus, look up discrete
    // level data for it. Set the level pointers for matrix elements
    // representing transitions to discrete nuclear levels
    set_level_ptrs( *matrix_elements, pdg_b, pdg_d, db );
 
    // Now loop over the projectile PDG codes that can participate in the
    // scattering process of interest. For each one, decide what the ejectile
    // PDG code should be, then produce a corresponding Reaction object
    for ( const int& pdg_a : get_projectiles(proc_type) ) {
      int pdg_c = get_ejectile_pdg( pdg_a, proc_type );
 
      loaded_reactions.emplace_back(
        std::make_unique< marley::DiscreteNuclearReaction >( proc_type,
          pdg_a, pdg_b, pdg_c, pdg_d, q_d, matrix_elements, coulomb_mode,
          ff_config, filename )
      );
    }
  }
  else if ( df == MultipoleResponses ) {
 
    // An energy shift is provided following the data format code if we
    // are working with multipole responses. This accounts for the energy
    // difference between the ground state of the initial nucleus and the
    // isobaric analog state in the daughter nucleus.
    double delta_ias;
    iss >> delta_ias;
 
    // Create a shared pointer to a TabulatedXSec object that will manage
    // the tables of nuclear responses. These can be re-used for multiple
    // neutrino flavors by separate Reaction objects.
    auto txsec = std::make_shared< marley::TabulatedXSec >(
      pdg_b, proc_type, coulomb_mode, delta_ias );
 
    // Each line contains a file name corresponding to a distinct table
    // of nuclear responses. Add each one to the map managed by the
    // TabulatedXSec object.
    std::string table_file_name;
    while ( table_file_name = marley_utils::get_next_line(file_in,
      rx_comment, false), file_in.good() )
    {
      txsec->add_table( table_file_name );
    }
 
    // Get the PDG code and (net) charge of the final nucleus
    int pdg_d, q_d;
    get_residue_pdg_and_charge( proc_type, pdg_b, pdg_d, q_d );
 
    // Now loop over the projectile PDG codes that can participate in the
    // scattering process of interest. For each one, decide what the ejectile
    // PDG code should be, then produce a corresponding Reaction object
    for ( const int& pdg_a : get_projectiles(proc_type) ) {
      int pdg_c = get_ejectile_pdg(pdg_a, proc_type);
 
      // TODO: remove hard-coding here
      txsec->optimize( pdg_a, 100. );
 
      loaded_reactions.emplace_back(
        std::make_unique< marley::ContinuumNuclearReaction >( proc_type, pdg_a,
          pdg_b, pdg_c, pdg_d, q_d, txsec, filename )
      );
    }
 
  }
  else throw marley::Error( "Unrecognized reaction data format"
    " encountered in marley::Reaction::load_from_file()" );
 
  return loaded_reactions;
}

References DiscreteStrengths, get_ejectile_pdg(), get_projectiles(), get_residue_pdg_and_charge(), MultipoleResponses, NuElectronElastic, pdg_a(), and pdg_b().

make_event_object() [1/2]

std::shared_ptr< HepMC3::GenEvent > marley::Reaction::make_event_object ( double KEa, const std::shared_ptr< HepMC3::GenParticle > & ejectile, const std::shared_ptr< HepMC3::GenParticle > & residue ) const

protectedvirtual

Helper function that makes an event object.

This function expects pre-made HepMC3::GenParticle objects as input that have four-momenta expressed in the lab frame.

Parameters

KEa	Lab-frame kinetic energy (MeV) of the projectile
ejectile	GenParticle object for the ejectile
residue	GenParticle object for the residue

Definition at line 283 of file Reaction.cc.

{
  // NuHepMC E.R.4
  auto event = std::make_shared< HepMC3::GenEvent >( HepMC3::Units::MEV,
    HepMC3::Units::CM );
 
  // NuHepMC E.R.3
  int signal_process_id = marley_hepmc3::get_nuhepmc_proc_id( process_type_ );
  event->add_attribute( "signal_process_id",
    std::make_shared< HepMC3::IntAttribute >( signal_process_id )
  );
 
  // Create the primary vertex
  // NuHepMC E.R.6
  auto prim_vtx = std::make_shared< HepMC3::GenVertex >();
  prim_vtx->set_status( marley_hepmc3::NUHEPMC_PRIMARY_VERTEX );
 
  event->add_vertex( prim_vtx );
 
  // Get the lab-frame total energy of the projectile
  double Ea = KEa + ma_;
 
  // Determine the magnitude of the lab-frame 3-momentum of the projectile
  double pa = real_sqrt( KEa * (KEa + 2.*ma_) );
 
  // Create particle objects representing the projectile and target in the lab
  // frame
  // @todo Allow for projectile directions other than along the z-axis
  auto projectile = marley_hepmc3::make_particle( pdg_a_, 0., 0., pa, Ea,
    marley_hepmc3::NUHEPMC_PROJECTILE_STATUS, ma_ );
 
  auto target = marley_hepmc3::make_particle( pdg_b_,
    marley_hepmc3::NUHEPMC_TARGET_STATUS, mb_ );
 
  // Attach the particles to the primary vertex
  prim_vtx->add_particle_in( projectile );
  prim_vtx->add_particle_in( target );
 
  prim_vtx->add_particle_out( ejectile );
  prim_vtx->add_particle_out( residue );
 
  return event;
}

References ma_, mb_, pdg_a_, pdg_b_, and process_type_.

make_event_object() [2/2]

std::shared_ptr< HepMC3::GenEvent > marley::Reaction::make_event_object ( double KEa, double pc_cm, double cos_theta_c_cm, double phi_c_cm, double Ec_cm, double Ed_cm, int residue_status ) const

protectedvirtual

Helper function that makes an event object.

This function should be called by marley::Reaction::create_event() after CM frame scattering angles have been sampled for the ejectile. The two outgoing particles are treated as generic final-state particles. Subclasses that need to attach particle-specific metadata to the residue (e.g., nuclear excitation information) should wrap this function (or the overload below) and add the desired attributes afterwards.

Parameters

KEa	Lab-frame kinetic energy (MeV) of the projectile
pc_cm	Ejectile 3-momentum magnitude (MeV) in the CM frame
cos_theta_c_cm	Cosine of ejectile's CM frame polar angle
phi_c_cm	Ejectile's CM frame azimuthal angle (radians)
Ec_cm	Ejectile total energy (MeV) in the CM frame
Ed_cm	Residue total energy (MeV) in the CM frame
residue_status	NuHepMC status code to assign to the residue particle (the final-state particle that recoils against the ejectile)

Definition at line 247 of file Reaction.cc.

{
  // Determine the Cartesian components of the ejectile's CM frame momentum
  double sin_theta_c_cm = real_sqrt( 1. - std::pow(cos_theta_c_cm, 2) );
 
  double pc_cm_x = sin_theta_c_cm * std::cos( phi_c_cm ) * pc_cm;
  double pc_cm_y = sin_theta_c_cm * std::sin( phi_c_cm ) * pc_cm;
  double pc_cm_z = cos_theta_c_cm * pc_cm;
 
  // Create particle objects representing the ejectile and residue in the CM
  // frame.
  auto ejectile = marley_hepmc3::make_particle( pdg_c_, pc_cm_x, pc_cm_y,
    pc_cm_z, Ec_cm, marley_hepmc3::NUHEPMC_FINAL_STATE_STATUS, mc_ );
 
  auto residue = marley_hepmc3::make_particle( pdg_d_, -pc_cm_x, -pc_cm_y,
    -pc_cm_z, Ed_cm, residue_status, md_ );
 
  // Get the lab-frame total energy of the projectile
  double Ea = KEa + ma_;
 
  // Determine the magnitude of the lab-frame 3-momentum of the projectile
  double pa = real_sqrt( KEa * (KEa + 2.*ma_) );
 
  // Boost the ejectile and residue into the lab frame.
  double beta_z = pa / (Ea + mb_);
  marley_kinematics::lorentz_boost( 0., 0., -beta_z, *ejectile );
  marley_kinematics::lorentz_boost( 0., 0., -beta_z, *residue );
 
  // Now that we have the outgoing particles defined in the lab frame, delegate
  // the remaining tasks for creation of the event to this overloaded version
  // of the function
  return this->make_event_object( KEa, ejectile, residue );
}

References ma_, make_event_object(), mb_, mc_, md_, pdg_c_, and pdg_d_.

Referenced by marley::ElectronReaction::create_event(), make_event_object(), marley::NuclearReaction::make_nuclear_event_object(), and marley::NuclearReaction::make_nuclear_event_object().

pdg_a()

int marley::Reaction::pdg_a ( ) const

inline

Get the projectile PDG code.

Definition at line 109 of file Reaction.hh.

{ return pdg_a_; }

References pdg_a_.

Referenced by marley::DiscreteNuclearReaction::DiscreteNuclearReaction(), marley::NuclearReaction::NuclearReaction(), atomic_target(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::create_event(), marley::ElectronReaction::create_event(), marley::Generator::create_event(), create_event(), marley::DiscreteNuclearReaction::diff_xs(), marley::ElectronReaction::diff_xs(), get_ejectile_pdg(), load_from_file(), marley::DiscreteNuclearReaction::set_decay_scheme(), marley::DiscreteNuclearReaction::summed_xs_helper(), marley::ContinuumNuclearReaction::total_xs(), marley::DiscreteNuclearReaction::total_xs(), marley::DiscreteNuclearReaction::total_xs(), marley::ElectronReaction::total_xs(), and total_xs().

pdg_b()

int marley::Reaction::pdg_b ( ) const

inline

Get the target PDG code.

Definition at line 112 of file Reaction.hh.

{ return pdg_b_; }

References pdg_b_.

Referenced by marley::DiscreteNuclearReaction::DiscreteNuclearReaction(), marley::NuclearReaction::NuclearReaction(), atomic_target(), get_residue_pdg_and_charge(), and load_from_file().

proc_type_to_string()

std::string marley::Reaction::proc_type_to_string ( const ProcessType & pt )

static

Definition at line 354 of file Reaction.cc.

                                                                {
  return proc_type_to_string_map.at( pt );
}

process_type()

ProcessType marley::Reaction::process_type ( ) const

inline

Get the process type for this reaction.

Definition at line 100 of file Reaction.hh.

{ return process_type_; }

References process_type_.

source_file()

const std::string & marley::Reaction::source_file ( ) const

inline

Get the resolved path of the reaction data file used to construct this Reaction.

Definition at line 104 of file Reaction.hh.

{ return source_file_; }

References source_file_.

Referenced by marley::DiscreteNuclearReaction::DiscreteNuclearReaction(), marley::NuclearReaction::NuclearReaction(), and Reaction().

threshold_kinetic_energy()

virtual double marley::Reaction::threshold_kinetic_energy ( ) const

pure virtual

Get the minimum lab-frame kinetic energy (MeV) of the projectile that allows this reaction to proceed via a transition to the residue's ground state.

Implemented in marley::ElectronReaction, and marley::NuclearReaction.

total_xs()

virtual double marley::Reaction::total_xs ( int pdg_a, double KEa ) const

pure virtual

Compute the reaction's total cross section (MeV ^-2)

Parameters

pdg_a	Projectile's PDG code
KEa	Lab-frame kinetic energy of the incident projectile

Returns

Reaction total cross section (MeV ^-2)

Note

Functions that override total_xs() should always return zero if pdg_a != pdg_a_.

Implemented in marley::ContinuumNuclearReaction, marley::DiscreteNuclearReaction, and marley::ElectronReaction.

References pdg_a().

Referenced by marley::Generator::create_event().

two_two_scatter()

void marley::Reaction::two_two_scatter ( double KEa, double & s, double & Ec_cm, double & pc_cm, double & Ed_cm ) const

protected

Helper function that handles CM frame kinematics for the reaction.

Parameters

	KEa	Lab-frame kinetic energy (MeV) of the projectile
[out]	s	Mandelstam s (MeV2)
[out]	Ec_cm	Ejectile total energy (MeV) in the CM frame
[out]	pc_cm	Ejectile 3-momentum magnitude (MeV) in the CM frame
[out]	Ed_cm	Residue total energy (MeV) in the CM frame

Definition at line 226 of file Reaction.cc.

{
  // Get the lab-frame total energy of the projectile
  double Ea = KEa + ma_;
 
  // Compute Mandelstam s (the square of the total CM frame energy)
  s = ma_*ma_ + mb_*mb_ + 2.*mb_*Ea;
  double sqrt_s = std::sqrt(s);
 
  // Determine the CM frame energy and momentum of the ejectile
  Ec_cm = (s + mc_*mc_ - md_*md_) / (2 * sqrt_s);
  pc_cm = real_sqrt(std::pow(Ec_cm, 2) - mc_*mc_);
 
  // Determine the residue's CM frame energy. Roundoff errors may cause Ed_cm to
  // dip below md, which is unphysical. Prevent this from occurring by allowing
  // md to be the minimum value of Ed_cm. Also note that, in the CM frame, the
  // residue and ejectile have equal and opposite momenta.
  Ed_cm = std::max(sqrt_s - Ec_cm, md_);
}

References ma_, mb_, mc_, and md_.

Referenced by marley::DiscreteNuclearReaction::create_event(), and marley::ElectronReaction::create_event().

Member Data Documentation

description_

std::string marley::Reaction::description_

protected

String that contains a formula describing the reaction.

Definition at line 157 of file Reaction.hh.

Referenced by get_description(), marley::ContinuumNuclearReaction::set_description(), marley::DiscreteNuclearReaction::set_description(), marley::NuclearReaction::set_description(), marley::DiscreteNuclearReaction::summed_xs_helper(), and marley::DiscreteNuclearReaction::total_xs().

ma_

double marley::Reaction::ma_

protected

Projectile mass (MeV)

Definition at line 147 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::diff_xs(), marley::ElectronReaction::diff_xs(), marley::ContinuumNuclearReaction::get_Ec_from_Ex(), make_event_object(), make_event_object(), marley::NuclearReaction::max_level_energy(), marley::ContinuumNuclearReaction::reassign_sub_continuum(), marley::ElectronReaction::total_xs(), and two_two_scatter().

mb_

double marley::Reaction::mb_

protected

Target mass (MeV)

Definition at line 148 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::diff_xs(), marley::ElectronReaction::diff_xs(), marley::ContinuumNuclearReaction::get_Ec_from_Ex(), make_event_object(), make_event_object(), marley::NuclearReaction::max_level_energy(), marley::ContinuumNuclearReaction::reassign_sub_continuum(), marley::ElectronReaction::total_xs(), and two_two_scatter().

mc_

double marley::Reaction::mc_

protected

Ejectile mass (MeV)

Definition at line 149 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::diff_xs(), marley::ElectronReaction::diff_xs(), marley::ContinuumNuclearReaction::get_Ec_from_Ex(), make_event_object(), marley::NuclearReaction::max_level_energy(), marley::ContinuumNuclearReaction::reassign_sub_continuum(), marley::ElectronReaction::total_xs(), and two_two_scatter().

md_

double marley::Reaction::md_

mutableprotected

Residue mass (MeV)

Definition at line 154 of file Reaction.hh.

Referenced by marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::create_event(), marley::ElectronReaction::create_event(), marley::ElectronReaction::diff_xs(), make_event_object(), marley::ElectronReaction::total_xs(), and two_two_scatter().

pdg_a_

int marley::Reaction::pdg_a_

protected

PDG code for the projectile.

Definition at line 142 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::create_event(), marley::ElectronReaction::create_event(), marley::DiscreteNuclearReaction::diff_xs(), marley::ElectronReaction::diff_xs(), make_event_object(), pdg_a(), marley::NuclearReaction::set_description(), marley::DiscreteNuclearReaction::summed_xs_helper(), marley::ContinuumNuclearReaction::total_xs(), and marley::ElectronReaction::total_xs().

pdg_b_

int marley::Reaction::pdg_b_

protected

PDG code for the target.

Definition at line 143 of file Reaction.hh.

Referenced by marley::DiscreteNuclearReaction::DiscreteNuclearReaction(), marley::NuclearReaction::NuclearReaction(), marley::NuclearReaction::atomic_target(), marley::DiscreteNuclearReaction::create_event(), make_event_object(), and pdg_b().

pdg_c_

int marley::Reaction::pdg_c_

protected

PDG code for the ejectile.

Definition at line 144 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), make_event_object(), and marley::NuclearReaction::set_description().

pdg_d_

int marley::Reaction::pdg_d_

protected

PDG code for the residue.

Definition at line 145 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::ContinuumNuclearReaction::create_event(), marley::DiscreteNuclearReaction::create_event(), make_event_object(), and marley::ContinuumNuclearReaction::reassign_sub_continuum().

process_type_

ProcessType marley::Reaction::process_type_

protected

Type of scattering process (CC, NC) represented by this reaction.

Definition at line 161 of file Reaction.hh.

Referenced by marley::NuclearReaction::NuclearReaction(), marley::DiscreteNuclearReaction::diff_xs(), make_event_object(), and process_type().

source_file_

const std::string marley::Reaction::source_file_

protected

Resolved path of the reaction data file.

Definition at line 210 of file Reaction.hh.

Referenced by Reaction(), and source_file().

---

The documentation for this class was generated from the following files:

• /home/sjg/Desktop/marley/include/marley/Reaction.hh
• /home/sjg/Desktop/marley/src/Reaction.cc