marley::Target Class Reference

Description of a macroscopic target for scattering reactions. More...

#include <Target.hh>

Public Member Functions
	Target (const std::vector< TargetAtom > &nuclides, const std::vector< double > &atom_fracs)
	Create a composite Target.
	Target (int pdg)
	Create a Target composed of a single nuclide.
	Target (int Z, int A)
	Create a Target composed of a single nuclide.
double	atom_fraction (const marley::TargetAtom &atom) const
	Returns the atom fraction for the requested nuclide.
const std::map< marley::TargetAtom, double > &	atom_fraction_map () const
	Get read-only access to the map of atom fractions.
bool	contains (const marley::TargetAtom &atom) const
	Return true if the target contains the requested atom, or false otherwise.
bool	has_single_nuclide () const
	Returns true if the target consists of a single kind of target atom, or false otherwise.
void	print (std::ostream &out) const
	Print a textual representation of the Target to a std::ostream.

Protected Member Functions
void	initialize (const std::vector< TargetAtom > &nuclides, const std::vector< double > &atom_fracs)
	General helper function for the constructors.
void	initialize_single_nuclide (int pdg)
	Helper function for the constructors that use a single nuclide.

Protected Attributes
std::map< marley::TargetAtom, double >	atom_fractions_
	Map storing the atom fraction for each nuclide in the target material.

Detailed Description

Description of a macroscopic target for scattering reactions.

The target is composed of one or more nuclides and stores their relative abundances as atom fractions

Definition at line 32 of file Target.hh.

Constructor & Destructor Documentation

Target() [1/3]

marley::Target::Target ( int pdg )

explicit

Create a Target composed of a single nuclide.

Parameters

pdg	Particle Data Group code for the atomic species

Definition at line 24 of file Target.cc.

                              {
  this->initialize_single_nuclide( pdg );
}

References initialize_single_nuclide().

Target() [2/3]

marley::Target::Target ( int Z, int A )

explicit

Create a Target composed of a single nuclide.

Parameters

Z	The proton number of the target atom
A	The mass number of the target atom

Definition at line 28 of file Target.cc.

                                   {
  // Get the nuclear PDG code corresponding to these Z and A values
  int pdg = marley_utils::get_nucleus_pid( Z, A );
 
  // Delegate the rest of the work
  this->initialize_single_nuclide( pdg );
}

References initialize_single_nuclide().

Target() [3/3]

marley::Target::Target	(	const std::vector< TargetAtom > &	nuclides,
		const std::vector< double > &	atom_fracs )

Create a composite Target.

Atom fractions that do not sum to unity will automatically be renormalized to do so

Parameters

nuclides	TargetAtom objects specifying each atomic species
atom_fracs	Atom fraction for each TargetAtom

Note

The nuclides and atom_fracs vectors must have the same length. If this is not the case, a marley::Error will be thrown

Definition at line 47 of file Target.cc.

{
  this->initialize( nuclides, atom_fracs );
}

References initialize().

Member Function Documentation

atom_fraction()

double marley::Target::atom_fraction

(

const marley::TargetAtom &

atom

)

const

Returns the atom fraction for the requested nuclide.

Definition at line 99 of file Target.cc.

                                                                       {
  // If we have an atom fraction stored in the map for this nuclide,
  // then just return it
  auto it = atom_fractions_.find( atom );
  if ( it != atom_fractions_.end() ) return it->second;
  // If we couldn't find it, then just return zero
  return 0.;
}

References atom_fractions_.

Referenced by contains().

atom_fraction_map()

const std::map< marley::TargetAtom, double > & marley::Target::atom_fraction_map ( ) const

inline

Get read-only access to the map of atom fractions.

Definition at line 73 of file Target.hh.

              { return atom_fractions_; }

References atom_fractions_.

contains()

bool marley::Target::contains

(

const marley::TargetAtom &

atom

)

const

Return true if the target contains the requested atom, or false otherwise.

Even if the target atom appears in the map, this function will return false if its atom fraction is exactly zero

Definition at line 108 of file Target.cc.

                                                                {
  return ( this->atom_fraction(atom) != 0. );
}

References atom_fraction().

has_single_nuclide()

bool marley::Target::has_single_nuclide ( ) const

inline

Returns true if the target consists of a single kind of target atom, or false otherwise.

Definition at line 66 of file Target.hh.

        { return (atom_fractions_.size() == 1u); }

References atom_fractions_.

initialize()

void marley::Target::initialize ( const std::vector< TargetAtom > & nuclides, const std::vector< double > & atom_fracs )

protected

General helper function for the constructors.

Definition at line 53 of file Target.cc.

{
  // Check that we have the same number of target atoms and atom fractions
  if ( nuclides.size() != atom_fracs.size() ) {
    throw marley::Error("Different numbers of target atoms and atom fractions"
      " encountered in the constructor of marley::Target");
  }
 
  // Check that we have at least one target nuclide. Note that the vector's
  // size is unsigned and therefore can't go negative.
  if ( nuclides.size() == 0u ) throw marley::Error( "No target atoms"
    " specified when constructing a marley::Target object" );
 
  // Make sure the atom fractions sum to unity by explicitly renormalizing them
  double sum = 0.;
  for ( size_t j = 0u; j < atom_fracs.size(); ++j ) {
    double af = atom_fracs.at( j );
    const auto& nuc = nuclides.at( j );
    if ( af < 0. ) throw marley::Error("Invalid atom fraction "
      + std::to_string(af) + " encountered for a "
      + nuc.to_string() + " target atom");
    else if ( af == 0. ) MARLEY_LOG( WARN, "init.config.target" )
      << "Atom fraction of zero encountered for a " << nuc << " target atom";
    sum += af;
  }
 
  // If the sum of the fractions is non-positive, we'll have trouble.
  if ( sum <= 0. ) throw marley::Error( "Sum of atom fractions = "
    + std::to_string(sum) + " in the constructor of marley::Target" );
 
  std::vector<double> renorm_fracs;
  for ( const auto& af : atom_fracs ) renorm_fracs.push_back( af / sum );
 
  // We're ready. Initialize the target atom map.
  for ( size_t j = 0u; j < nuclides.size(); ++j ) {
    const auto& nuc = nuclides.at( j );
    const auto& frac = renorm_fracs.at( j );
    // If we have duplicate nuclides, throw an error (likely to be a mistake)
    if ( atom_fractions_.count(nuc) ) throw marley::Error("Duplicate atom"
      " fractions specified for the target atom " + nuc.to_string() + " in"
      " the constructor of marley::Target");
    atom_fractions_[ nuc ] = frac;
  }
}

References atom_fractions_.

Referenced by Target(), and initialize_single_nuclide().

initialize_single_nuclide()

void marley::Target::initialize_single_nuclide ( int pdg )

protected

Helper function for the constructors that use a single nuclide.

Definition at line 36 of file Target.cc.

                                                      {
  // Create trivial vectors of a single nuclide
  // whose atom fraction is one
  std::vector<double> atom_fracs = { 1. };
  std::vector<marley::TargetAtom> atoms;
  atoms.emplace_back( pdg );
 
  // Delegate the rest to the initialization method for the general case
  this->initialize( atoms, atom_fracs );
}

References initialize().

Referenced by Target(), and Target().

print()

void marley::Target::print

(

std::ostream &

out

)

const

Print a textual representation of the Target to a std::ostream.

Definition at line 112 of file Target.cc.

                                                {
  size_t num_atom_types = atom_fractions_.size();
  size_t count = 1;
  for ( const auto& pair : atom_fractions_ ) {
    const auto& nuc = pair.first;
    const auto& frac = pair.second;
    std::string A_str = std::to_string( nuc.A() );
    marley_utils::pad_left_inplace( A_str, 3 );
 
    auto it = marley_utils::element_symbols.find( nuc.Z() );
    std::string symb = "??";
    if ( it != marley_utils::element_symbols.end() ) symb = it->second;
    marley_utils::pad_right_inplace( symb, 2 );
 
    out << A_str << symb << " = " << frac;
    // Add a newline to all but the last entry
    if ( count < num_atom_types ) out << '\n';
    ++count;
  }
}

References atom_fractions_.

Member Data Documentation

atom_fractions_

std::map< marley::TargetAtom, double > marley::Target::atom_fractions_

protected

Map storing the atom fraction for each nuclide in the target material.

Keys are TargetAtom objects representing each nuclide, values are atom fractions. The Target class ensures that the atom fractions always sum to unity.

Definition at line 91 of file Target.hh.

Referenced by atom_fraction(), atom_fraction_map(), has_single_nuclide(), initialize(), and print().

---

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

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