#include <EDepSimUserPrimaryGeneratorMessenger.hh>

Inheritance diagram for EDepSim::UserPrimaryGeneratorMessenger:

Public Member Functions
	UserPrimaryGeneratorMessenger (EDepSim::UserPrimaryGeneratorAction *)

virtual	~UserPrimaryGeneratorMessenger ()

void	SetNewValue (G4UIcommand *, G4String)
	Handle messages from the UI processor. More...

G4String	GetPath ()
	Get the base directory for the messenger commands. More...

void	AddKinematicsFactory (EDepSim::VKinematicsFactory *factory)
	Add a new kinematics factory to the messenger. More...

void	SetKinematicsFactory (const G4String &factory)
	Set the current kinematics factory for the messenger. More...

G4String	GetKinematicsFactories ()
	Get the list of kinematics factories available to the messenger. More...

void	AddCountFactory (EDepSim::VCountFactory *factory)
	Add a new count factory to the messenger. More...

void	SetCountFactory (const G4String &factory)
	Set the current count factory for the messenger. More...

G4String	GetCountFactories ()
	Get the list of count factories available to the messenger. More...

void	AddPositionFactory (EDepSim::VPositionFactory *factory)
	Add a new position factory to the messenger. More...

void	SetPositionFactory (const G4String &factory)
	Set the current position factory for the messenger. More...

G4String	GetPositionFactories ()
	Get the list of position factories available to the messenger. More...

void	AddTimeFactory (EDepSim::VTimeFactory *factory)
	Add a new time factory to the messenger. More...

void	SetTimeFactory (const G4String &factory)
	Set the current time factory for the messenger. More...

G4String	GetTimeFactories ()
	Get the list of time factories available to the messenger. More...

EDepSim::PrimaryGenerator *	CreateGenerator ()
	Create a new generator using the current generator factories. More...

Private Attributes
EDepSim::UserPrimaryGeneratorAction *	fAction

std::map< G4String, EDepSim::VKinematicsFactory * >	fKinematicsFactories
	The list of available kinematics factories;. More...

EDepSim::VKinematicsFactory *	fKinematics
	The current kinematics factory. More...

std::map< G4String, EDepSim::VCountFactory * >	fCountFactories
	The list of available count factories;. More...

EDepSim::VCountFactory *	fCount
	The current count factory. More...

std::map< G4String, EDepSim::VPositionFactory * >	fPositionFactories
	The list of available position factories;. More...

EDepSim::VPositionFactory *	fPosition
	The current position factory. More...

std::map< G4String, EDepSim::VTimeFactory * >	fTimeFactories
	The list of available time factories;. More...

EDepSim::VTimeFactory *	fTime
	The current time factory. More...

G4UIdirectory *	fDir

G4UIdirectory *	fKinematicsDir

G4UIdirectory *	fCountDir

G4UIdirectory *	fPositionDir

G4UIdirectory *	fTimeDir

G4UIcmdWithoutParameter *	fClearCMD

G4UIcmdWithoutParameter *	fAddCMD

G4UIcommand *	fCombineCMD

G4UIcmdWithAString *	fSetKinematicsCMD

G4UIcmdWithAString *	fSetCountCMD

G4UIcmdWithAString *	fSetPositionCMD

G4UIcmdWithAString *	fSetTimeCMD

G4UIcmdWithABool *	fAllowEmptyEventsCMD

G4UIcmdWithABool *	fAddFakeGeantinoCMD

G4UIcmdWithABool *	fAllowPartialEventsCMD

Detailed Description

Definition at line 25 of file EDepSimUserPrimaryGeneratorMessenger.hh.

Constructor & Destructor Documentation

EDepSim::UserPrimaryGeneratorMessenger::UserPrimaryGeneratorMessenger ( EDepSim::UserPrimaryGeneratorAction * gen )

Definition at line 40 of file EDepSimUserPrimaryGeneratorMessenger.cc.

     : fAction(gen) {
 
     /////////////////////////////////////////
     // The directories must be created first.
     /////////////////////////////////////////
 
     fDir = new G4UIdirectory("/generator/");
     fDir->SetGuidance("Control of the particle generator.");
 
     fCountDir = new G4UIdirectory("/generator/count/");
     fCountDir->SetGuidance("Control number of primary vertices per event.");
 
     fKinematicsDir = new G4UIdirectory("/generator/kinematics/");
     fKinematicsDir->SetGuidance("Control kinematics generators.");
 
     fPositionDir = new G4UIdirectory("/generator/position/");
     fPositionDir->SetGuidance("Control vertex position the generators.");
 
     fTimeDir = new G4UIdirectory("/generator/time/");
     fTimeDir->SetGuidance("Control vertex time the generators.");
 
     /////////////////////////////////////////
     // The factories must be created after the directories.
     /////////////////////////////////////////
 
     AddKinematicsFactory(new EDepSim::GPSKinematicsFactory(this));
     AddKinematicsFactory(new EDepSim::NuMIRockKinematicsFactory(this));
     AddKinematicsFactory(new EDepSim::RooTrackerKinematicsFactory(this));
 
     AddCountFactory(new EDepSim::FixedCountFactory(this));
     AddCountFactory(new EDepSim::MeanCountFactory(this));
 
     AddPositionFactory(new EDepSim::FreePositionFactory(this));
     AddPositionFactory(new EDepSim::FixedPositionFactory(this));
     AddPositionFactory(new EDepSim::UniformPositionFactory(this));
     AddPositionFactory(new EDepSim::DensityPositionFactory(this));
 
     AddTimeFactory(new EDepSim::FixedTimeFactory(this));
     AddTimeFactory(new EDepSim::FreeTimeFactory(this));
     AddTimeFactory(new EDepSim::SpillTimeFactory(this));
 
     /////////////////////////////////////////
     // The UI commands must be created after the factories.
     /////////////////////////////////////////
 
     fClearCMD = new G4UIcmdWithoutParameter("/generator/clear",this);
     fClearCMD->SetGuidance("Clear the current list of vertex generators.");
 
     fAddCMD = new G4UIcmdWithoutParameter("/generator/add",this);
     fAddCMD->SetGuidance("Add a generator using the current factories.");
 
     fCombineCMD = new G4UIcommand("/generator/combine",this);
     fCombineCMD->SetGuidance("Combine the previous two vertices into one.");
     fCombineCMD->SetParameter(new G4UIparameter("src",'i',false));
     fCombineCMD->SetParameter(new G4UIparameter("dest",'i',false));
     fCombineCMD->SetParameter(new G4UIparameter("relative",'b',true));
     fCombineCMD->GetParameter(2)->SetDefaultValue("false");
 
     fSetKinematicsCMD
         = new G4UIcmdWithAString("/generator/kinematics/set",this);
     fSetKinematicsCMD->SetGuidance("Set the current kinematics factory.");
     fSetKinematicsCMD->SetParameterName("Factory",false);
     fSetKinematicsCMD->SetCandidates(GetKinematicsFactories());
 
     fSetCountCMD
         = new G4UIcmdWithAString("/generator/count/set",this);
     fSetCountCMD->SetGuidance("Set the current count factory.");
     fSetCountCMD->SetParameterName("Factory",false);
     fSetCountCMD->SetCandidates(GetCountFactories());
 
     fSetPositionCMD
         = new G4UIcmdWithAString("/generator/position/set",this);
     fSetPositionCMD->SetGuidance("Set the current position factory.");
     fSetPositionCMD->SetParameterName("Factory",false);
     fSetPositionCMD->SetCandidates(GetPositionFactories());
 
     fSetTimeCMD
         = new G4UIcmdWithAString("/generator/time/set",this);
     fSetTimeCMD->SetGuidance("Set the current time factory.");
     fSetTimeCMD->SetParameterName("Factory",false);
     fSetTimeCMD->SetCandidates(GetTimeFactories());
 
     fAllowEmptyEventsCMD
         = new G4UIcmdWithABool("/generator/allowEmptyEvents",this);
     fAllowEmptyEventsCMD->SetGuidance("If true, then generate events even"
                                       " if they don't contain a vertex.");
 
     fAddFakeGeantinoCMD
         = new G4UIcmdWithABool("/generator/addFakeGeantino",this);
     fAddFakeGeantinoCMD->SetGuidance("If true, then guarantee a primary vertex"
                                      " by adding a geantino.");
 
     fAllowPartialEventsCMD
         = new G4UIcmdWithABool("/generator/allowPartialEvents",this);
     fAllowEmptyEventsCMD->SetGuidance("If true, then generate the final event"
                                       " even if it ran out of interactions"
                                       " in the input kinematics file.");
 
     //////////////////////////////////
     // Set default values for the factories.
     SetKinematicsFactory("gps");
     SetCountFactory("fixed");
     SetPositionFactory("free");
     SetTimeFactory("fixed");
 
 }

EDepSim::UserPrimaryGeneratorMessenger::~UserPrimaryGeneratorMessenger ( )

virtual

Definition at line 149 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                      {
     delete fDir;
     delete fCountDir;
     delete fKinematicsDir;
     delete fPositionDir;
     delete fTimeDir;
     delete fClearCMD;
     delete fAddCMD;
     delete fCombineCMD;
     delete fSetKinematicsCMD;
     delete fSetCountCMD;
     delete fSetPositionCMD;
     delete fSetTimeCMD;
     delete fAllowEmptyEventsCMD;
     delete fAddFakeGeantinoCMD;
     delete fAllowPartialEventsCMD;
 }

Member Function Documentation

void EDepSim::UserPrimaryGeneratorMessenger::AddCountFactory ( EDepSim::VCountFactory * factory )

Add a new count factory to the messenger.

Definition at line 264 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                    {
     fCountFactories[factory->GetName()] = factory;
 }

void EDepSim::UserPrimaryGeneratorMessenger::AddKinematicsFactory ( EDepSim::VKinematicsFactory * factory )

Add a new kinematics factory to the messenger.

Definition at line 235 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                         {
     fKinematicsFactories[factory->GetName()] = factory;
 }

void EDepSim::UserPrimaryGeneratorMessenger::AddPositionFactory ( EDepSim::VPositionFactory * factory )

Add a new position factory to the messenger.

Definition at line 293 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                       {
     fPositionFactories[factory->GetName()] = factory;
 }

void EDepSim::UserPrimaryGeneratorMessenger::AddTimeFactory ( EDepSim::VTimeFactory * factory )

Add a new time factory to the messenger.

Definition at line 322 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                   {
     fTimeFactories[factory->GetName()] = factory;
 }

EDepSim::PrimaryGenerator * EDepSim::UserPrimaryGeneratorMessenger::CreateGenerator ( )

Create a new generator using the current generator factories.

Definition at line 217 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                       {
     EDepSim::VKinematicsGenerator* kine = fKinematics->GetGenerator();
     EDepSim::VCountGenerator* count = fCount->GetGenerator();
     EDepSim::VPositionGenerator* position = fPosition->GetGenerator();
     EDepSim::VTimeGenerator* time = fTime->GetGenerator();
     EDepSim::PrimaryGenerator* gen
         = new EDepSim::PrimaryGenerator(kine,count,position,time);
     EDepSimLog("#############################################");
     EDepSimLog("# Create a new EDepSim_PrimaryGenerator: "
              << gen->GetName());
     EDepSimLog("#############################################");
     return gen;
 }

G4String EDepSim::UserPrimaryGeneratorMessenger::GetCountFactories ( )

Get the list of count factories available to the messenger.

Definition at line 282 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                  {
     G4String list = "";
     for (std::map<G4String,EDepSim::VCountFactory*>::const_iterator p
              = fCountFactories.begin();
          p != fCountFactories.end();
          ++p) {
         list = list + p->first + " ";
     }
     return list;
 }

G4String EDepSim::UserPrimaryGeneratorMessenger::GetKinematicsFactories ( )

Get the list of kinematics factories available to the messenger.

Definition at line 253 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                       {
     G4String list = "";
     for (std::map<G4String,EDepSim::VKinematicsFactory*>::const_iterator p
              = fKinematicsFactories.begin();
          p != fKinematicsFactories.end();
          ++p) {
         list = list + p->first + " ";
     }
     return list;
 }

G4String EDepSim::UserPrimaryGeneratorMessenger::GetPath ( )

Get the base directory for the messenger commands.

Definition at line 231 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                        {
     return fDir->GetCommandPath();
 }

G4String EDepSim::UserPrimaryGeneratorMessenger::GetPositionFactories ( )

Get the list of position factories available to the messenger.

Definition at line 311 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                     {
     G4String list = "";
     for (std::map<G4String,EDepSim::VPositionFactory*>::const_iterator p
              = fPositionFactories.begin();
          p != fPositionFactories.end();
          ++p) {
         list = list + p->first + " ";
     }
     return list;
 }

G4String EDepSim::UserPrimaryGeneratorMessenger::GetTimeFactories ( )

Get the list of time factories available to the messenger.

Definition at line 340 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                 {
     G4String list = "";
     for (std::map<G4String,EDepSim::VTimeFactory*>::const_iterator p
              = fTimeFactories.begin();
          p != fTimeFactories.end();
          ++p) {
         list = list + p->first + " ";
     }
     return list;
 }

void EDepSim::UserPrimaryGeneratorMessenger::SetCountFactory ( const G4String & factory )

Set the current count factory for the messenger.

Definition at line 269 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                           {
     std::map<G4String,EDepSim::VCountFactory*>::const_iterator p
         = fCountFactories.find(name);
     if (p != fCountFactories.end()) {
         fCount = p->second;
         EDepSimLog("  Count factory set to: " << fCount->GetName());
     }
     else {
         EDepSimThrow("  Illegal count factory name.");
     }
 }

void EDepSim::UserPrimaryGeneratorMessenger::SetKinematicsFactory ( const G4String & factory )

Set the current kinematics factory for the messenger.

Definition at line 240 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                           {
     std::map<G4String,EDepSim::VKinematicsFactory*>::const_iterator p
         = fKinematicsFactories.find(name);
     if (p != fKinematicsFactories.end()) {
         fKinematics = p->second;
         EDepSimLog("  Kinematics factory set to: " << fKinematics->GetName());
     }
     else {
         EDepSimThrow("  Illegal kinematics factory name.");
     }
 }

void EDepSim::UserPrimaryGeneratorMessenger::SetNewValue	(	G4UIcommand *	command,
		G4String	newValue
	)

Handle messages from the UI processor.

Definition at line 167 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                                                                        {
     if (command == fClearCMD) {
         fAction->ClearGenerators();
     }
     else if (command == fAddCMD) {
         EDepSim::PrimaryGenerator* generator = CreateGenerator();
         fAction->AddGenerator(generator);
     }
     else if (command == fCombineCMD) {
         int src, dest;
         std::string relative;
         std::istringstream is(newValue);
         is >> src >> dest >> relative;
         EDepSim::CombinationGenerator* generator
             = new EDepSim::CombinationGenerator(
                 src,dest,G4UIcommand::ConvertToBool(relative.c_str()));
         fAction->AddGenerator(generator);
     }
     else if (command == fSetKinematicsCMD) {
         SetKinematicsFactory(newValue);
     }
     else if (command == fSetCountCMD) {
         SetCountFactory(newValue);
     }
     else if (command == fSetPositionCMD) {
         SetPositionFactory(newValue);
     }
     else if (command == fSetTimeCMD) {
         SetTimeFactory(newValue);
     }
     else if (command == fAllowEmptyEventsCMD) {
         fAction->SetAllowEmptyEvents(
             fAllowEmptyEventsCMD->GetNewBoolValue(newValue));
     }
     else if (command == fAddFakeGeantinoCMD) {
         fAction->SetAddFakeGeantino(
             fAddFakeGeantinoCMD->GetNewBoolValue(newValue));
     }
     else if (command == fAllowPartialEventsCMD) {
         fAction->SetAllowPartialEvents(
             fAllowPartialEventsCMD->GetNewBoolValue(newValue));
     }
     else {
         EDepSimThrow("EDepSim::UserPrimaryGeneratorMessenger:: "
                     "Unimplemented command");
     }
 }

void EDepSim::UserPrimaryGeneratorMessenger::SetPositionFactory ( const G4String & factory )

Set the current position factory for the messenger.

Definition at line 298 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                           {
     std::map<G4String,EDepSim::VPositionFactory*>::const_iterator p
         = fPositionFactories.find(name);
     if (p != fPositionFactories.end()) {
         fPosition = p->second;
         EDepSimLog("  Position factory set to: " << fPosition->GetName());
     }
     else {
         EDepSimThrow("  Illegal position factory name.");
     }
 }

void EDepSim::UserPrimaryGeneratorMessenger::SetTimeFactory ( const G4String & factory )

Set the current time factory for the messenger.

Definition at line 327 of file EDepSimUserPrimaryGeneratorMessenger.cc.

                           {
     std::map<G4String,EDepSim::VTimeFactory*>::const_iterator p
         = fTimeFactories.find(name);
     if (p != fTimeFactories.end()) {
         fTime = p->second;
         EDepSimLog("  Time factory set to: " << fTime->GetName());
     }
     else {
         EDepSimThrow("  Illegal time factory name.");
     }
 }