#include <EDepSimUserPrimaryGeneratorAction.hh>

Inheritance diagram for EDepSim::UserPrimaryGeneratorAction:

Public Member Functions
	UserPrimaryGeneratorAction (void)

virtual	~UserPrimaryGeneratorAction ()

virtual void	GeneratePrimaries (G4Event *anEvent)

void	AddGenerator (G4VPrimaryGenerator *generator)

void	ClearGenerators ()
	Clear the current list of generators. More...

const G4VPrimaryGenerator *	GetGenerator (int i) const
	Get the generators used to create events. There will be at least one. More...

int	GetGeneratorCount () const
	Get the number of generators being used to create events. More...

void	SetAllowEmptyEvents (bool flag)

void	SetAllowPartialEvents (bool flag)

void	SetAddFakeGeantino (bool flag)

Private Attributes
std::vector< G4VPrimaryGenerator * >	fPrimaryGenerators

bool	fAllowEmptyEvents

bool	fAddFakeGeantino

bool	fAllowPartialEvents

EDepSim::UserPrimaryGeneratorMessenger *	fMessenger
	The messenger for this action. More...

Detailed Description

Definition at line 17 of file EDepSimUserPrimaryGeneratorAction.hh.

Constructor & Destructor Documentation

EDepSim::UserPrimaryGeneratorAction::UserPrimaryGeneratorAction ( void )

Definition at line 16 of file EDepSimUserPrimaryGeneratorAction.cc.

                                                               {
     fMessenger = new EDepSim::UserPrimaryGeneratorMessenger(this);
     fAllowEmptyEvents = true;
     fAddFakeGeantino = false;
 }

EDepSim::UserPrimaryGeneratorAction::~UserPrimaryGeneratorAction ( )

virtual

Definition at line 22 of file EDepSimUserPrimaryGeneratorAction.cc.

                                                                {
     delete fMessenger;
 }

Member Function Documentation

void EDepSim::UserPrimaryGeneratorAction::AddGenerator ( G4VPrimaryGenerator * generator )

inline

Add a new EDepSim::PrimaryGenerator to the list of generators adding primary vertices to the event.

Definition at line 31 of file EDepSimUserPrimaryGeneratorAction.hh.

                                                       {
         fPrimaryGenerators.push_back(generator);
     }

void EDepSim::UserPrimaryGeneratorAction::ClearGenerators ( )

Clear the current list of generators.

Definition at line 76 of file EDepSimUserPrimaryGeneratorAction.cc.

                                                         {
     for (std::vector<G4VPrimaryGenerator*>::iterator gen
              = fPrimaryGenerators.begin();
          gen != fPrimaryGenerators.end();
          ++gen) {
         delete (*gen);
     }
     fPrimaryGenerators.clear();
 }

void EDepSim::UserPrimaryGeneratorAction::GeneratePrimaries ( G4Event * anEvent )

virtual

Generate all of the primaries for and event and place them into a primary vertex. This may generate several primary vertices (in no particular order).

Definition at line 26 of file EDepSimUserPrimaryGeneratorAction.cc.

                                                                           {
     // Make sure that at least one generater is in the list.  If the list is
     // empty, then create the default generator.
     if (fPrimaryGenerators.size()<1) {
         AddGenerator(fMessenger->CreateGenerator());
     }
 
     for (int finiteLoop = 0; finiteLoop<1000; ++finiteLoop) {
         for (std::vector<G4VPrimaryGenerator*>::iterator generator
                  = fPrimaryGenerators.begin();
              generator != fPrimaryGenerators.end();
              ++generator) {
             try {
                 (*generator)->GeneratePrimaryVertex(anEvent);
             }
             catch (EDepSim::NoMoreEvents&) {
                 if (fAllowPartialEvents) {
                     EDepSimLog("GeneratePrimaries: "
                                << "Ran out of primaries will filling event.");
                     continue;
                 }
                 EDepSimError("Run aborted.  No more input events.");
                 G4RunManager::GetRunManager()->AbortRun();
                 return;
             }
         }
         if (fAddFakeGeantino) {
             EDepSimWarn("Add a GEANTINO vertex.");
             // Put the vertex far way, and far in the future.
             G4PrimaryVertex* theVertex =
                 new G4PrimaryVertex(G4ThreeVector(1E+20, 1E+20, 1E+20),
                                     1E+20);
             anEvent->AddPrimaryVertex(theVertex);
             // Create the GEANTINO
             G4ParticleTable* particleTable
                 = G4ParticleTable::GetParticleTable();
             G4ParticleDefinition* def = particleTable->FindParticle("geantino");
             G4PrimaryParticle* part
                 = new G4PrimaryParticle(def,0.0, 0.0, 1.0);
             theVertex->SetPrimary(part);
             break;
         }
         if (anEvent->GetNumberOfPrimaryVertex()>0) break;
         if (fAllowEmptyEvents) continue;
         EDepSimError("EDepSim::UserPrimaryGeneratorAction::GeneratePrimaries():"
                    << " Event generated without any primary verticies.");
         EDepSimThrow("No primaries generated.");
     }
 }

const G4VPrimaryGenerator* EDepSim::UserPrimaryGeneratorAction::GetGenerator ( int i ) const

inline

Get the generators used to create events. There will be at least one.

Definition at line 39 of file EDepSimUserPrimaryGeneratorAction.hh.

                                                          {
         return fPrimaryGenerators[i];
     }

int EDepSim::UserPrimaryGeneratorAction::GetGeneratorCount ( ) const

inline

Get the number of generators being used to create events.

Definition at line 44 of file EDepSimUserPrimaryGeneratorAction.hh.

                                   {
         return fPrimaryGenerators.size();
     }

void EDepSim::UserPrimaryGeneratorAction::SetAddFakeGeantino ( bool flag )

inline

Set a flag that events without a real vertex should have a fake GEANTINO generated. This only has an effect with SetAllowEmptyEvents() has been called with true.

Definition at line 60 of file EDepSimUserPrimaryGeneratorAction.hh.

60 {fAddFakeGeantino = flag;}

EDepSim::UserPrimaryGeneratorAction::fAddFakeGeantino

bool fAddFakeGeantino

Definition: EDepSimUserPrimaryGeneratorAction.hh:74

void EDepSim::UserPrimaryGeneratorAction::SetAllowEmptyEvents ( bool flag )

inline

Set a flag that events that don't contain a real vertex are allowed. If the flag is true, then empty events are allowed.

Definition at line 50 of file EDepSimUserPrimaryGeneratorAction.hh.

50 {fAllowEmptyEvents = flag;}

EDepSim::UserPrimaryGeneratorAction::fAllowEmptyEvents

bool fAllowEmptyEvents

Definition: EDepSimUserPrimaryGeneratorAction.hh:70

void EDepSim::UserPrimaryGeneratorAction::SetAllowPartialEvents ( bool flag )

inline

Set a flag that events that it's to run out of events in the kinematics file. If the flag is true, then partial events are allowed.

Definition at line 55 of file EDepSimUserPrimaryGeneratorAction.hh.

55 {fAllowPartialEvents = flag;}

EDepSim::UserPrimaryGeneratorAction::fAllowPartialEvents

bool fAllowPartialEvents

Definition: EDepSimUserPrimaryGeneratorAction.hh:80

Member Data Documentation

bool EDepSim::UserPrimaryGeneratorAction::fAddFakeGeantino

private

A flag that any empty event should be filled with a fake GEANTINO vertex. This only has an affect with fAllowEmptyEvents is true.

Definition at line 74 of file EDepSimUserPrimaryGeneratorAction.hh.

bool EDepSim::UserPrimaryGeneratorAction::fAllowEmptyEvents

private

A flag that empty events are allowed. If this is set to be true, the generator will return events even if there are no real vertices.

Definition at line 70 of file EDepSimUserPrimaryGeneratorAction.hh.

bool EDepSim::UserPrimaryGeneratorAction::fAllowPartialEvents

private

A flag to allow an event to be generated even if the input kinematics has run out of data. This is useful when a single spill of interactions has been generated and you want to generate a single event containing every interaction in the kinematic input file.

Definition at line 80 of file EDepSimUserPrimaryGeneratorAction.hh.

EDepSim::UserPrimaryGeneratorMessenger* EDepSim::UserPrimaryGeneratorAction::fMessenger

private

The messenger for this action.

Definition at line 83 of file EDepSimUserPrimaryGeneratorAction.hh.

std::vector<G4VPrimaryGenerator*> EDepSim::UserPrimaryGeneratorAction::fPrimaryGenerators

private

A vector of generator sets to use to generate events. Each of these primary factories will be called in sequence.

Definition at line 66 of file EDepSimUserPrimaryGeneratorAction.hh.

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

edep-sim/src/EDepSimUserPrimaryGeneratorAction.hh
edep-sim/src/EDepSimUserPrimaryGeneratorAction.cc

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation