# Presentation: 305724

## Tuesday, Nov 9th

- 9:30-12:30
- Visualization attributes
- Physics processes
- 14:00-17:00
- Kinematics and event generation (from yesterday)
- Particle gun
- Boolean solids (?)

## Visualization Attributes

- Visualization attributes are a set of information associated with objects which can be visualized
- This information is just used for visualization and it is not included in the geometrical information such as shapes, position and orientation
- A set of visualization attributes is held by an object of class G4VisAttributes

## Visibility

- Visibility is a boolean flag used to control the visibility of the objects passed to the Visualization Manager for visualization
- Visibility is set by:
- G4VisAttributes::SetVisibility(G4bool visibility);
- If visibility=false, visualization is skipped for those objects to which this set of attributes is assigned
- The following public data member is by default defined
- static const G4VisAttributes Invisible
- This can be referred at as G4VisAttributes::Invisible
- experimentalHall_log->SetVisAttributes(G4VisAttributes::Invisible);

## Color

- G4VisAttributes holds its color entry as an object of the class G4Colour
- G4Colour has four field which represent the RGBA (red,green,blue,alpha) of a color. Each component takes a value between 0 and 1. Alpha is the opacity, not used in the present version
- A G4Colour object is created by giving the red, blue and green components of the color
- G4Color( 	G4double red=1.0,G4double green=1.0,G4double blue=1.0,
- 			G4double a=1.0);
- The default value of each component is 1, which means white

## Color (2)

- G4Colour white 	()		;      	// white
- G4Colour white	(1.,1.,1.)		;      	// white
- G4Colour gray	(.5,.5,.5)		;	// gray
- G4Colour black	(0.,0.,0.)		;	// black
- G4Colour red	(1.,0.,0.)		;	// red
- G4Colour green	(0.,1.,0.)		;	// green
- G4Colour blue	(0.,0.,1.)		;	// blue
- G4Colour cyan	(0.,1.,1.)		;	// cyan
- G4Colour magenta	(1.,0.,1.)		;	// magenta
- G4Colour yellow	(1.,1.,0.)		;	// yellow

## Color (3)

- One can set the RGBA components directly into G4VisAttributes
- void G4VisAttributes::SetColour (	G4double red,
- 						G4double green,
- 						G4double blue,
- 						G4double alpha=1.0);
- The following G4VisAttributes constructor is also supported
- G4VisAttributes::G4VisAttributes(const G4Colour& color);

## Forced wireframe and forced solid styles

- Several drawing styles can be selected for the volumes. For instance, one can select to visualize detector components in “wireframe” or with “surfaces”. In the former, only the edges of the detector are drawn, so the detector looks transparent. In the latter, the detector looks opaque with shading effects
- The forced wireframe and forced solid styles make it possible to mix wireframe and solid visualization. For instance, one can make the mother volume transparent and still look inside when in “solid” mode
- Forced wireframe and forced solid are available via:
- void G4VisAttributes::SetForceWireframe(G4bool force);
- void G4VisAttributes::SetForceSolid(G4bool force);

## Constructors for G4VisAttributes

- The following constructors are supported for G4VisAttributes
- G4VisAttributes();
- G4VisAttributes(G4bool visibility);
- G4VisAttributes(const G4Colour& colour);
- G4VisAttributes(G4bool visibility, const G4Colour& colour);

## How to assign G4VisAttributes to a volume

- In constructing the detector components, one may assign a set of visualization attributes to each Logical Volume in order to visualize it later
- G4LogicalVolume holds a pointer to a G4VisAttributes. This field is set and referenced by using:
- void G4LogicalVolume::SetVisAttributes(const G4VisAttributes* pVa);
- void G4LogicalVolume::SetVisAttributes(const G4VisAttributes& Va);
- If you want to display you experimental hall in cyan and in forced wireframe style you do:
- ExpHall_log=new G4LogicalVolume(ExpHall_box,Air,”exp_hall”);
- .....
- G4VisAttributes *expHallVisAtt=new G4VisAttributes(G4Colour(0.,1.,1.));
- expHallVisAtt->SetForceWireframe(true);
- ExpHall_log->SetVisAttributes(expHallVisAtt);

## Particles and physics processes

## G4VUserPhysicsList

- The G4VUserPhysicsList class is the base class which one has to derive from to specify all particles and physics processes to be used in the simulation
- The user must inherit from G4VUserPhysicsList and implement three methods:
- ConstructParticle()		Particle Construction
- ConstructPhysics()		Physics processes
- SetCuts()			Cut values (in stopping range)

## Particles

- Geant4 provides a set of ordinary particles such as electron, proton, gamma etc.
- The G4ParticleDefinition class provides a representation of a particle. Each particle has its own class derived from it
- G4ParticleDefinition contains properties which characterize individual particles such as name, mass, charge, spin... Except for lifetime, decay table and the “stable” flag, this attributes are read-only and cannot be changed without re-building the libraries
- There are 6 major particle classes:
- 	leptons			bosons
- 	mesons			shortlived
- 	baryons			ions

## Particles (2)

- Each particle is represented by its own class
- Each particle class has only one static object (singleton)
- G4Electron represents the electron
- G4Electron::theElectron is the only object of the G4Electron class
- A pointer to the electron object can be obtained by using the static method G4Electron::ElectronDefinition()
- The class G4ParticleTable is a collection of defined particles. It provides a series of utility methods to retrieve particle definitions:
- FindParticle(G4String name)	find the particle by name
- FindParticle(G4int PDGencoding)	find the particle by its PDG code
- G4ParticleTable is a singleton and the static method G4ParticleTable::GetParticleTable() returns its pointer

## Particles (3)

- Particles are static objects belonging to the individual particle classes
- As such, these object will automatically instanciated before main() is executed
- However, one must explicitly declare the particle classes somewehre in the program, otherwise the compiler cannot recognize these classes and no particle object will be available

## Particle construction

- The ConstructParticle() method from G4VUserPhysicsList must be implemented by the user to create all particles which are needed in the simulation
- Utility classes provided to define all particles of the same types in Geant4.

- #include “G4Geantino.hh”
- #include “G4Electron.hh”
- #include “MyPhysicsList.hh”
- void MyPhysicsList::ConstructParticle()
- {
- 	G4Geantino::GeantinoDefinition();
- 	G4Electron::ElectronDefinition();
- }

- void MyPhysicsList::ConstructLeptons()
- {
- // Construct all leptons
- G4LeptonConstructor pConstructor;
- pConstructor.ConstructParticle();
- }

## Setting cuts

- SetCuts(G4double cut) is a virtual method of the class G4VUserPhisicsList to be implemented in order to set the cut in range for each particle
- Construction of geometry, particles and processes should precede the invocation of SetCuts()
- By means of SetCuts(), the cut in range is then converted to the cut-off energy for all materials defined in the geometry
- G4VUserPhysicsList keeps a defaultCutValue as the default cut off value for the range. A method SetCutsWithDefault() is invoked by the G4RunManager for all normal applications and this default value is passed to the argument of the SetCuts() method

## Setting cuts (2)

- The default cut value is 1mm in all cases. Its value can be changed directly in the constructor of the class you inherit from G4VPhysicsList or by using the SetDefaultCutValue() method
- The cut value can be retrieved by using the method
- GetLengthCuts()
- whilst the cut-off energy for each material can be obtained by invoking
- GetEnergyThreshold(G4Material *)
- If you want to set different cut values for different particles, you must respect a specific definition order, as some particles depend on some other particle’s cut value for calculating the cross-sections
- gamma electron prositron proton/antiproton others

## Setting cuts (3)

- To ease the implementation of the SetCuts() method, the G4VUserPhysicsList class provides some utility methods
- SetCutValue(G4double cut_value, G4String particle_name)
- SetCutValueForOthers(G4double cut_value)
- SetCutValueForOtherThan(G4double cut, G4ParticleDefinition* particle)
- An example of implementation
- void MyPhysicsList::SetCuts(G4double cut)
- {
- 	SetCutValue(cut,”gamma”);
- 	SetCutValue(cut,”e+”);
- 	SetCutValue(cut,”e-”);
- 	SetCutValue(cut,”proton”);
- 	SetCutValueForOthers(cut);
- }

## Production threshold vs tracking cut

- It is the responsibility of each individual process to produce secondary particles according to its own capabilities. On the other hand, only the Geant4 kernel can ensure an overall coherence of the whole simulation
- hence, as general principle
- Each _process_ has its intrinsic limits to produce secondary particles
- All particles produced will be tracked up to _zero range_
- Each particle has a suggested cut in range (converted to an energy cut for all materials)
- The results of this is that the cut associated to each particle is a (recommended) production threshold on secondary particles

## Production below threshold

- A process can still decide to produce secondary particles even below the recommended production threshold
- if, by checking the range of the secondary produced against quantities like safety (~the distance to the next boundary), it turns out that the particle, even below threshold, might reach a sensitive part of the detector
- when mass-to-energy conversion can occur, to conserve the energy. For instance, in gamma conversion, the positron is always produced, even at 0 energy, for further annihilation

## Physics Processes

- Physics processes describe the interaction of particles with matter
- In Geant4 there are 7 major categories of physics processes
- electromagnetic
- hadronic
- transportation
- decay
- optical
- photolepton_hadron
- parameterisation

## Physics Processes (2)

- A class G4VProcess is provided as the base class for all physics processes
- All physics processes are described by using three (virtual) methods:
- AtRestDoIt()
- AlongStepDoIt()
- PostStepDoIt()
- The following classes are then used as base classes for simple processes
- G4VAtRestProcess		Process with AtRestDoIt() only
- G4VContinuousProcess	Process with AlongStepDoIt only
- G4VDiscreteProcess	Process with PostStepDoIt
- 4 additional classes (such as G4VContinuousDiscreteProcess) are provided for complex processes

## G4ProcessManager

- G4ProcessManager is a member of G4ParticleDefinition
- G4ProcessManager keeps a list of processes a particle can undergo. Moreover, it keeps the information on the order of invocation of the processes as well as which kind of DoIt method is valid for which process
- Physics processes should be registered with the G4ProcessManager of each particle (together with ordering information) by using AddProcess() and SetProcessOrdering(). For registering simple processes, one can use AddAtRestProcess(), AddContinuousProcess() and AddDiscreteProcess()
- The G4ProcessManager has the possibility of switching on/off some processes at run time by using ActivateProcess() and InActivateProcess()

## AddTransportation()

- Transportation (propagating particles in space) is treated as a process, hence it must be defined for all particles
- The G4Transportation class must be registered with all particle classes. An AddTransportation() method is provided in G4VUserPhysicsList and it must be called in ConstructPhysics()
- void G4VUserPhysicsList::AddTransportation() {
- 	G4Transportation* theTransportation=new G4Transportation;
- 	theParticleIterator->reset();
- 	while ( (*theParticleIterator) () ) {
- 		G4ParticleDefinition *particle=theParticleIterator->value();
- 		G4ProcessManager* pmanager=particle->GetProcessManager();
- 		if (!particle->IsShortLived()) {
- 			pmanager->AddProcess(theTransportationProcess);
- 			pmanager->SetProcessOrderingToFirst(theTransportationProcess,idxAlongStep);
- 		}
- 	}
- }

## ConstructProcess()

- ConstructProcess() is a pure virtual method  which is used to create physics processes and register them to particles
- For each particle which has been declared in ConstructParticle(), the user must get hold of the G4ProcessManager attached to the particle and register all relevant physics processes by using the AddProcess(G4VProcess *) method

## ConstructProcess for a geantino

- A geantino is a geometrical probe, only the transportation process must be registered with it
- Void ExN01PhysicsList::ConstructProcess()
- {
- 	AddTransportation();
- }

## ConstructProcess for gammas

- Void MyPhysicsList::ConstructProcess()
- {
- 	AddTransportation();
- 	ConstructEM();
- }
- void MyPhysicsList::ConstructEM()
- {
- 	G4ParticleDefinition* particle = G4Gamma::GammaDefinition();
- 	G4ProcessMAnager *pmanager= particle->GetProcessManager();
- 	G4PhotoElectricEffect *thePhotoElectricEffect = new G4PhotoElectricEffect;
- 	G4ComptonScattering *theComptonScattering = new G4ComptonScattering;
- 	G4GammaConversion *theGammaConversion = new G4GammaConversion;
- 	pmanager->AddDiscreteProcess(thePhotoElectricEffect);
- 	pmanager->AddDiscreteProcess(theComptonScattering);
- 	pmanager->AddDiscreteProcess(theGammaConversion);
- }

## Physics

- The aim of the exercise is to add particles and physics processes and to define cuts for these particles in the physics list
- go into PhysicsPhysicsList and add geantino, electron, positron, mu+ and mu- into ConstructParticles()
- go into CostructProcess() and add processes for the particles you just defined
- geantinos only need transportation
- electrons need the multiple scattering (G4MultipleScattering), the ionisation (G4eIonisation), the bremsstrahlung (G4eBremsstrahlung) to be added. In the case of positron, add the annihilation (G4eplusAnnihilation)
- add processes for the muons too (G4MultipleScattering, G4MuIonisation, G4MuBremsstrahlung, G4MuPairProduction)
- Add cuts for these particles in SetCuts()

## Physics (2)

- Use ExampleN02 for reference (but don’t copy&paste into the blue, try and understand what is happening)
- To find a particle into the particle table, use either the particle iterator or the FindParticle() method
- Shoot an electron (we are using the same geometry as in the Frame example). See if a shower develops in the calorimeter
- For displaying the tracks, copy ExN02EventAction.hh and .cc from the N02 example and register an object of it with the G4RunManager (in the main()) by using the SetUserAction() method

## Kinematics

## G4VUserPrimaryGeneratorAction

- G4VUserPrimaryGeneratorAction is one of the mandatory classes the user has to derive a concrete class from
- In the concrete class, one must specify how the primary event should be generated
- The actual generation of the primary particles will be performed in a concrete class derived from G4VPrimaryGenerator
- The class inherited from G4VPrimaryGenerator must implement the method:
- GeneratePrimaryVertex(G4Event *evt)

## An example of PrimaryGeneratorAction

- #ifndef MyPrimaryGeneratorAction_H
- #define MyPrimaryGeneratorAction_H
- #include “G4VUserPrimaryGeneratorAction.hh”
- class MyTestBeam;
- class Event;
- class MyPrimaryGeneratorAction: public G4VUserPrimaryGeneratorAction{
- public:
- 	MyPrimaryGeneratorAction();
- 	~MyPrimaryGeneratorAction();
- 	void GeneratePrimaries(G4Event* anEvent);
- private:
- 	MyTestBeam *tBeam;
- };
- #endif

## An example of PrimaryGeneratorAction (2)

- #include “MyPrimaryGeneratorAction.hh”
- #include “G4Event.hh”
- #include “MyTestBeam.hh”
- #include “G4ThreeVector.hh”
- #include “G4Geantino.hh”
- #include “globals.hh”
- MyPrimaryGeneratorAction::MyPrimaryGeneratorAction()
- {
- 		tBeam=new MyTestBeam();
- }

## An example of PrimaryGeneratorAction (3)

- MyPrimaryGeneratorAction::~MyPrimaryGeneratorAction()
- {
- 	delete tBeam;
- }
- void MyPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)
- {
- 	cout<<“Generating the kinematics for event “<<anEvent->GetEventId()<<endl;
- 	tBeam->GeneratePrimaryVertex(anEvent);
- }

## Generation of an event

- The primary generator should be selected in the constructor of the concrete class derived from G4VUserPrimaryGeneratorAction
- This particle generator must then be destroyed in the destructor
- In the previous example we make use of a class (MyTestBeam) which is a predefined primary particle generator (G4VPrimaryGenerator)
- G4VUserPrimaryGeneratoAction has a pure virtual method named GeneratePrimaries(), invoked at the beginning of each event. In this method, one must invoke the GeneratePrimaryVertex() method of  the G4VPrimaryGenerator concrete class that one instanciated

## An example of PrimaryGenerator

- #ifndef MyTestBeam_H
- #define MyTestBeam_H
- #include “G4VPrimaryGenerator.hh”
- #include “G4ThreeVector.hh”
- #include “G4PrimaryVertex.hh”
- #include “G4ParticleDefinition.hh”
- #include “G4ParticleMomentum.hh”
- #include “G4Event.hh”
- class MyTestBeam: public G4VPrimaryGenerator {
- public:
- 	MyTestBeam();
- 	void GeneratePrimaryVertex(G4Event *evt);
- private:
- 	G4ParticleDefinition *beamParticleDefinition;
- 	G4ParticleMomentum beamMomentum;
- 	G4double beamEnergy;
- 	G4ThreeVector beamVertex;
- 	G4double beamTime;
- }
- #endif

## An example of PrimaryGenerator (2)

- // MyTestBeam.cc
- #include  “G4Event.hh”
- #include “MyTestBeam.hh”
- #include “G4Electron.hh”
- #include “G4PrimaryParticle.hh”
- MyTestBeam::MyTestBeam() {
- 	beamParticleDefinition=G4Electron::ElectronDefinition();
- 	beamEnergy=10*GeV;
- 	beamMomentum=G4ParticleMomentum(1.,0.,0);
- 	beamVertex=G4ThreeVector(0.,0.,-100);
- 	beamTime=0;
- }
- MyTestBeam::GeneratePrimaryVertex(G4Event *evt) {
- 	G4PrimaryVertex *vt=new G4PrimaryVertex(beamVertex,beamTime);
- 	G4double px=beamEnergy*beamMomentum.x();
- 	G4double px=beamEnergy*beamMomentum.x();
- 	G4double px=beamEnergy*beamMomentum.x();
- 	G4PrimaryParticle *particle=new G4PrimaryParticle(beamParticleDefinition,px,py,pz);
- 	vt->SetPrimary(particle);
- 	evt->AddPrimaryVertex(vt);
- }

## G4ParticleGun

- G4ParticleGun is a primary particle generator provided by Geant4. It generates primary particles with a given momentum and position
- Randomization of energy, momentum and position is not provided directly by G4ParticleGun but it can be realized by invoking several of its methods; this must be done in GeneratePrimaries() before invoking generatePrimaryVertex()
- The following methods are provided for G4ParticleGun
- void SetParticleDefinition(G4ParticleDefinition*)
- void SetParticleMomentum(G4ParticleMomentum)
- void SetParticleMomentumDirection(G4ThreeVector)
- void SetParticleEnergy(G4double)
- void SetParticleTime(G4double)
- void SetParticlePosition(G4ThreeVector)
- void SetParticlePolarization(G4ThreeVector)
- void SetNumberOfParticles(G4int)

## kinematics

- The aim of the exercise is to implement a PrimaryGeneratorAction, either as a test beam generator or as a 4- generator (flat generation of particles in eta-phi)
- Use G4ParticleGun as a first attempt (the test beam generator is trivial in this case), then try and implement your own PrimaryGenerator
- Use G4UniformRand() from Randomize.hh is you need a random number generator (flat distribution in ]0,1[)

## boolean  (2)

- A set of variables is already available for doing the work
- idet_inner_radius		min distance of the idet from beam pipe
- idet_outer_radius		outer radius of the idet
- idet_zmax			maximum z of the idet
- calo_inner_radius		min distance of the calo from beam pipe
- calo_outer_radius		outer radius of the calo
- calo_zmax		maximum z of the calorimeter
- muon_inner_radius		min distance of the muon from beam pipe
- muon_outer_radius		outer radius of the muon
- muon_zmax		maximum z of the muon
- Visualization has not been implemented yet for boolean solids, hence the only way to check the results is to shoot particles and check that they behave as expected

## Boolean solids

## Solids from boolean operations

- A very interesting feature of Geant4 is the possibility of combining simple solids with boolean operations
- To create such a “new” boolean solid, one needs:
- Two solids
- a boolean operation (union, intersection, subtraction)
- (optionally) a transformation for the second solid
- The solids used should be either CSG solids or another boolean solid (result of a previous boolean operation)

## Boolean solids

- #include “G4UnionSolid.hh”
- #include “G4SubtractionSolid.hh”
- #include “G4IntersectionSolid.hh”
- ....
- G4Box box1(“Box #1”,20,30,40);
- G4Tubs cylinder1(“Cylinder #1”,0,50,50,0,2*M_PI);
- G4UnionSolid b1UnionC1(“Box+Cylinder”,&box1,&cylinder1);
- G4IntersectionSolid b1IntersC1(“Box intersect Cylinder”,&box1,&cylinder1);
- G4SubtractionSolid b1MinusC1(“Box-Cylinder”,&box1,&cylinder1);

## Boolean solids (2)

- The more useful case is the one where one of the solids is displaced from the origin of the coordinates of the first (reference) solid
- This can be done
- Either by giving a rotation matrix and a translation vector that are used to transform the coordinate system of the first solid to the coordinate system of the second solid (passive method)
- or by creating a transformation that moves the second solid from its desired position to its standard position
- In the first case the translation is applied first to move the origin of coordinates. Then the rotation is used to rotate the coordinate system of the first solid to the coordinate system of the second solid

## Boolean solids (3)

- G4RotationMatrix yRot45deg;
- yRot45deg.rotateY(M_PI/4);
- G4ThreeVector translation(0,0,50);
- G4UnionSolid  boxUnionCyl1(“box union cylinder”,
- 			&box1,&cylinder1,&yRot45deg,translation);
- // the same solid with the active method
- G4RotationMatrix InvRot=yRot45deg;
- InvRot.invert();
- G4Transform3D transform(InvRot,translation);
- G4UnionSolid   boxUnionCyl2(“box union cylinder”,
- 			&box1,&cylinder1,transform)

## boolean

- The aim of the exercise is to implement the mother volumes for the three major subdetectors in Atlas (inner detector, calorimeters, muon) by using boolean solids.
- Implement the inner detector as a normal tube, the calorimeter as a subtraction and the muon part as union