#include <EDepSimSpillTimeFactory.hh>

Inheritance diagram for EDepSim::SpillTimeFactory:

Public Member Functions
	SpillTimeFactory (EDepSim::UserPrimaryGeneratorMessenger *parent)

virtual	~SpillTimeFactory ()

EDepSim::VTimeGenerator *	GetGenerator ()

void	SetSpillTime (double spillTime)

void	SetBunchCount (int bunchs)
	Set the number of bunchs (and reset the bunch power) in a spill. More...

void	SetBunchSeparation (double sep)

void	SetBunchLength (double length)

void	SetBunchPower (int bunch, double power)

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

Public Member Functions inherited from EDepSim::VTimeFactory
	VTimeFactory (G4String name, EDepSim::UserPrimaryGeneratorMessenger *fParent, bool makeDirectory=true)

virtual	~VTimeFactory ()

Public Member Functions inherited from EDepSim::VPrimaryFactory
	VPrimaryFactory (G4String subdir, G4String name, EDepSim::UserPrimaryGeneratorMessenger *parent, bool makeDirectory)

virtual	~VPrimaryFactory ()

G4String	GetPath () const

G4String	GetName () const

G4String	GetSubDir () const

Private Attributes
double	fSpillTime
	The start time of the spill. More...

double	fBunchSeparation
	The bunch separation. More...

double	fBunchLength
	The bunch length. More...

std::vector< double >	fBunchPower
	The power in each bunch. More...

G4UIcmdWithADoubleAndUnit *	fSpillTimeCMD

G4UIcmdWithADoubleAndUnit *	fBunchSepCMD

G4UIcmdWithADoubleAndUnit *	fBunchLengthCMD

G4UIcmdWithAnInteger *	fBunchCountCMD

G4UIcommand *	fBunchPowerCMD

Additional Inherited Members
Protected Member Functions inherited from EDepSim::VPrimaryFactory
G4String	CommandName (G4String cmd)
	Build a command name with the directory prefix. More...

Detailed Description

Definition at line 11 of file EDepSimSpillTimeFactory.hh.

Constructor & Destructor Documentation

EDepSim::SpillTimeFactory::SpillTimeFactory ( EDepSim::UserPrimaryGeneratorMessenger * parent )

Definition at line 11 of file EDepSimSpillTimeFactory.cc.

     : EDepSim::VTimeFactory("spill",parent),
       fSpillTime(100*ns), 
       fBunchSeparation(582*ns),
       fBunchLength(12.4*ns) {
     
     fSpillTimeCMD = new G4UIcmdWithADoubleAndUnit(CommandName("start"),this);
     fSpillTimeCMD->SetGuidance("Set the start time of the spill.");
     fSpillTimeCMD->SetParameterName("time",false);
     fSpillTimeCMD->SetUnitCategory("Time");
 
     fBunchSepCMD = new G4UIcmdWithADoubleAndUnit(CommandName("bunchSep"),this);
     fBunchSepCMD->SetGuidance("Set the time between bunch starts.");
     fBunchSepCMD->SetParameterName("time",false);
     fBunchSepCMD->SetUnitCategory("Time");
 
     fBunchLengthCMD = new G4UIcmdWithADoubleAndUnit(CommandName("bunchLength"),
                                                     this);
     fBunchLengthCMD->SetGuidance("Set the length of a bunch.");
     fBunchLengthCMD->SetParameterName("time",false);
     fBunchLengthCMD->SetUnitCategory("Time");
 
     fBunchCountCMD = new G4UIcmdWithAnInteger(CommandName("bunchCount"),
                                               this);
     fBunchCountCMD->SetGuidance("Set the number of bunchs in a spill.  "
                                 "Reset bunch power to default.");
     fBunchCountCMD->SetParameterName("count",false);
 
     fBunchPowerCMD = new G4UIcommand(CommandName("bunchPower"),this);
     fBunchPowerCMD->SetGuidance("Set the power in a bunch "
                                 "(bunchs are numbered from ONE)");
     G4UIparameter* bunchPar = new G4UIparameter('i');
     bunchPar->SetParameterName("bunch");
     fBunchPowerCMD->SetParameter(bunchPar);
     G4UIparameter* powerPar = new G4UIparameter('d');
     powerPar->SetParameterName("power");
     fBunchPowerCMD->SetParameter(powerPar);
     
     //Initialize the bunchs
     SetBunchCount(6);
 
 }

EDepSim::SpillTimeFactory::~SpillTimeFactory ( )

virtual

Definition at line 55 of file EDepSimSpillTimeFactory.cc.

                                            {
     delete fSpillTimeCMD;
     delete fBunchSepCMD;
     delete fBunchLengthCMD;
     delete fBunchCountCMD;
     delete fBunchPowerCMD;
 }

Member Function Documentation

EDepSim::VTimeGenerator * EDepSim::SpillTimeFactory::GetGenerator ( )

virtual

Return the spill time generator. The spill parameters must be set before this is called.

Implements EDepSim::VTimeFactory.

Definition at line 86 of file EDepSimSpillTimeFactory.cc.

                                                              {
     EDepSim::VTimeGenerator* time = new EDepSim::SpillTimeGenerator(
         GetName(),fSpillTime,fBunchSeparation,fBunchLength,fBunchPower);
     return time;
 }

void EDepSim::SpillTimeFactory::SetBunchCount ( int bunchs )

Set the number of bunchs (and reset the bunch power) in a spill.

Definition at line 92 of file EDepSimSpillTimeFactory.cc.

                                                       {
     fBunchPower.resize(bunchs);
     for (std::vector<double>::iterator b = fBunchPower.begin();
          b != fBunchPower.end();
          ++b) {
         *b = 1.0;
     }
 }

void EDepSim::SpillTimeFactory::SetBunchLength ( double length )

inline

Set the bunch length. This is the length of a bunch, and determines the end of the bunch with respect to the start. The start of the bunch is determined by the spill time, and the bunch separation. The bunch is modeled as a Gaussian with a sigma set to the Bunch Length.

Definition at line 36 of file EDepSimSpillTimeFactory.hh.

36 {fBunchLength=length;}

EDepSim::SpillTimeFactory::fBunchLength

double fBunchLength

The bunch length.

Definition: EDepSimSpillTimeFactory.hh:53

void EDepSim::SpillTimeFactory::SetBunchPower	(	int	bunch,
		double	power
	)

Set the power for a bunch. The bunchs are numbered from ONE, and the nominal (default) power in a bunch is 1.0.

Definition at line 101 of file EDepSimSpillTimeFactory.cc.

                                                                    {
     if (bunch<1 || (unsigned) bunch > fBunchPower.size()) {
         EDepSimError("Illegal bunch number: " << bunch);
         EDepSimError("Invalid bunch structure");
     }
     fBunchPower[bunch-1] = power;
 }

void EDepSim::SpillTimeFactory::SetBunchSeparation ( double sep )

inline

Set the bunch separation. This is the time between the start of successive bunches.

Definition at line 30 of file EDepSimSpillTimeFactory.hh.

30 {fBunchSeparation=sep;}

EDepSim::SpillTimeFactory::fBunchSeparation

double fBunchSeparation

The bunch separation.

Definition: EDepSimSpillTimeFactory.hh:50

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

virtual

Handle messages from the UI processor.

Reimplemented from EDepSim::VPrimaryFactory.

Definition at line 63 of file EDepSimSpillTimeFactory.cc.

                                                               {
     if (command == fSpillTimeCMD) {
         SetSpillTime(fSpillTimeCMD->GetNewDoubleValue(newValue));
     }
     else if (command == fBunchSepCMD) {
         SetBunchSeparation(fBunchSepCMD->GetNewDoubleValue(newValue));
     }
     else if (command == fBunchLengthCMD) {
         SetBunchLength(fBunchLengthCMD->GetNewDoubleValue(newValue));
     }
     else if (command == fBunchCountCMD) {
         SetBunchCount(fBunchCountCMD->GetNewIntValue(newValue));
     }
     else if (command == fBunchPowerCMD) {
         std::istringstream input((char*)newValue.c_str());
         int bunch;
         double power;
         input >> bunch >> power;
         SetBunchPower(bunch,power);
     }
 }

void EDepSim::SpillTimeFactory::SetSpillTime ( double spillTime )

inline

Set the spill time. The spill time is the offset of start of the first bunch with respect to zero. This is the time that the bunch will cross the center of the EDepSim:: hall.

Definition at line 23 of file EDepSimSpillTimeFactory.hh.

23 {fSpillTime=spillTime;}

EDepSim::SpillTimeFactory::fSpillTime

double fSpillTime

The start time of the spill.

Definition: EDepSimSpillTimeFactory.hh:47

Member Data Documentation

G4UIcmdWithAnInteger* EDepSim::SpillTimeFactory::fBunchCountCMD

private

Definition at line 61 of file EDepSimSpillTimeFactory.hh.

double EDepSim::SpillTimeFactory::fBunchLength

private

The bunch length.

Definition at line 53 of file EDepSimSpillTimeFactory.hh.

G4UIcmdWithADoubleAndUnit* EDepSim::SpillTimeFactory::fBunchLengthCMD

private

Definition at line 60 of file EDepSimSpillTimeFactory.hh.

std::vector<double> EDepSim::SpillTimeFactory::fBunchPower

private

The power in each bunch.

Definition at line 56 of file EDepSimSpillTimeFactory.hh.

G4UIcommand* EDepSim::SpillTimeFactory::fBunchPowerCMD

private

Definition at line 62 of file EDepSimSpillTimeFactory.hh.

double EDepSim::SpillTimeFactory::fBunchSeparation

private

The bunch separation.

Definition at line 50 of file EDepSimSpillTimeFactory.hh.

G4UIcmdWithADoubleAndUnit* EDepSim::SpillTimeFactory::fBunchSepCMD

private

Definition at line 59 of file EDepSimSpillTimeFactory.hh.

double EDepSim::SpillTimeFactory::fSpillTime

private

The start time of the spill.

Definition at line 47 of file EDepSimSpillTimeFactory.hh.

G4UIcmdWithADoubleAndUnit* EDepSim::SpillTimeFactory::fSpillTimeCMD

private

Definition at line 58 of file EDepSimSpillTimeFactory.hh.

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

edep-sim/src/kinem/EDepSimSpillTimeFactory.hh
edep-sim/src/kinem/EDepSimSpillTimeFactory.cc

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation