EDepSim::RooTrackerKinematicsGenerator Class Reference

#include <EDepSimRooTrackerKinematicsGenerator.hh>

Inheritance diagram for EDepSim::RooTrackerKinematicsGenerator:

Public Member Functions
	RooTrackerKinematicsGenerator (const G4String &name, const G4String &fileName, const G4String &treeName, const G4String &order, int firstEvent)
virtual	~RooTrackerKinematicsGenerator ()
virtual GeneratorStatus	GeneratePrimaryVertex (G4Event *evt, const G4LorentzVector &position)
	Add a primary vertex to the event. More...
virtual G4String	GetInputName ()
	Get the name of the open kinematics file. More...
Public Member Functions inherited from EDepSim::VKinematicsGenerator
	VKinematicsGenerator (const G4String &name)
virtual	~VKinematicsGenerator ()
G4String	GetName () const
	Return the name of the generator. More...

Private Attributes
std::string	fFilename
	The static part of the file name field. More...
TFile *	fInput
	The RooTracker file to read. More...
TTree *	fTree
	The event tree that contains the output events. More...
unsigned int	fNextEntry
std::vector< int >	fEntryVector
TBits *	fEvtFlags
	The generator-specific event flags. More...
TObjString *	fEvtCode
	The generator-specific string with the 'event code'. More...
int	fEvtNum
	The sequence number of the event (the event number). More...
double	fEvtXSec
	The cross section for the event (1E-38 cm2) More...
double	fEvtDXSec
double	fEvtWght
	The weight for the event. More...
double	fEvtProb
double	fEvtVtx [4]
int	fStdHepN
	The number of particles in the particle arrays to track. More...
int	fStdHepPdg [kNPmax]
int	fStdHepStatus [kNPmax]
double	fStdHepX4 [kNPmax][4]
double	fStdHepP4 [kNPmax][4]
	The 4-momentum (px, py, pz, E) of the particle in the LAB frame (GeV) More...
double	fStdHepPolz [kNPmax][3]
	The particle polarization vector. More...
int	fStdHepFd [kNPmax]
	The index of the first daughter of the particle in the arrays. More...
int	fStdHepLd [kNPmax]
	The index last daughter of the particle in the arrays. More...
int	fStdHepFm [kNPmax]
	The index of the first mother of the particle in there arrays. More...
int	fStdHepLm [kNPmax]
	The index of the last mother of the particle in the arrays. More...
int	fNuParentPdg
	The PDG code of the particle which created the parent neutrino. More...
int	fNuParentDecMode
double	fNuParentDecP4 [4]
double	fNuParentDecX4 [4]
double	fNuParentProP4 [4]
double	fNuParentProX4 [4]
int	fNuParentProNVtx
	The vertex ID of the parent particle vertex. More...

Static Private Attributes
static const int	kNPmax = 4000
	The maximum number of particles that can be in the particle arrays. More...

Additional Inherited Members
Public Types inherited from EDepSim::VKinematicsGenerator
enum	GeneratorStatus { kFail = 0, kSuccess, kLastVertex, kEndEvent }
	A status value that can be returned by GeneratePrimaryVertex. More...

Detailed Description

Definition at line 18 of file EDepSimRooTrackerKinematicsGenerator.hh.

Constructor & Destructor Documentation

EDepSim::RooTrackerKinematicsGenerator::RooTrackerKinematicsGenerator	(	const G4String &	name,
		const G4String &	fileName,
		const G4String &	treeName,
		const G4String &	order,
		int	firstEvent
	)

Construct a new generator. The name is the name of the generator (e.g. NEUT, GENIE, &c). The fileName is the name of the root file containing the tree of kinematic information. The treeName is the path of the rooTracker tree in the input file. The order is a string specifying the order that events in the input files should be used. The current legal values are "consecutive", "stride", or "random". The firstEvent is the first event to use in the file.

While NEUT and GENIE produce files with single interactions in each event, the individual events can be built into spill using another program (a so called overlay program). The divisions between the spills can be specified by adding in a fake event that has a single particle with a HepStatus value of -1. The fake event will be dropped from generation, so it should not contain a real particle.

Definition at line 35 of file EDepSimRooTrackerKinematicsGenerator.cc.

    : EDepSim::VKinematicsGenerator(name), fInput(NULL), fTree(NULL),
      fNextEntry(0) {

    fInput = TFile::Open(filename,"OLD");
    if (!fInput->IsOpen()) {
        throw std::runtime_error("EDepSim::RooTrackerKinematicsGenerator::"
                                 " File Not Open");
    }

    EDepSimLog("Open a RooTracker tree from " << filename);

    fTree = dynamic_cast<TTree*>(fInput->Get(treeName));
    if (!fTree) {
        throw std::runtime_error("EDepSim::RooTrackerKinematicsGenerator::"
                                 " Tree not found by constructor");
    }
    EDepSimNamedInfo("rooTracker",
                     "   File has  " << fTree->GetEntries() << " entries");

    // Find the basename of the input filename.
    std::string::size_type start_pos = filename.rfind("/");
    if (start_pos == std::string::npos) start_pos = 0; else ++start_pos;
    std::string basename(filename,start_pos);
    fFilename = basename + ":" + treeName;

    fEvtFlags = NULL;
    fTree->SetBranchAddress("EvtFlags",       &fEvtFlags);
    fEvtCode = NULL;
    fTree->SetBranchAddress("EvtCode",        &fEvtCode);
    fTree->SetBranchAddress("EvtNum",         &fEvtNum);
    fTree->SetBranchAddress("EvtXSec",        &fEvtXSec);
    fTree->SetBranchAddress("EvtDXSec",       &fEvtDXSec);
    fTree->SetBranchAddress("EvtWght",        &fEvtWght);
    fTree->SetBranchAddress("EvtProb",        &fEvtProb);
    fTree->SetBranchAddress("EvtVtx",          fEvtVtx);
    fTree->SetBranchAddress("StdHepN",        &fStdHepN);
    fTree->SetBranchAddress("StdHepPdg",       fStdHepPdg);
    fTree->SetBranchAddress("StdHepStatus",    fStdHepStatus);
    fTree->SetBranchAddress("StdHepX4",        fStdHepX4);
    fTree->SetBranchAddress("StdHepP4",        fStdHepP4);
    fTree->SetBranchAddress("StdHepPolz",      fStdHepPolz);
    fTree->SetBranchAddress("StdHepFd",        fStdHepFd);
    fTree->SetBranchAddress("StdHepLd",        fStdHepLd);
    fTree->SetBranchAddress("StdHepFm",        fStdHepFm);
    fTree->SetBranchAddress("StdHepLm",        fStdHepLm);
#define PARENT_PARTICLE_PASS_THROUGH
#ifdef PARENT_PARTICLE_PASS_THROUGH
    fTree->SetBranchAddress("NuParentPdg",    &fNuParentPdg);
    fTree->SetBranchAddress("NuParentDecMode",&fNuParentDecMode);
    fTree->SetBranchAddress("NuParentDecP4",   fNuParentDecP4);
    fTree->SetBranchAddress("NuParentDecX4",   fNuParentDecX4);
    fTree->SetBranchAddress("NuParentProP4",   fNuParentProP4);
    fTree->SetBranchAddress("NuParentProX4",   fNuParentProX4);
    fTree->SetBranchAddress("NuParentProNVtx",&fNuParentProNVtx);
#endif

    // Set the input tree to the current rootracker tree that this class is
    // using.
    EDepSim::KinemPassThrough::GetInstance()->AddInputTree(fTree,
                                                       filename,
                                                       GetName());

    // Generate a vector of entries to be used by this generator.

    // Calculate the stride through the file.  This could be cached, but
    // recalculate each time for simplicity.  Note that the stride should be a
    // prime number, and not a divisor of the number of entries in the tree.
    int entries = fTree->GetEntries();
    fEntryVector.resize(entries);
    int stride = 1;
    while (order == "stride") {
        stride = 17;
        if (0 != entries%stride) break;
        stride = 19;
        if (0 != entries%stride) break;
        stride = 23;
        if (0 != entries%stride) break;
        stride = 29;
        if (0 != entries%stride) break;
        throw std::runtime_error("EDepSim::RooTrackerKinematicsGenerator:: "
                    "File size cannot be divisible by 215441");
        break; // throw std::runtime_error doesn't actually return
    }
    int entry = 0;
    for (int i=0; i<entries; ++i) {
        fEntryVector[i] = entry;
        entry = (entry + stride)%entries;
    }
    if (order == "random") {
        unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
        std::shuffle(fEntryVector.begin(), fEntryVector.end(),std::default_random_engine(seed));
    }

    if (firstEvent > 0) {
        EDepSimLog("   FIRST EVENT WILL BE " << firstEvent);
        if (firstEvent >= entries) {
            throw std::runtime_error("EDepSim::RooTrackerKinematicsGenerator::"
                        "  First event after last event");
        }
        fEntryVector.erase(std::copy(fEntryVector.begin()+firstEvent,
                                     fEntryVector.end(),fEntryVector.begin()),
                           fEntryVector.end());
    }
}

EDepSim::RooTrackerKinematicsGenerator::~RooTrackerKinematicsGenerator ( )

virtual

Definition at line 144 of file EDepSimRooTrackerKinematicsGenerator.cc.

{ }

Member Function Documentation

EDepSim::VKinematicsGenerator::GeneratorStatus EDepSim::RooTrackerKinematicsGenerator::GeneratePrimaryVertex ( G4Event *  evt, const G4LorentzVector &  position  )

virtual

Add a primary vertex to the event.

Check to see if the next event is there.

Implements EDepSim::VKinematicsGenerator.

Definition at line 152 of file EDepSimRooTrackerKinematicsGenerator.cc.

                            {
    if (!fInput) {
        throw std::runtime_error("EDepSim::RooTrackerKinematicsGenerator::"
                                 " File Not Open");
    }

    /// Check to see if the next event is there.
    if (fNextEntry >= fEntryVector.size()) {
        EDepSimLog("EDepSim::RooTrackerKinematicsGenerator: input file end.");
        throw EDepSim::NoMoreEvents();
    }

    fInput->cd();

    int entry = fEntryVector.at(fNextEntry);
    // Get current entry to be used as new vertex - see comment below.
    fTree->GetEntry(entry);
    // Store current entry in the pass-through obj. N.B. To avoid mismatch
    // and false results call EDepSim::KinemPassThrough::AddEntry(fTreePtr, X)
    // where X is same as X in most recent call to fTreePtr->GetEntry(X).
    EDepSim::KinemPassThrough::GetInstance()->AddEntry(fTree, entry);
    EDepSimVerbose("Use rooTracker event number " << fEvtNum
                 << " (entry #" << entry << " in tree)");

    // Increment the next entry counter.
    ++fNextEntry;

    // Set the default generator status.  This should be overridden if the
    // state changes.
    GeneratorStatus generatorStatus = kSuccess;

    // Check if this is an end-of-sequence marker.
    if (fStdHepN == 1 && fStdHepStatus[0]<0) {
        return kEndEvent;
    }

    // Create a new vertex to add the new particles, and add the vertex to the
    // event.
    G4PrimaryVertex* theVertex
        = new G4PrimaryVertex(G4ThreeVector(fEvtVtx[0]*m,
                                            fEvtVtx[1]*m,
                                            fEvtVtx[2]*m),
                              fEvtVtx[3]*second);
    anEvent->AddPrimaryVertex(theVertex);
    EDepSimNamedInfo("rooTracker","Vertex @ "
                     << G4BestUnit(theVertex->GetPosition(), "Length")
                     << " Time: " << G4BestUnit(theVertex->GetT0(), "Time"));

    // Add an information field to the vertex.
    EDepSim::VertexInfo *vertexInfo = new EDepSim::VertexInfo;
    theVertex->SetUserInformation(vertexInfo);

    // Fill the information fields for this vertex.
    vertexInfo->SetReaction(std::string(fEvtCode->String().Data()));
    // Set the file name for this event.
    std::ostringstream fs;
    fs << fFilename << ":" << entry;
    vertexInfo->SetFilename(fs.str());
    // Set the interaction number to that of the RooTracker pass-through tree.
    vertexInfo->SetInteractionNumber(
        EDepSim::KinemPassThrough::GetInstance()->LastEntryNumber());
    vertexInfo->SetCrossSection(fEvtXSec*1E-38*cm2);
    vertexInfo->SetDiffCrossSection(fEvtDXSec*1E-38*cm2);
    vertexInfo->SetWeight(fEvtWght);
    vertexInfo->SetProbability(fEvtProb);

    // Add an informational vertex for storing the incoming
    // neutrino particle and target nucleus.
    G4PrimaryVertex* theIncomingVertex
        = new G4PrimaryVertex(G4ThreeVector(fEvtVtx[0]*m,
                                            fEvtVtx[1]*m,
                                            fEvtVtx[2]*m),
                              fEvtVtx[3]*second);
    vertexInfo->AddInformationalVertex(theIncomingVertex);

    // Add an information field to the vertex.
    EDepSim::VertexInfo *incomingVertexInfo = new EDepSim::VertexInfo;
    incomingVertexInfo->SetName("initial-state");
    incomingVertexInfo->SetReaction(std::string(fEvtCode->String().Data()));
    theIncomingVertex->SetUserInformation(incomingVertexInfo);

    // Fill the particles to be tracked (status ==1).  These particles are
    // attached to the primary vertex.  Also save the incident neutrino
    // particle and the incident target nucleus; these particles are attached
    // to informational vertex.
    G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
    for (int cnt = 0; cnt < fStdHepN; ++cnt) {
        G4ParticleDefinition* particleDef
            = particleTable->FindParticle(fStdHepPdg[cnt]);
        if (!particleDef) {
            //maybe we have an ion; figure out if it makes any sense
            int ionA = (fStdHepPdg[cnt]/10) % 1000;
            int ionZ = (fStdHepPdg[cnt]/10000) % 1000;
            int type = (fStdHepPdg[cnt]/100000000);
            if (type == 10 && ionZ > 0 && ionA > ionZ) {
                G4IonTable* ionTable = particleTable->GetIonTable();
                particleDef = ionTable->GetIon(ionZ, ionA);
            }
            else if (type == 20) {
                // This is a pseudo-particle so skip it.
                continue;
            }
        }

        // Determine a name for the particle.
        std::string particleName =
            particleDef ? particleDef->GetParticleName(): "unknown";

        // Get the momentum.
        G4LorentzVector momentum(fStdHepP4[cnt][0]*GeV,
                                 fStdHepP4[cnt][1]*GeV,
                                 fStdHepP4[cnt][2]*GeV,
                                 fStdHepP4[cnt][3]*GeV);

        if (fStdHepStatus[cnt] != 1) {
            EDepSimVerbose("Untracked particle: " << cnt
                         << " " << particleName
                           << " with " << momentum.e()/MeV
                         << " MeV "
                         << " w/ mothers " << fStdHepFm[cnt]
                         << " to " << fStdHepLm[cnt]);
        }

        // We are only interested in particles to be tracked (status==1)
        // or incident neutrino/target nucleus (status==0).
        if( !(fStdHepStatus[cnt] == 0 || fStdHepStatus[cnt] == 1)) {
            continue;
        }

        if (!particleDef) {
            EDepSimSevere(" Particle code " << fStdHepPdg[cnt]
                      << " not recognized (not tracking)");
            continue;
        }

        // create the particle.
        G4PrimaryParticle* theParticle
            = new G4PrimaryParticle(particleDef,
                                    momentum.px(),
                                    momentum.py(),
                                    momentum.pz());
        theParticle->SetPolarization(fStdHepPolz[cnt][0],
                                     fStdHepPolz[cnt][1],
                                     fStdHepPolz[cnt][2]);

        if (fStdHepStatus[cnt] == 0) {
            EDepSimNamedInfo(
                "rooTracker",
                "Incoming "
                << particleDef->GetParticleName()
                << " " << theParticle->GetPDGcode()
                << " " << momentum.e()/MeV << " MeV"
                << " " << momentum.m()/MeV << " MeV/c^2");
            theIncomingVertex->SetPrimary(theParticle);
        }
        else if (fStdHepStatus[cnt] == 1){
            EDepSimNamedInfo(
                "rooTracker",
                "Tracking "
                << particleDef->GetParticleName()
                << " " << theParticle->GetPDGcode()
                << " " << momentum.e()/MeV << " MeV"
                << " " << momentum.m()/MeV << " MeV/c^2");
            theVertex->SetPrimary(theParticle);
        }
    }

#ifdef PARENT_PARTICLE_PASS_THROUGH
    // Fill the particles at the decay vertex.  These are the first info
    // vertex.
    G4PrimaryVertex* theDecayVertex
        = new G4PrimaryVertex(G4ThreeVector(fNuParentDecX4[0]*m,
                                            fNuParentDecX4[1]*m,
                                            fNuParentDecX4[2]*m),
                              fNuParentDecX4[3]*second);
    vertexInfo->AddInformationalVertex(theDecayVertex);

    // Add an information field to the vertex.
    EDepSim::VertexInfo *decayVertexInfo = new EDepSim::VertexInfo;
    decayVertexInfo->SetName("beam-particle:Decay");
    {
        std::ostringstream tmp;
        tmp << fNuParentDecMode;
        decayVertexInfo->SetReaction(tmp.str());
    }
    theDecayVertex->SetUserInformation(decayVertexInfo);

    G4PrimaryParticle* theDecayParticle
        = new G4PrimaryParticle(fNuParentPdg,
                                fNuParentDecP4[0]*GeV,
                                fNuParentDecP4[1]*GeV,
                                fNuParentDecP4[2]*GeV);
    theDecayVertex->SetPrimary(theDecayParticle);

    // Fill the particles at the production vertex.
    G4PrimaryVertex* theProductionVertex
        = new G4PrimaryVertex(G4ThreeVector(fNuParentProX4[0]*m,
                                            fNuParentProX4[1]*m,
                                            fNuParentProX4[2]*m),
                              fNuParentProX4[3]*second);
    decayVertexInfo->AddInformationalVertex(theProductionVertex);

    // Add information about the production vertex.
    EDepSim::VertexInfo *productionVertexInfo = new EDepSim::VertexInfo;
    productionVertexInfo->SetName("beam-particle:Production");
    productionVertexInfo->SetInteractionNumber(fNuParentProNVtx);
    theProductionVertex->SetUserInformation(productionVertexInfo);

    G4PrimaryParticle* theProductionParticle
        = new G4PrimaryParticle(fNuParentPdg,
                                fNuParentProP4[0]*GeV,
                                fNuParentProP4[1]*GeV,
                                fNuParentProP4[2]*GeV);
    theProductionVertex->SetPrimary(theProductionParticle);
#endif

    return generatorStatus;
}

G4String EDepSim::RooTrackerKinematicsGenerator::GetInputName ( )

virtual

Get the name of the open kinematics file.

Definition at line 146 of file EDepSimRooTrackerKinematicsGenerator.cc.

                                                            {
    if (!fInput) return G4String("not-open");
    return G4String(fInput->GetName());
}

Member Data Documentation

std::vector<int> EDepSim::RooTrackerKinematicsGenerator::fEntryVector

private

A pre-filled vector of entry numbers to be used from input tree. This is used to allow the order of the input interactions to be randomized. Beam flux simulators typically over-sample pion decays in the beam pipe so that they can generate larger samples. This has the unfortunate effect that consecutive neutrino interactions will have correlated energies.

Definition at line 68 of file EDepSimRooTrackerKinematicsGenerator.hh.

TObjString* EDepSim::RooTrackerKinematicsGenerator::fEvtCode

private

The generator-specific string with the 'event code'.

Definition at line 79 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fEvtDXSec

private

The differential cross section for the event kinematics (1E-38 cm2/{K^n})

Definition at line 89 of file EDepSimRooTrackerKinematicsGenerator.hh.

TBits* EDepSim::RooTrackerKinematicsGenerator::fEvtFlags

private

The generator-specific event flags.

Definition at line 76 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fEvtNum

private

The sequence number of the event (the event number).

Definition at line 82 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fEvtProb

private

The probability for the event (given the cross section, path lengths, etc.).

Definition at line 96 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fEvtVtx[4]

private

The event vertex position in detector coord syst (in meters and seconds).

Definition at line 100 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fEvtWght

private

The weight for the event.

Definition at line 92 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fEvtXSec

private

The cross section for the event (1E-38 cm2)

Definition at line 85 of file EDepSimRooTrackerKinematicsGenerator.hh.

std::string EDepSim::RooTrackerKinematicsGenerator::fFilename

private

The static part of the file name field.

Definition at line 50 of file EDepSimRooTrackerKinematicsGenerator.hh.

TFile* EDepSim::RooTrackerKinematicsGenerator::fInput

private

The RooTracker file to read.

Definition at line 53 of file EDepSimRooTrackerKinematicsGenerator.hh.

unsigned int EDepSim::RooTrackerKinematicsGenerator::fNextEntry

private

The next entry to read from the file. The entry to be used is fEntryVector[fNextEntry].

Definition at line 60 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fNuParentDecMode

private

The interaction mode at the vertex which created the parent neutrino. This is normally the decay mode of the parent particle.

Definition at line 177 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fNuParentDecP4[4]

private

The 4 momentum of the particle at the vertex which created the parent neutrino. This is normally the momentum of the parent particle at the decay point.

Definition at line 182 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fNuParentDecX4[4]

private

The position of the vertex at which the neutrino was created. This is passed directly from the beam (or other flux) generator, and is in the native units of the original generator.

Definition at line 187 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fNuParentPdg

private

The PDG code of the particle which created the parent neutrino.

The following variables are copied more or less directly from the input flux generator.

Definition at line 173 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fNuParentProNVtx

private

The vertex ID of the parent particle vertex.

Definition at line 199 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fNuParentProP4[4]

private

The momentum of the parent particle at it's production point. This is in the native energy units of the flux generator.

Definition at line 191 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fNuParentProX4[4]

private

The position of the parent particle at it's production point. This uses the target as the origin and is in the native units of the flux generator.

Definition at line 196 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepFd[kNPmax]

private

The index of the first daughter of the particle in the arrays.

Definition at line 156 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepFm[kNPmax]

private

The index of the first mother of the particle in there arrays.

Definition at line 162 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepLd[kNPmax]

private

The index last daughter of the particle in the arrays.

Definition at line 159 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepLm[kNPmax]

private

The index of the last mother of the particle in the arrays.

Definition at line 165 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepN

private

The number of particles in the particle arrays to track.

Definition at line 103 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fStdHepP4[kNPmax][4]

private

The 4-momentum (px, py, pz, E) of the particle in the LAB frame (GeV)

Definition at line 150 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepPdg[kNPmax]

private

The PDG codes for the particles to track. This may include generator specific codes for pseudo particles.

Definition at line 110 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fStdHepPolz[kNPmax][3]

private

The particle polarization vector.

Definition at line 153 of file EDepSimRooTrackerKinematicsGenerator.hh.

int EDepSim::RooTrackerKinematicsGenerator::fStdHepStatus[kNPmax]

private

The a generator specific status for each particle. Particles with a status equal to 1 will be tracked.

The HEPEVT status values are as follows:

• 0 : null entry.
• 1 : an existing entry, which has not decayed or fragmented. This is the main class of entries, which represents the `final state' given by the generator.
• 2 : an entry which has decayed or fragmented and is therefore not appearing in the final state, but is retained for event history information.
• 3 : a documentation line, defined separately from the event history. This could include the two incoming reacting particles, etc.
• 4 to 10 : undefined, but reserved for future standards.
• 11 to 200 : at the disposal of each model builder for constructs specific to his program, but equivalent to a null line in the context of any other program.
• 201 and above : at the disposal of users, in particular for event tracking in the detector.

The GENIE generator approximately follows the HEPEVT status codes. As of July 2008, the status values found the GENIE source code are:

• -1 – Undefined particle
• 0 – An initial state particle.
• 1 – A stable final state particle to be tracked.
• 2 – An intermediate particle that should not be tracked.
• 3 – A particle which decayed and should not be tracked. If this particle produced daughters to be tracked, they will have a state of 1.

Definition at line 143 of file EDepSimRooTrackerKinematicsGenerator.hh.

double EDepSim::RooTrackerKinematicsGenerator::fStdHepX4[kNPmax][4]

private

The position (x, y, z, t) (fm, second) of the particle in the nuclear frame

Definition at line 147 of file EDepSimRooTrackerKinematicsGenerator.hh.

TTree* EDepSim::RooTrackerKinematicsGenerator::fTree

private

The event tree that contains the output events.

Definition at line 56 of file EDepSimRooTrackerKinematicsGenerator.hh.

const int EDepSim::RooTrackerKinematicsGenerator::kNPmax = 4000

staticprivate

The maximum number of particles that can be in the particle arrays.

Definition at line 106 of file EDepSimRooTrackerKinematicsGenerator.hh.

---

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

• edep-sim/src/kinem/EDepSimRooTrackerKinematicsGenerator.hh
• edep-sim/src/kinem/EDepSimRooTrackerKinematicsGenerator.cc