sim Namespace Reference

Code to link reconstructed objects back to the MC truth information. More...

Namespaces
	details
	dump
	Functions to dump Monte Carlo object information into a stream.

Classes
class	AuxDetHit
class	AuxDetIDE
	MC truth information to make RawDigits and do back tracking. More...
class	AuxDetSimChannel
	Collection of particles crossing one auxiliary detector cell. More...
class	BeamGateInfo
struct	Chan_Phot
class	DumpGTruth
class	DumpMCParticles
class	DumpMCShowers
class	DumpMCTracks
class	DumpMCTruth
class	DumpOpDetBacktrackerRecords
class	DumpOpDetDivRecs
class	DumpSimChannels
class	DumpSimEnergyDeposits
	Prints the content of all the deposited energies on screen. More...
class	DumpSimPhotons
class	DumpSimPhotonsLite
class	GeneratedParticleInfo
	Contains information about a generated particle. More...
class	GenericCRT
class	GenericCRTUtility
struct	IDE
	Ionization at a point of the TPC sensitive volume. More...
class	LArG4Parameters
class	LArVoxelCalculator
class	LArVoxelData
class	LArVoxelID
class	LArVoxelList
class	MCBaseException
struct	MCEdep
class	MCEdepHit
class	MCEnDep
class	MCHit
class	MCHitCollection
class	MCMiniPart
class	MCRecoEdep
class	MCRecoPart
class	MCShower
class	MCShowerRecoAlg
class	MCShowerRecoPart
class	MCStep
class	MCTrack
class	MCTrackCollectionAnaAlg
class	MCTrackRecoAlg
class	MCWire
class	MCWireCollection
class	MergeSimSources
class	MergeSimSourcesUtility
struct	OnePhoton
	All information of a photon entering the sensitive optical detector volume. More...
struct	OpDet_Time_Chans
class	OpDetBacktrackerRecord
	Energy deposited on a readout Optical Detector by simulated tracks. More...
class	OpDetDivRec
class	PhotonVoxel
	Representation of a single small volume (voxel). More...
class	PhotonVoxelDef
	Representation of a region of space diced into voxels. More...
class	POTaccumulator
	Prints on console the total Protons On Target from the input subruns. More...
class	ProtoDUNEBeamInstrument
class	ProtoDUNEbeamsim
class	ProtoDUNEBeamTPCMatching
struct	SDP
class	SimChannel
	Energy deposited on a readout channel by simulated tracks. More...
class	SimDriftedElectronCluster
class	SimEnergyDeposit
	Energy deposition in the active material. More...
class	SimListUtils
class	SimPhotons
	Collection of photons which recorded on one channel. More...
class	SimPhotonsCollection
	Collection of sim::SimPhotons, indexed by channel number. More...
class	SimPhotonsLite
	Compact representation of photons on a channel. More...
class	SupernovaTruth
struct	TrackIDE
	Ionization energy from a Geant4 track. More...
struct	TrackSDP
	Ionization photons from a Geant4 track. More...
class	UniquePosition

Typedefs
typedef std::vector< AuxDetHit >	AuxDetHitCollection
typedef std::vector< AuxDetSimChannel >	AuxDetSimChannelCollection
typedef std::pair< double, std::vector< sim::SDP > >	timePDclockSDP_t
	List of energy deposits at the same time (on this Optical Detector) More...
typedef std::pair< unsigned short, std::vector< sim::IDE > >	TDCIDE
	List of energy deposits at the same time (on this channel) More...
typedef std::vector< SimEnergyDeposit >	SimEnergyDepositCollection

Enumerations
enum	BeamType_t { kUnknown =0, kBNB, kNuMI, kBeamTypeMax }
	Defines category of beams to be stored in sim::BeamGateInfo. More...
enum	SupernovaSamplingMode_t {   kUnknownSupernovaSamplingMode = 0, kUnbiased, kUniformTime, kUniformEnergy,   kSupernovaSamplingModeMax }

Functions
bool	operator< (const BeamGateInfo &lhs, const BeamGateInfo &rhs)
unsigned int	GetRandomNumberSeed ()
bool	operator< (OnePhoton const &, OnePhoton const &)
	a is smaller than b if has earlier Time, or lower MotherTrackID. More...
const LArVoxelData	operator* (const double &value, const LArVoxelData &data)
std::ostream &	operator<< (std::ostream &output, const LArVoxelData &data)
std::ostream &	operator<< (std::ostream &output, const LArVoxelID &id)
const LArVoxelList	operator* (const double &value, const LArVoxelList &list)
std::ostream &	operator<< (std::ostream &output, const LArVoxelList &list)
std::ostream &	operator<< (std::ostream &out, sim::PhotonVoxelDef const &voxelDef)
	Prints the content of the specified voxel definition into a stream. More...
Function to name `simb::MCParticle` enumerators and codes.
std::string	ParticleName (int pigid)
	Returns a string with the name of particle the specified with PDG ID. More...
std::string	ParticleStatusName (int code)
	Describes the status of a particle (simb::MCParticle::StatusCode()). More...

Variables
const double	kINVALID_DOUBLE = std::numeric_limits <double>::max()
const float	kINVALID_FLOAT = std::numeric_limits <float>::max()
const unsigned int	kINVALID_UINT = std::numeric_limits <unsigned int>::max()
const int	kINVALID_INT = std::numeric_limits <int>::max()
static const int	NoParticleId = std::numeric_limits<int>::min()

Functions to name `simb::MCTruth` enumerators and codes.
enum	RescatterCategory { RescatterCategory::GENIE_INukeFateHA, RescatterCategory::LArSoftDefault = GENIE_INukeFateHA }
	Possible sources of rescattering code (which is generator-dependent). More...
std::string	TruthOriginName (simb::Origin_t origin)
	Returns a string representing the specified process origin. More...
std::string	TruthCCNCname (int ccnc)
std::string	TruthReactionMode (int mode)
	Returns the "mode" of the reaction (a lesser version of interaction type). More...
std::string	TruthInteractionTypeName (int type)
std::string	RescatteringName (int code, RescatterCategory cat=RescatterCategory::LArSoftDefault)
	The name of the specified rescattering code. More...
std::string	GENIE_INukeFateHA_RescatteringName (int code)
	Description of a rescattering code from GENIE INukeFateHA_t. More...

Detailed Description

Code to link reconstructed objects back to the MC truth information.

Monte Carlo Simulation.

Title: GenericCRT Utility Class Author: Andrzej Szelc (andrz.nosp@m.ejs@.nosp@m.fnal..nosp@m.gov)

Description: Class with Algorithms to convert sim::AuxDetHits to sim::AuxDetSimChannels

Title: MergeSimSources Utility Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that merges different simulation sources together to created a combined sim list. Typically just merges vectors/maps/etc together. But, if anything as a G4 trackID, applies a user-defined offset to those IDs.

This class encapsulates the calculations associated with computing the LArVoxelID, and provides access to the any LArVoxel parameters from the input file(s). It is to be called using art::ServiceHandle<sim::LArVoxelCalculator const> lvx; The service makes it act like a singleton, but it knows about the Parameters defined in the input file. Definition: "Voxels" are three-dimensional "pixels"; basically they divide the energy deposition in the LAr into (x,y,z) cubes. Well, hyper-cubes actually, since we have to potentially include divisions in time as well.

This service encapsulates the calculations associated with computing the LArVoxelID, and provides access to the any LArVoxel parameters from the input file(s). Definition: "Voxels" are three-dimensional "pixels"; basically they divide the energy deposition in the LAr into (x,y,z) cubes. Well, hyper-cubes actually, since we have to potentially include divisions in time as well.

LArVoxelList associates a voxel ID with voxel data. LArVoxelID describes the ID (position); this class describes the data.

In particular, this class stores the association between particle tracks and the energy deposited within a voxel.

The key item of information stored for a voxel is the energy. Another, less important item is the association of a particular particle track to an amount of energy stored in the voxel. If all you want is the energy in a voxel, use LArVoxelData::Energy() and ignore the rest of this discussion. If you want to understand the source of that energy, you have to dig deeper:

LArVoxelData::Energy[trackID] returns the amount of energy deposited by the particle with the given track ID (note the use of square brackets).

LArVoxelData::NumberParticles() returns the number of individual particles whose energy deposits are recorded for this voxel.

LArVoxelData::Energy(i) returns the amount of energy deposited by the "i-th" particle (note the use of parenthesis).

LArVoxelData::TrackID(i) returns the track ID of the "i-th" particle.

LArVoxelData::UnassignedEnergy() returns the amount of energy in the voxel that's not assigned to any particle. There might be "unassigned" energy for one of two reasons:

1) In the Monte Carlo, particles can be cut from the ParticleList because they fall below the energy cut. If that happens, the particle is also removed from the LArVoxelData lists, and its energy placed in "unassigned" energy.

For example, a voxel might contain the sum of many low-energy electrons. It may be that none of the individual electron tracks would be written to the output, but their sum might be enough for the voxel to be written to the output file.

2) If any form of "voxel arithmetic" is performed (e.g,. adding two LArVoxelLists together), it becomes too difficult to maintain the particle<->energy relationship because the track IDs change. In that case, all the voxel energies are moved to "unassigned" energy.

LArVoxelData::AssignedEnergy() returns, in effect, Energy() - UnassignedEnergy()

This class defines a unique identifier for a given volume element ("voxel") in the LAr volume. It is sortable, can be tested for equality, and is persistent under ROOT I/O. (Actually, the term "voxel" is a mis-nomer, since we're also keeping track of the time slice. What's a four-dimensional volume element? A "tesseract element or "tessel"?)

A container for LAr voxel information. Although there's nothing in the class below that assumes units, the standard for LArSoft is that distances are in cm, and energy is in GeV.

It acts like a map<LArVoxelID,LArVoxelData>, but with additional features:

• An Add(LArVoxelList) method allows you to add one LArVoxelList to another. Voxels with the same ID are added together; otherwise the lists are merged. Usage: sim::LArVoxelList a,b; a.Add(b); There's even an operator+ so you can write "a += b", but be careful about wasting memory if you write "a = a+b". Of course, you can do: sim:LArVoxelList c = a + b;
• An operator* so you can scale all the voxel energies for calibration: sim::LArVoxelList c; double calib = 1.00000012 c *= calib; c = c * calib; // same as above, but wastes memory sim::LArVoxelList d = c * calib; (Yes, I know we probably won't do calibration in this way, but it's here if you need it.)
• A method Cut(double) that will remove all voxels with energy less than the argument.
• Methods ID(int) and Energy(int) for those who are unfamiliar with the concept of "first" and "second" as used with STL maps: sim::LArVoxelList* voxelList = // ...; int numberOfVoxels = voxelList->size(); for (int i=0; i<numberOfVoxels; ++i) { sim::LArVoxelID = voxelList->ID(i); double energy = voxelList->Energy(i); } The STL equivalent to the above statements (more efficient): sim::LArVoxelList* voxelList = // ... ; for ( sim::LArVoxelList::const_iterator i = voxelList->begin(); i != voxelList->end(); ++i ) { sim::LArVoxelID = (*i).first; double energy = (*i).second.Energy(); }
• operator<< method for ROOT display and ease of debugging.

Author

brebe.nosp@m.l@fn.nosp@m.al.go.nosp@m.v

this class is designed to hold methods that access the event handle to make the various simulation lists, ie ParticleList, LArVoxelList, etc

Typedef Documentation

typedef std::vector<AuxDetHit> sim::AuxDetHitCollection

Definition at line 183 of file AuxDetHit.h.

typedef std::vector<AuxDetSimChannel> sim::AuxDetSimChannelCollection

Definition at line 104 of file AuxDetSimChannel.h.

typedef std::vector<SimEnergyDeposit> sim::SimEnergyDepositCollection

Definition at line 230 of file SimEnergyDeposit.h.

typedef std::pair<unsigned short, std::vector<sim::IDE> > sim::TDCIDE

List of energy deposits at the same time (on this channel)

Definition at line 122 of file SimChannel.h.

typedef std::pair< double, std::vector<sim::SDP> > sim::timePDclockSDP_t

List of energy deposits at the same time (on this Optical Detector)

Definition at line 104 of file OpDetBacktrackerRecord.h.

Enumeration Type Documentation

enum sim::BeamType_t

Defines category of beams to be stored in sim::BeamGateInfo.

Enumerator
kUnknown	Unknown beam type.
kBNB	BNB.
kNuMI	NuMI.
kBeamTypeMax	Max value of enum for iteration.

Definition at line 9 of file BeamTypes.h.

                  {
    kUnknown=0,  ///< Unknown beam type
    kBNB,        ///< BNB
    kNuMI,       ///< NuMI
    kBeamTypeMax ///< Max value of enum for iteration
  };

enum sim::RescatterCategory

strong

Possible sources of rescattering code (which is generator-dependent).

Enumerator
GENIE_INukeFateHA	GENIE genie::EINukeFateHA_t
LArSoftDefault

Definition at line 39 of file MCDumperUtils.h.

                               {
    GENIE_INukeFateHA, ///< GENIE `genie::EINukeFateHA_t`
    LArSoftDefault = GENIE_INukeFateHA
  };

enum sim::SupernovaSamplingMode_t

Enumerator
kUnknownSupernovaSamplingMode	Unknown sampling mode.
kUnbiased	Sample directly from cross-section weighted spectrum.
kUniformTime	Arrival times were sampled uniformly.
kUniformEnergy	Neutrino energies were sampled uniformly.
kSupernovaSamplingModeMax	Max value of enum for iteration.

Definition at line 14 of file SupernovaTruth.h.

                               {
    kUnknownSupernovaSamplingMode = 0,  ///< Unknown sampling mode
    kUnbiased,   ///< Sample directly from cross-section weighted spectrum
    kUniformTime, ///< Arrival times were sampled uniformly
    kUniformEnergy, ///< Neutrino energies were sampled uniformly
    kSupernovaSamplingModeMax ///< Max value of enum for iteration
  };

Function Documentation

std::string sim::GENIE_INukeFateHA_RescatteringName

(

int

code

)

Description of a rescattering code from GENIE INukeFateHA_t.

Definition at line 181 of file MCDumperUtils.cxx.

                                                          {
  
#ifdef _INTRANUKE_FATES_H_ // from GENIE
  
  return 
    genie::INukeHadroFates::AsString(static_cast<genie::INukeFateHA_t>(code));
  
#else // !_INTRANUKE_FATES_H_:
  
  using namespace std::string_literals;
  
  /*
   * Here we do an horrible thing, that is to copy GENIE code into LArSoft.
   * By defining `HAS_GENIE`, the proper code branch would be taken instead,
   * which directly refers to GENIE.
   * But LArSoft does not do that, because we don't want to be forced to have
   * GENIE around all the time we use `simb::MCParticle`.
   * 
   */
  switch (code) {
    // from Fermilab UPS GENIE v3_0_0_b4a, `Physics/HadronTransport/INukeHadroFates.h`:
    case  0 /* kIHAFtUndefined     */ : return "** Undefined HA-mode fate **"s; break;
    case  1 /* kIHAFtNoInteraction */ : return "HA-mode / no interaction"s;     break;
    case  2 /* kIHAFtCEx           */ : return "HA-mode / cex"s;                break;
    case  3 /* kIHAFtElas          */ : return "HA-mode / elas"s;               break;
    case  4 /* kIHAFtInelas        */ : return "HA-mode / inelas"s;             break;
    case  5 /* kIHAFtAbs           */ : return "HA-mode / abs"s;                break;
    case  6 /* kIHAFtKo            */ : return "HA-mode / knock-out"s;          break;
    case  7 /* kIHAFtCmp           */ : return "HA-mode / compound"s;           break;
    case  8 /* kIHAFtPiProd        */ : return "HA-mode / pi-production"s ;     break;
    case  9 /* kIHAFtInclPip       */ : return "HA-mode / pi-prod incl pi+"s;   break;
    case 10 /* kIHAFtInclPim       */ : return "HA-mode / pi-prod incl pi-"s;   break;
    case 11 /* kIHAFtInclPi0       */ : return "HA-mode / pi-prod incl pi0"s;   break;
    case 12 /* kIHAFtDCEx          */ : return "HA-mode / dcex"s;               break;
    default:
      return "unknown ("s + std::to_string(code) + ")"s;
  } // switch(code)
  
#endif // ?_INTRANUKE_FATES_H_
  
} // sim::GENIE_INukeFateHA_RescatteringName()

unsigned int sim::GetRandomNumberSeed ( )

inline

Definition at line 32 of file sim.h.

                                            {

    // the maximum allowed seed for the art::RandomNumberGenerator
    // is 900000000. Use TRandom3 to get the seed value in that range.
    // Instantiating TRandom3 with a 0 means that its seed is set based
    // on the TUUID and should always be random, even for jobs running on the
    // same machine
    TRandom3 rand(0);
    return rand.Integer(900000000);
}

const LArVoxelList sim::operator*	(	const double &	value,
		const LArVoxelList &	list
	)

Just in case: define the result of "scalar * LArVoxelList" to be the same as "LArVoxelList * scalar".

Definition at line 45 of file LArVoxelList.cxx.

  {
    return LArVoxelList(list) *= value;
  }

const LArVoxelData sim::operator*	(	const double &	value,
		const LArVoxelData &	data
	)

Just in case: define the result of "scalar * LArVoxelData" to be the same as "LArVoxelData * scalar".

Definition at line 71 of file LArVoxelData.cxx.

  {
    return LArVoxelData(data) *= value;
  }

bool sim::operator<	(	const BeamGateInfo &	lhs,
		const BeamGateInfo &	rhs
	)

Definition at line 45 of file BeamGateInfo.h.

  {
    // Sort by start; in the enormously-unlikely case that two beam
    // gates (BNB and NuMI?) start at the same time, sort by width.
    if ( lhs.Start() < rhs.Start() )
      return true;
    if ( lhs.Start() == rhs.Start() )
      return ( lhs.Width() < lhs.Width() );
    return false;
  }

bool sim::operator< ( OnePhoton const &  a, OnePhoton const &  b  )

inline

a is smaller than b if has earlier Time, or lower MotherTrackID.

Definition at line 235 of file SimPhotons.h.

                                                                  {
  if (a.Time < b.Time) return true;
  if (a.Time > b.Time) return false;

  return (a.MotherTrackID < b.MotherTrackID);
} // sim::operator< (OnePhoton const&, OnePhoton const&)

std::ostream& sim::operator<<	(	std::ostream &	output,
		const LArVoxelData &	data
	)

Definition at line 77 of file LArVoxelData.cxx.

  {
    output << "Voxel: " << data.VoxelID() << std::endl;

    double unassigned = data.UnassignedEnergy();
    // Display the total energy then the breakdown of
    // the sum.
    output << data.Energy() << " = <ID,E>=";
    for ( LArVoxelData::const_iterator i = data.begin(); i != data.end(); ++i){
      if ( i != data.begin() )
        output << ",";

      output << "<" << (*i).first << "," << (*i).second << ">";
    }
    if( unassigned > 0 )
      output << ",<*," << unassigned << ">";

    return output;
  }

std::ostream& sim::operator<<	(	std::ostream &	output,
		const LArVoxelList &	list
	)

Definition at line 91 of file LArVoxelList.cxx.

  {
    // Determine a field width for the voxel number.
    LArVoxelList::size_type numberOfVoxels = list.size();
    int numberOfDigits = (int) std::log10( (double) numberOfVoxels ) + 1;

    // A simple header.
    output.width( numberOfDigits );
    output << "#" << ": < ID, energy >" << std::endl;

    // Write each voxel on a separate line.
    LArVoxelList::size_type nVoxel = 0;
    for ( LArVoxelList::const_iterator voxel = list.begin(); voxel != list.end(); ++voxel, ++nVoxel ){
      output.width( numberOfDigits );
      output << nVoxel << ": "
             << "< " << (*voxel).first
             << ", " << (*voxel).second
             << " >\n";
    }

    return output;
  }

std::ostream& sim::operator<<	(	std::ostream &	output,
		const LArVoxelID &	id
	)

Put the contents on the output stream. We have a choice: write the bin number, or write the position represented by the bins. For now, let's pick writing the positions.

Definition at line 121 of file LArVoxelID.cxx.

  {
    output << "(" << id.X()
           << "," << id.Y()
           << "," << id.Z()
           << "," << id.T()
           << ")";

    return output;
  }

std::ostream & sim::operator<<	(	std::ostream &	out,
		sim::PhotonVoxelDef const &	voxelDef
	)

Prints the content of the specified voxel definition into a stream.

Definition at line 233 of file PhotonVoxels.cxx.

  {

    auto const& lower = voxelDef.GetRegionLowerCorner();
    auto const& upper = voxelDef.GetRegionUpperCorner();
    auto const& steps = voxelDef.GetSteps();
    auto const& stepSize = voxelDef.GetVoxelSize();

    out << "Volume " << voxelDef.GetVolumeSize() << " cm^3 split in " << voxelDef.GetNVoxels()
        << " voxels:"
        << "\n  - x axis: [ " << lower.X() << " ; " << upper.X() << " ] split in " << steps[0]
        << "x " << stepSize.X() << " cm steps"
        << "\n  - y axis: [ " << lower.Y() << " ; " << upper.Y() << " ] split in " << steps[1]
        << "x " << stepSize.Y() << " cm steps"
        << "\n  - z axis: [ " << lower.Z() << " ; " << upper.Z() << " ] split in " << steps[2]
        << "x " << stepSize.Z() << " cm steps"
        << "\n";

    return out;
  } // operator<< (sim::PhotonVoxelDef)

std::string sim::ParticleName

(

int

pigid

)

Returns a string with the name of particle the specified with PDG ID.

Definition at line 147 of file MCDumperUtils.cxx.

                                     {
  TParticlePDG const* PDGinfo = TDatabasePDG::Instance()->GetParticle(pigid);
  return PDGinfo? PDGinfo->GetTitle(): ("PDG ID " + std::to_string(pigid));
} // sim::ParticleName()

std::string sim::ParticleStatusName

(

int

code

)

Describes the status of a particle (simb::MCParticle::StatusCode()).

Definition at line 126 of file MCDumperUtils.cxx.

                                          {

  switch(code) {
    case -1: return "undefined";
    case  0: return "initial state";
    case  1: return "stable final state";
    case  2: return "intermediate";
    case  3: return "decayed";
    case 11: return "nucleon target";
    case 12: return "pre-fragmentation hadronic state";
    case 13: return "pre-decay resonant state";
    case 14: return "hadron in nucleus";
    case 15: return "final state nuclear remnant";
    case 16: return "nucleon cluster target";
    default: return "unknown";
  } // switch
  
} // sim::ParticleStatusName

std::string sim::RescatteringName	(	int	code,
		RescatterCategory	cat = RescatterCategory::LArSoftDefault
	)

The name of the specified rescattering code.

Parameters

code	the rescattering code
type	the category of rescattering code belongs to

Returns

a string describing the rescattering code

The meaning of the rescattering code is generator-dependent, and also within a generator it may be algorithm-dependent. The category pins down which set of possible meaning the code belongs to. In LArSoft, if the code is unassigned by the generator, it will default to simb::MCParticle::s_uninitialized.

Definition at line 163 of file MCDumperUtils.cxx.

{
  using namespace std::string_literals;
  
  if (code == simb::MCParticle::s_uninitialized) return "(unset)"s;
  
  switch (cat) {
    case RescatterCategory::GENIE_INukeFateHA:
      return GENIE_INukeFateHA_RescatteringName(code);
    default:
      return "unknown category "s + std::to_string(static_cast<int>(cat))
        + " (code: "s + std::to_string(code) + ")"s;
  } // switch(code)
  
} // sim::RescatteringName()

std::string sim::TruthCCNCname

(

int

ccnc

)

Returns a string representing the specified process from simb::MCTruth (CC or NC, nothing fancy).

Definition at line 32 of file MCDumperUtils.cxx.

                                     {
  switch (ccnc) {
    case simb::kCC: return "charged weak current";
    case simb::kNC: return "neutral weak current";
    default:        return "unsupported (" + std::to_string(ccnc) + ")";
  } // switch
} // sim::TruthCCNCname()

std::string sim::TruthInteractionTypeName

(

int

type

)

Returns a string representing the specified interaction type as in simb::MCTruth convention.

Definition at line 56 of file MCDumperUtils.cxx.

                                                {
  switch (type) {
    case simb::kUnknownInteraction            : return "unknown interaction";
    case simb::kQE                            : return "quasi-elastic scattering";
    case simb::kRes                           : return "resonant scattering";
    case simb::kDIS                           : return "deep inelastic scattering";
    case simb::kCoh                           : return "coherent scattering";
    case simb::kCohElastic                    : return "coherent elastic scattering";
    case simb::kElectronScattering            : return "electron scattering";
    case simb::kIMDAnnihilation               : return "inverse muon decay annihilation";
    case simb::kInverseBetaDecay              : return "inverse beta decay";
    case simb::kGlashowResonance              : return "Glashow resonance";
    case simb::kAMNuGamma                     : return "anomalous neutrino-photon interaction";
    case simb::kMEC                           : return "meson exchange current";
    case simb::kDiffractive                   : return "diffractive";
    case simb::kEM                            : return "electromagnetic";
    case simb::kWeakMix                       : return "weak mixing";
    case simb::kNuanceOffset                  : return "<nuance offset>";
    case simb::kCCQE                          : return "charged current quasi-elastic scattering";
    case simb::kNCQE                          : return "neutral current quasi-elastic scattering";
    case simb::kResCCNuProtonPiPlus           : return "resonant charged current neutrino proton pi+";
    case simb::kResCCNuNeutronPi0             : return "resonant charged current neutrino neutron pi0";
    case simb::kResCCNuNeutronPiPlus          : return "resonant charged current neutrino neutron pi+";
    case simb::kResNCNuProtonPi0              : return "resonant neutral current neutrino proton pi0";
    case simb::kResNCNuProtonPiPlus           : return "resonant neutral current neutrino proton pi+";
    case simb::kResNCNuNeutronPi0             : return "resonant neutral current neutrino neutron pi0";
    case simb::kResNCNuNeutronPiMinus         : return "resonant neutral current neutrino neutron pi-";
    case simb::kResCCNuBarNeutronPiMinus      : return "resonant charged current antineutrino neutron pi-";
    case simb::kResCCNuBarProtonPi0           : return "resonant charged current antineutrino proton pi0";
    case simb::kResCCNuBarProtonPiMinus       : return "resonant charged current antineutrino proton pi-";
    case simb::kResNCNuBarProtonPi0           : return "resonant neutral current antineutrino proton pi0";
    case simb::kResNCNuBarProtonPiPlus        : return "resonant neutral current antineutrino proton pi+";
    case simb::kResNCNuBarNeutronPi0          : return "resonant neutral current antineutrino neutron pi0";
    case simb::kResNCNuBarNeutronPiMinus      : return "resonant neutral current antineutrino neutron pi-";
    case simb::kResCCNuDeltaPlusPiPlus        : return "resonant charged current neutrino Delta+ pi+";
    case simb::kResCCNuDelta2PlusPiMinus      : return "resonant charged current neutrino Delta++ pi-";
    case simb::kResCCNuBarDelta0PiMinus       : return "resonant charged current antineutrino Delta0 pi-";
    case simb::kResCCNuBarDeltaMinusPiPlus    : return "resonant charged current antineutrino Delta- pi+";
    case simb::kResCCNuProtonRhoPlus          : return "resonant charged current neutrino proton rho+";
    case simb::kResCCNuNeutronRhoPlus         : return "resonant charged current neutrino neutron rho+";
    case simb::kResCCNuBarNeutronRhoMinus     : return "resonant charged current antineutrino neutron rho-";
    case simb::kResCCNuBarNeutronRho0         : return "resonant charged current antineutrino neutron rho0";
    case simb::kResCCNuSigmaPlusKaonPlus      : return "resonant charged current neutrino Sigma+ kaon+";
    case simb::kResCCNuSigmaPlusKaon0         : return "resonant charged current neutrino Sigma+ kaon0";
    case simb::kResCCNuBarSigmaMinusKaon0     : return "resonant charged current antineutrino Sigma- kaon0";
    case simb::kResCCNuBarSigma0Kaon0         : return "resonant charged current antineutrino Sigma0 kaon0";
    case simb::kResCCNuProtonEta              : return "resonant charged current neutrino proton eta";
    case simb::kResCCNuBarNeutronEta          : return "resonant charged current antineutrino neutron eta";
    case simb::kResCCNuKaonPlusLambda0        : return "resonant charged current neutrino Kaon+ Lambda0";
    case simb::kResCCNuBarKaon0Lambda0        : return "resonant charged current antineutrino kaon0 Lambda0";
    case simb::kResCCNuProtonPiPlusPiMinus    : return "resonant charged current neutrino proton pi+ pi-";
    case simb::kResCCNuProtonPi0Pi0           : return "resonant charged current neutrino proton pi0 pi0";
    case simb::kResCCNuBarNeutronPiPlusPiMinus: return "resonant charged current antineutrino neutron pi+ pi-";
    case simb::kResCCNuBarNeutronPi0Pi0       : return "resonant charged current antineutrino neutron pi0 pi0";
    case simb::kResCCNuBarProtonPi0Pi0        : return "resonant charged current antineutrino proton pi0 pi0";
    case simb::kCCDIS                         : return "charged current deep inelastic scattering";
    case simb::kNCDIS                         : return "neutral current deep inelastic scattering";
    case simb::kUnUsed1                       : return "unused (1)";
    case simb::kUnUsed2                       : return "unused (2)";
    case simb::kCCQEHyperon                   : return "charged current quasi-elastic scattering with hyperon";
    case simb::kNCCOH                         : return "neutral current coherent scattering";
    case simb::kCCCOH                         : return "charged current coherent scattering";
    case simb::kNuElectronElastic             : return "electron neutrino elastic";
    case simb::kInverseMuDecay                : return "inverse muon decay";
    default                                   : return "unsupported (" + std::to_string(type) + ")";
  } // switch
} // sim::TruthInteractionTypeName()

std::string sim::TruthOriginName

(

simb::Origin_t

origin

)

Returns a string representing the specified process origin.

Definition at line 19 of file MCDumperUtils.cxx.

                                                  {
  switch (origin) {
    case simb::kUnknown          : return "unknown origin";
    case simb::kBeamNeutrino     : return "neutrinos from beam";
    case simb::kCosmicRay        : return "cosmic rays";
    case simb::kSuperNovaNeutrino: return "supernova neutrinos";
    case simb::kSingleParticle   : return "single particle";
    default:        return "unsupported (" + std::to_string((int)origin) + ")";
  } // switch
} // sim::TruthOriginName()

std::string sim::TruthReactionMode

(

int

mode

)

Returns the "mode" of the reaction (a lesser version of interaction type).

Definition at line 42 of file MCDumperUtils.cxx.

                                         {
  
  switch (mode) {
    case  0: return "quasi-elastic";
    case  1: return "resonant";
    case  2: return "deep inelastic";
    case  3: return "coherent";
    default: return "unknown mode";
  } // switch
  
} // sim::TruthReactionMode()

Variable Documentation

const double sim::kINVALID_DOUBLE = std::numeric_limits <double>::max()

Definition at line 10 of file MCLimits.h.

const float sim::kINVALID_FLOAT = std::numeric_limits <float>::max()

Definition at line 12 of file MCLimits.h.

const int sim::kINVALID_INT = std::numeric_limits <int>::max()

Definition at line 16 of file MCLimits.h.

const unsigned int sim::kINVALID_UINT = std::numeric_limits <unsigned int>::max()

Definition at line 14 of file MCLimits.h.

const int sim::NoParticleId = std::numeric_limits<int>::min()

static

Definition at line 28 of file sim.h.