Geant4: Detector description module

Geant4: Detector description module
Alexander Howard, CERN Acknowledgements: Slides produced by J.Apostolakis, G.Cosmo, M. Asai

Part I The Basics Part II Logical and physical volumes Part III Solids, touchables Part IV Sensitive detector, digitizer & magnetic field Part V Visualization attributes & Optimization technique Part VI Advanced features Detector Description - Geant4 Course

Detector Description: the Basics
PART I Detector Description: the Basics

Materials - The System of units & constants - Definition of elements - Materials and mixtures - Some examples …

Detector Description - Geant4 Course
Unit system Geant4 has no default unit. To give a number, unit must be “multiplied” to the number. for example : G4double width = 12.5*m; G4double density = 2.7*g/cm3; If no unit is specified, the internal G4 unit will be used, but this is discouraged ! Almost all commonly used units are available. The user can define new units. Refer to CLHEP: SystemOfUnits.h Divide a variable by a unit you want to get. G4cout << dE / MeV << “ (MeV)” << G4endl; Detector Description - Geant4 Course

System of Units System of units are defined in CLHEP, based on: millimetre (mm), nanosecond (ns), Mega eV (MeV), positron charge (eplus) degree Kelvin (kelvin), the amount of substance (mole), luminous intensity (candela), radian (radian), steradian (steradian) All other units are computed from the basic ones. In output, Geant4 can choose the most appropriate unit to use. Just specify the category for the data (Length, Time, Energy, etc…): G4cout << G4BestUnit(StepSize, “Length”); StepSize will be printed in km, m, mm or … fermi, depending on its value Detector Description - Geant4 Course

Defining new units New units can be defined directly as constants, or (suggested way) via G4UnitDefinition. G4UnitDefinition ( name, symbol, category, value ) Example (mass thickness): G4UnitDefinition (“grammpercm2”, “g/cm2”, “MassThickness”, g/cm2); The new category “MassThickness” will be registered in the kernel in G4UnitsTable To print the list of units: From the code G4UnitDefinition::PrintUnitsTable(); At run-time, as UI command: Idle> /units/list Detector Description - Geant4 Course

Definition of Materials
Different kinds of materials can be defined: isotopes <> G4Isotope elements <> G4Element molecules <> G4Material compounds and mixtures <> G4Material Attributes associated: temperature, pressure, state, density Detector Description - Geant4 Course

Isotopes, Elements and Materials
G4Isotope and G4Element describe the properties of the atoms: Atomic number, number of nucleons, mass of a mole, shell energies Cross-sections per atoms, etc… G4Material describes the macroscopic properties of the matter: temperature, pressure, state, density Radiation length, absorption length, etc… Detector Description - Geant4 Course

Elements & Isotopes Isotopes can be assembled into elements G4Isotope (const G4String& name, G4int z, // atomic number G4int n, // number of nucleons G4double a ); // mass of mole … building elements as follows: G4Element (const G4String& name, const G4String& symbol, // element symbol G4int nIso ); // # of isotopes G4Element::AddIsotope(G4Isotope* iso, // isotope G4double relAbund); // fraction of atoms // per volume Detector Description - Geant4 Course

Material of one element
Single element material G4double density = 1.390*g/cm3; G4double a = 39.95*g/mole; G4Material* lAr = new G4Material("liquidArgon",z=18.,a,density); Prefer low-density material to vacuum Detector Description - Geant4 Course

Material: molecule A Molecule is made of several elements (composition by number of atoms): a = 1.01*g/mole; G4Element* elH = new G4Element("Hydrogen",symbol="H",z=1.,a); a = 16.00*g/mole; G4Element* elO = new G4Element("Oxygen",symbol="O",z=8.,a); density = 1.000*g/cm3; G4Material* H2O = new G4Material("Water",density,ncomp=2); H2O->AddElement(elH, natoms=2); H2O->AddElement(elO, natoms=1); Detector Description - Geant4 Course

Material: compound Compound: composition by fraction of mass a = 14.01*g/mole; G4Element* elN = new G4Element(name="Nitrogen",symbol="N",z= 7.,a); a = 16.00*g/mole; G4Element* elO = new G4Element(name="Oxygen",symbol="O",z= 8.,a); density = 1.290*mg/cm3; G4Material* Air = new G4Material(name="Air",density,ncomponents=2); Air->AddElement(elN, 70.0*perCent); Air->AddElement(elO, 30.0*perCent); Detector Description - Geant4 Course

Material: mixture Composition of compound materials G4Element* elC = …; // define “carbon” element G4Material* SiO2 = …; // define “quartz” material G4Material* H2O = …; // define “water” material density = 0.200*g/cm3; G4Material* Aerog = new G4Material("Aerogel",density,ncomponents=3); Aerog->AddMaterial(SiO2,fractionmass=62.5*perCent); Aerog->AddMaterial(H2O ,fractionmass=37.4*perCent); Aerog->AddElement (elC ,fractionmass= 0.1*perCent); Detector Description - Geant4 Course

Example: gas It may be necessary to specify temperature and pressure (dE/dx computation affected) G4double density = 27.*mg/cm3; G4double temperature = 325.*kelvin; G4double pressure = 50.*atmosphere; G4Material* CO2 = new G4Material(“CarbonicGas", density, ncomponents=2 kStateGas, temperature, pressure); CO2->AddElement(C,natoms = 1); CO2->AddElement(O,natoms = 2); Detector Description - Geant4 Course

Example: vacuum Absolute vacuum does not exist. It is a gas at very low density ! Cannot define materials composed of multiple elements through Z or A, or with r = 0. G4double atomicNumber = 1.; G4double massOfMole = 1.008*g/mole; G4double density = 1.e-25*g/cm3; G4double temperature = 2.73*kelvin; G4double pressure = 3.e-18*pascal; G4Material* Vacuum = new G4Material(“interGalactic", atomicNumber, massOfMole, density, kStateGas, temperature, pressure); Detector Description - Geant4 Course

NIST Material Data Base and Geant4

NIST materials in Geant4
==================================== ### Elementary Materials from the NIST Data Base ================================== Z Name ChFormula density(g/cm^3) I(eV) 1 G4_H H_ e 2 G4_He 3 G4_Li 4 G4_Be 5 G4_B 6 G4_C 7 G4_N N_ 8 G4_O O_ 9 G4_F 10 G4_Ne 11 G4_Na 12 G4_Mg 13 G4_Al 14 G4_Si NIST Elementary Materials NIST Compounds Nuclear Materials Space Materials? =================================== ### Compound Materials from the NIST Data Base N Name ChFormula density(g/cm^3) I(eV) 13 G4_Adipose_Tissue e-05 e-05 e-05 e-05 4 G4_Air 2 G4_CsI Detector Description - Geant4 Course

How to use Do not need anymore to predefine elements and materials Main new user interfaces: G4NistManager* manager = G4NistManager::GetPointer(); G4Element* elm = manager->FindOrBuildElement(“symb”, G4bool iso); G4Element* elm = manager->FindOrBuildElement(G4int Z, G4bool iso); G4Material* mat = manager->FindOrBuildMaterial(“name”, G4bool iso); G4Material* mat = manager->ConstructNewMaterial(“name”, const std::vector<G4int>& Z, const std::vector<G4double>& weight, G4double density, G4bool iso); G4double isotopeMass = manager->GetMass(G4int Z, G4int N); Detector Description - Geant4 Course

Describing a detector - Detector geometry modeling - The basic concepts: solids & volumes

Describe your detector
Geant4: Detector description module Describe your detector Derive your own concrete class from G4VUserDetectorConstruction abstract base class. Implementing the method Construct(): Modularize it according to each detector component or sub-detector: Construct all necessary materials Define shapes/solids required to describe the geometry Construct and place volumes of your detector geometry Define sensitive detectors and identify detector volumes which to associate them Associate magnetic field to detector regions Define visualization attributes for the detector elements The main class defining the detector geometry is derived from G4VUserDetectorConstruction. It is advised to modularize its design according to the geometry components (I.e. define a class for each geometry component), especially for complex geometry structures. Definition of attributes, like sensitive detectors, local fields or visualization are optional. Detector Description - Geant4 Course

Creating a Detector Volume
Geant4: Detector description module Creating a Detector Volume Solid Logical-Volume Physical-Volume Start with its Shape & Size Box 3x5x7 cm, sphere R=8m Add properties: material, B/E field, make it sensitive Place it in another volume in one place repeatedly using a function So you can re-use i) one solid for 10 or 100 or any number of logical volumes. ii) one logical volume for 100 or 1000 physical volumes. Solids are geometrical entities. They can also be used to describe sensitive volumes, ... Detector Description - Geant4 Course

Define detector geometry
Geant4: Detector description module Define detector geometry Three conceptual layers G4VSolid -- shape, size G4LogicalVolume -- daughter physical volumes, material, sensitivity, user limits, etc. G4VPhysicalVolume -- position, rotation G4Box G4Tubs G4VSolid G4VPhysicalVolume G4Material G4VSensitiveDetector G4PVPlacement G4PVParameterised G4VisAttributes G4LogicalVolume Possible attributes associated to a G4LogicalVolume: Magnetic field Material If sensitive, associated sensitive detector Quality of geometry optimization (smartless) Visualization attributes User limits (maximum allowed step, track length, minimum kinetic energy, …) … Detector Description - Geant4 Course

Define detector geometry
Geant4: Detector description module Basic strategy G4VSolid* pBoxSolid = new G4Box(“aBoxSolid”, 1.*m, 2.*m, 3.*m); G4LogicalVolume* pBoxLog = new G4LogicalVolume( pBoxSolid, pBoxMaterial, “aBoxLog”, 0, 0, 0); G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog, “aBoxPhys”, pMotherLog, 0, copyNo); A volume is placed in its mother volume. Position and rotation of the daughter volume is described with respect to the local coordinate system of the mother volume. The origin of mother volume’s local coordinate system is at the center of the mother volume. Daughter volume cannot protrude from mother volume. Logical volume : + material, sensitivity, etc. Solid : shape and size Physical volume : + rotation and position Detector Description - Geant4 Course

Geometrical hierarchy
Geant4: Detector description module Geometrical hierarchy One logical volume can be placed more than once. One or more volumes can be placed to a mother volume. Note that the mother-daughter relationship is an information of G4LogicalVolume. If the mother volume is placed more than once, all daughters are by definition appear in all of mother physical volumes. The world volume must be a unique physical volume which fully contains all the other volumes. The world volume defines the global coordinate system. The origin of the global coordinate system is at the center of the world volume. Position of a track is given with respect to the global coordinate system. Detector Description - Geant4 Course

Detector Description: Logical and Physical Volumes
PART II Detector Description: Logical and Physical Volumes

G4LogicalVolume G4LogicalVolume(G4VSolid* pSolid, G4Material* pMaterial, const G4String& name, G4FieldManager* pFieldMgr=0, G4VSensitiveDetector* pSDetector=0, G4UserLimits* pULimits=0, G4bool optimise=true); Contains all information of volume except position: Shape and dimension (G4VSolid) Material, sensitivity, visualization attributes Position of daughter volumes Magnetic field, User limits Shower parameterisation Physical volumes of same type can share a logical volume. The pointers to solid and material must be NOT null Once created it is automatically entered in the LV store It is not meant to act as a base class It is possible to deactivate optimisation (voxelisation) of the geometry for a given logical volume. Optimisation is built by default, if the flag “optimise” is set to false, the whole hierarchy of volumes identified by the logical volume will not be optimised. Note that optimisation is always applied for logical volumes whose physical volumes are parameterised volumes. Detector Description - Geant4 Course

G4VPhysicalVolume G4PVPlacement Placement = One Volume A volume instance positioned once in a mother volume G4PVParameterised Parameterised = Many Volumes Parameterised by the copy number Shape, size, material, position and rotation can be parameterised, by implementing a concrete class of G4VPVParameterisation. Reduction of memory consumption Currently: parameterisation can be used only for volumes that either a) have no further daughters or b) are identical in size & shape. G4PVReplica Replica = Many Volumes Slicing a volume into smaller pieces (if it has a symmetry) Detector Description - Geant4 Course

Physical Volumes repeated placement Placement: it is one positioned volume Repeated: a volume placed many times can represent any number of volumes reduces use of memory. Replica simple repetition, similar to G3 divisions Parameterised A mother volume can contain either many placement volumes OR one repeated volume Detector Description - Geant4 Course

G4PVPlacement

G4PVPlacement G4PVPlacement(G4RotationMatrix* pRot, const G4ThreeVector& tlate, G4LogicalVolume* pCurrentLogical, const G4String& pName, G4LogicalVolume* pMotherLogical, G4bool pMany, G4int pCopyNo); Single volume positioned relatively to the mother volume In a frame rotated and translated relative to the coordinate system of the mother volume Three additional constructors: A simple variation: specifying the mother volume as a pointer to its physical volume instead of its logical volume. Using G4Transform3D to represent the direct rotation and translation of the solid instead of the frame The combination of the two variants above Adopting the constructor using the pointer to the logical volume of the mother, is a very natural way of defining a physical volume, and is especially useful when creating sub-detectors: the mother volumes is not placed until a later stage of the assembly program. The G4Transform3D argument should be constructed by: i) First rotating it to align the solid to the system of reference of its mother volume, and ii) Then placing the solid at the location Transform3D.getTranslation(), with respect to the origin of the system of coordinates of the mother volume. This is useful for the people who prefer to think in terms of moving objects in a given reference frame. Detector Description - Geant4 Course

G4PVPlacement Geant4: Detector description module G4PVPlacement(G4RotationMatrix* pRot, // rotation of mother frame const G4ThreeVector &tlate, // position in rotated frame G4LogicalVolume *pDaughterLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, // ‘true’ is not supported yet… G4int pCopyNo, // unique arbitrary integer G4bool pSurfChk=false); // optional boundary check Single volume positioned relatively to the mother volume. Mother volume translation in rotated frame Adopting the constructor using the pointer to the logical volume of the mother, is a very natural way of defining a physical volume, and is especially useful when creating sub-detectors: the mother volumes is not placed until a later stage of the assembly program. The G4Transform3D argument should be constructed by: i) First rotating it to align the solid to the system of reference of its mother volume *pMother, and ii) Then placing the solid at the location Transform3D.getTranslation(), with respect to the origin of the system of coordinates of the mother volume. This is useful for the people who prefer to think in terms of moving objects in a given reference frame. rotation Detector Description - Geant4 Course

Alternative G4PVPlacement
Geant4: Detector description module G4PVPlacement( G4Transform3D(G4RotationMatrix &pRot, // rotation of daughter frame const G4ThreeVector &tlate), // position in mother frame G4LogicalVolume *pDaughterLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, // ‘true’ is not supported yet… G4int pCopyNo, // unique arbitrary integer G4bool pSurfChk=false); // optional boundary check Single volume positioned relatively to the mother volume. Mother volume rotation Adopting the constructor using the pointer to the logical volume of the mother, is a very natural way of defining a physical volume, and is especially useful when creating sub-detectors: the mother volumes is not placed until a later stage of the assembly program. The G4Transform3D argument should be constructed by: i) First rotating it to align the solid to the system of reference of its mother volume *pMother, and ii) Then placing the solid at the location Transform3D.getTranslation(), with respect to the origin of the system of coordinates of the mother volume. This is useful for the people who prefer to think in terms of moving objects in a given reference frame. translation in mother frame Detector Description - Geant4 Course

Parameterised Physical Volumes
Geant4: Detector description module Parameterised Physical Volumes User written functions define: the size of the solid (dimensions) Function ComputeDimensions(…) where it is positioned (transformation) Function ComputeTransformations(…) Optional: the type of the solid Function ComputeSolid(…) the material Function ComputeMaterial(…) Limitations: Applies to simple CSG solids only Daughter volumes allowed only for special cases Very powerful Consider parameterised volumes as “leaf” volumes For parameterised volumes the mother volume must be always specified, therefore the world volume can never be a parameterised volume. All methods in G4VPVParameterisation provides an argument (integer) for specifying the copy number of the parameterisation instance under consideration. Only parameterised volumes in which all the solids have the same size, currently allows the addition of daughter volumes. Detector Description - Geant4 Course

Uses of Parameterised Volumes
Geant4: Detector description module Uses of Parameterised Volumes Complex detectors with large repetition of volumes regular or irregular Medical applications the material in animal tissue is measured cubes with varying material Detector Description - Geant4 Course

G4PVParameterised G4PVParameterised(const G4String& pName, G4LogicalVolume* pCurrentLogical, G4LogicalVolume* pMotherLogical, const EAxis pAxis, const G4int nReplicas, G4VPVParameterisation* pParam); Replicates the volume nReplicas times using the parameterisation pParam, within the mother volume The positioning of the replicas is dominant along the specified Cartesian axis If kUndefined is specified as axis, 3D voxelisation for optimisation of the geometry is adopted Represents many touchable detector elements differing in their positioning and dimensions. Both are calculated by means of a G4VPVParameterisation object Alternative constructor using pointer to physical volume for the mother Detector Description - Geant4 Course

Parameterisation example - 1
Geant4: Detector description module Parameterisation example - 1 G4VSolid* solidChamber = new G4Box("chamber", 100*cm, 100*cm, 10*cm); G4LogicalVolume* logicChamber = new G4LogicalVolume(solidChamber, ChamberMater, "Chamber", 0, 0, 0); G4double firstPosition = -trackerSize + 0.5*ChamberWidth; G4double firstLength = fTrackerLength/10; G4double lastLength = fTrackerLength; G4VPVParameterisation* chamberParam = new ChamberParameterisation( NbOfChambers, firstPosition, ChamberSpacing, ChamberWidth, firstLength, lastLength); G4VPhysicalVolume* physChamber = new G4PVParameterised( "Chamber", logicChamber, logicTracker, kZAxis, NbOfChambers, chamberParam); Example of parameterisation along the Z axis (kZAxis) NbOfChambers - Number of chambers firstPosition - Z of center of first chamber ChamberSpacing - Z spacing of centers ChamberWidth - Width of chamber firstLength - initial length lastLength - final length Use kUndefined for activating 3D voxelisation for optimisation Detector Description - Geant4 Course

Geant4: Detector description module Parameterisation example - 2 class ChamberParameterisation : public G4VPVParameterisation { public: ChamberParameterisation( G4int NoChambers, G4double startZ, G4double spacing, G4double widthChamber, G4double lenInitial, G4double lenFinal ); ~ChamberParameterisation(); void ComputeTransformation (const G4int copyNo, G4VPhysicalVolume* physVol) const; void ComputeDimensions (G4Box& trackerLayer, const G4int copyNo, const G4VPhysicalVolume* physVol) const; } Example of parameterisation along the Z axis (kZAxis) Detector Description - Geant4 Course

Geant4: Detector description module Parameterisation example - 3 void ChamberParameterisation::ComputeTransformation (const G4int copyNo, G4VPhysicalVolume* physVol) const { G4double Zposition= fStartZ + (copyNo+1) * fSpacing; G4ThreeVector origin(0, 0, Zposition); physVol->SetTranslation(origin); physVol->SetRotation(0); } void ChamberParameterisation::ComputeDimensions (G4Box& trackerChamber, const G4int copyNo, const G4VPhysicalVolume* physVol) const G4double halfLength= fHalfLengthFirst + copyNo * fHalfLengthIncr; trackerChamber.SetXHalfLength(halfLength); trackerChamber.SetYHalfLength(halfLength); trackerChamber.SetZHalfLength(fHalfWidth); Example of parameterisation along the Z axis (kZAxis) Detector Description - Geant4 Course

Replicated Physical Volumes
Geant4: Detector description module Replicated Physical Volumes repeated The mother volume is sliced into replicas, all of the same size and dimensions. Represents many touchable detector elements differing only in their positioning. Replication may occur along: Cartesian axes (X, Y, Z) – slices are considered perpendicular to the axis of replication Coordinate system at the center of each replica Radial axis (Rho) – cons/tubs sections centered on the origin and un-rotated Coordinate system same as the mother Phi axis (Phi) – phi sections or wedges, of cons/tubs form Coordinate system rotated such as that the X axis bisects the angle made by each wedge The elements positions are calculated by means of a simple linear formula, and the elements completely fill the containing mother volume. If a G4PVReplica is positioned inside a given mother, it must be the only daughter volume for that mother. During tracking, translation and rotation of each replica object are computed according to the current active replication. Detector Description - Geant4 Course

a daughter volume to be replicated mother volume G4PVReplica G4PVReplica(const G4String& pName, G4LogicalVolume* pCurrentLogical, G4LogicalVolume* pMotherLogical, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double offset=0); Alternative constructor: using pointer to physical volume for the mother An offset can only be associated to a mother offset along the axis of replication Features and restrictions: Replicas can be placed inside other replicas Normal placement volumes can be placed inside replicas, assuming no intersection/overlaps with the mother volume or with other replicas No volume can be placed inside a radial replication Parameterised volumes cannot be placed inside a replica The width of the replica refers to its extent along the axis of replication. Detector Description - Geant4 Course

Replica – axis, width, offset
Cartesian axes - kXaxis, kYaxis, kZaxis offset shall not be used Center of n-th daughter is given as -width*(nReplicas-1)*0.5+n*width Radial axis - kRaxis width*(n+0.5)+offset Phi axis - kPhi offset width Detector Description - Geant4 Course

Replication example G4double tube_dPhi = 2.* M_PI; G4VSolid* tube = new G4Tubs("tube", 20*cm, 50*cm, 30*cm, 0., tube_dPhi*rad); G4LogicalVolume * tube_log = new G4LogicalVolume(tube, Ar, "tubeL", 0, 0, 0); G4VPhysicalVolume* tube_phys = new G4PVPlacement(0,G4ThreeVector(-200.*cm, 0., 0.*cm), "tubeP", tube_log, world_phys, false, 0); G4double divided_tube_dPhi = tube_dPhi/6.; G4VSolid* divided_tube = new G4Tubs("divided_tube", 20*cm, 50*cm, 30*cm, -divided_tube_dPhi/2.*rad, divided_tube_dPhi*rad); G4LogicalVolume* divided_tube_log = new G4LogicalVolume(divided_tube, Ar, "div_tubeL", 0, 0, 0); G4VPhysicalVolume* divided_tube_phys = new G4PVReplica("divided_tube_phys", divided_tube_log, tube_log, kPhi, 6, divided_tube_dPhi); Example of replication in Phi Detector Description - Geant4 Course

Divided Physical Volumes
Geant4: Detector description module Divided Physical Volumes Implemented as “special” kind of parameterised volumes Applies to CSG-like solids only (box, tubs, cons, para, trd, polycone, polyhedra) Divides a volume in identical copies along one of its axis (copies are not strictly identical) e.g. - a tube divided along its radial axis Offsets can be specified The possible axes of division vary according to the supported solid type Represents many touchable detector elements differing only in their positioning G4PVDivision is the class defining the division The parameterisation is calculated automatically using the values provided in input Detector Description - Geant4 Course

PART III Detector Description: Solids & Touchables

G4VSolid Abstract class. All solids in Geant4 derive from it Defines but does not implement all functions required to: compute distances to/from the shape check whether a point is inside the shape compute the extent of the shape compute the surface normal to the shape at a given point Once constructed, each solid is automatically registered in a specific solid store Detector Description - Geant4 Course

Solids Solids defined in Geant4: CSG (Constructed Solid Geometry) solids G4Box, G4Tubs, G4Cons, G4Trd, … Analogous to simple GEANT3 CSG solids Specific solids (CSG like) G4Polycone, G4Polyhedra, G4Hype, … G4TwistedTubs, G4TwistedTrap, … BREP (Boundary REPresented) solids G4BREPSolidPolycone, G4BSplineSurface, … Any order surface Boolean solids G4UnionSolid, G4SubtractionSolid, … Detector Description - Geant4 Course

CSG: G4Tubs, G4Cons G4Tubs(const G4String& pname, // name G4double pRmin, // inner radius G4double pRmax, // outer radius G4double pDz, // Z half length G4double pSphi, // starting Phi G4double pDphi); // segment angle G4Cons(const G4String& pname, // name G4double pRmin1, // inner radius -pDz G4double pRmax1, // outer radius -pDz G4double pRmin2, // inner radius +pDz G4double pRmax2, // outer radius +pDz Detector Description - Geant4 Course

CSG: G4Box, G4Tubs G4Box(const G4String &pname, // name G4double half_x, // X half size G4double half_y, // Y half size G4double half_z); // Z half size G4Tubs(const G4String &pname, // name G4double pRmin, // inner radius G4double pRmax, // outer radius G4double pDz, // Z half length G4double pSphi, // starting Phi G4double pDphi); // segment angle Detector Description - Geant4 Course

Other CSG solids G4Para (parallelepiped) G4Trap G4Cons G4Trd G4Torus Consult to Section of Geant4 Application Developers Guide for all available shapes. G4Sphere G4Orb (full solid sphere) Detector Description - Geant4 Course

Specific CSG Solids: G4Polycone
Geant4: Detector description module Specific CSG Solids: G4Polycone G4Polycone(const G4String& pName, G4double phiStart, G4double phiTotal, G4int numRZ, const G4double r[], const G4double z[]); numRZ - numbers of corners in the r,z space r, z - coordinates of corners Additional constructor using planes Constructor by planes: G4Polycone( const G4String& pName, G4double phiStart, G4double phiTotal, G4int numZPlanes, const G4double zPlane[], const G4double rInner[], const G4double rOuter[]) Detector Description - Geant4 Course

Other Specific CSG solids
Geant4: Detector description module Other Specific CSG solids G4Tet (tetrahedra) G4Hype G4Polyhedra G4Ellipsoid G4EllipticalTube G4TwistedTrd G4TwistedBox G4TwistedTrap Consult to Section of Geant4 Application Developers Guide for all available shapes. G4EllipticalCone G4TwistedTubs Detector Description - Geant4 Course

BREP Solids BREP = Boundary REPresented Solid Listing all its surfaces specifies a solid e.g. 6 squares for a cube Surfaces can be planar, 2nd or higher order elementary BREPS Splines, B-Splines, NURBS (Non-Uniform B-Splines) advanced BREPS Few elementary BREPS pre-defined box, cons, tubs, sphere, torus, polycone, polyhedra Advanced BREPS built through CAD systems In picture: G4double zval[6] = { -4000*mm, -3500*mm, -3500*mm, -1500*mm, -1500*mm, -1000*mm }; G4double rmin[6] = { 500*mm, 500*mm, 500*mm, 500*mm, 500*mm, 500*mm }; G4double rmax[6] = { 500*mm, 2000*mm, 1000*mm, 1000*mm, 2000*mm, 500*mm }; G4BREPSolidPCone *Solid = new G4BREPSolidPCone( "BREPSolidPCone", 0.0*rad, twopi*rad, 6, zval[0], zval, rmin, rmax ); Detector Description - Geant4 Course

BREPS: G4BREPSolidPolyhedra
Geant4: Detector description module BREPS: G4BREPSolidPolyhedra G4BREPSolidPolyhedra(const G4String& pName, G4double phiStart, G4double phiTotal, G4int sides, G4int nZplanes, G4double zStart, const G4double zval[], const G4double rmin[], const G4double rmax[]); sides - numbers of sides of each polygon in the x-y plane nZplanes - numbers of planes perpendicular to the z axis zval[] - z coordinates of each plane rmin[], rmax[] - Radii of inner and outer polygon at each plane In picture: #define VECSIZE 6 G4int sides = 5; G4double rmin[VECSIZE] = { 100*mm, 100*mm, 100*mm, 100*mm, 100*mm, 100*mm }; G4double rmax[VECSIZE] = { 700*mm, 800*mm, 400*mm, 400*mm, 600*mm, 500*mm }; G4double zval[VECSIZE] = { 3500*mm, 3800*mm, 4000*mm, 4300*mm, 4500*mm, 5000*mm }; G4BREPSolidPolyhedra *sphedra = new G4BREPSolidPolyhedra( "sphedra", pi/2*rad, 2*pi*rad, sides, VECSIZE, zval[0], zval, rmin, rmax); G4LogicalVolume *lvphedra = new G4LogicalVolume( sphedra, Al, "lvphedra" ); G4PVPlacement *pvphedra = new G4PVPlacement( 0, G4ThreeVector(), "pvphedra1", lvphedra, worldPhysic, false, 0 ); Detector Description - Geant4 Course

Boolean Solids Geant4: Detector description module Solids can be combined using boolean operations: G4UnionSolid, G4SubtractionSolid, G4IntersectionSolid Requires: 2 solids, 1 boolean operation, and an (optional) transformation for the 2nd solid 2nd solid is positioned relative to the coordinate system of the 1st solid Result of boolean operation becomes a solid. Thus the third solid can be combined to the resulting solid of first operation. Solids to be combined can be either CSG or other Boolean solids. Note: tracking cost for the navigation in a complex Boolean solid is proportional to the number of constituent CSG solids G4UnionSolid G4SubtractionSolid G4IntersectionSolid Passive transformation: a rotation matrix/translation is provided to transform the coordinate system of the 1st solid to the coordinate system of the 2nd solid. The final transformation in this case is NOT copied, therefore, once defined and used it must not be modified. Active transformation: a transformation (G4Transform3D) is first created to move the 2nd solid to the correct position. The transformation in this case is stored (copied) in the final boolean solid. Detector Description - Geant4 Course

Boolean solid Detector Description - Geant4 Course

Boolean Solids - example
Geant4: Detector description module G4VSolid* box = new G4Box(“Box",50*cm,60*cm,40*cm); G4VSolid* cylinder = new G4Tubs(“Cylinder”,0.,50.*cm,50.*cm,0.,2*M_PI*rad); G4VSolid* union = new G4UnionSolid("Box+Cylinder", box, cylinder); G4VSolid* subtract = new G4SubtractionSolid("Box-Cylinder", box, cylinder, 0, G4ThreeVector(30.*cm,0.,0.)); G4RotationMatrix* rm = new G4RotationMatrix(); rm->RotateX(30.*deg); G4VSolid* intersect = new G4IntersectionSolid("Box&&Cylinder", box, cylinder, rm, G4ThreeVector(0.,0.,0.)); The origin and the coordinates of the combined solid are the same as those of the first solid. Passive transformation: a rotation matrix/translation is provided to transform the coordinate system of the 1st solid to the coordinate system of the 2nd solid. The final transformation in this case is NOT copied, therefore, once defined and used it must not be modified. Active transformation: a transformation (G4Transform3D) is first created to move the 2nd solid to the correct position. The transformation in this case is stored (copied) in the final boolean solid. Detector Description - Geant4 Course

Touchable Suppose a geometry is made of 4x5 voxels. and it is implemented by two levels of replica. In reality, there is only one physical volume object for each level. Its position is parameterized by its copy number. To get the copy number of each level, CopyNo = 0 1 2 3 4 CopyNo = 1 CopyNo = 2 CopyNo = 3 Use touchable to get the copy number of each level. G4VTouchable has a method GetCopyNumber(G4int nLevel=0) nLevel = 0 : returns the copy number of the bottom level nLevel = 1 : returns the copy number of the mother volume nLevel = 2 : returns the copy number of the grandmother volume, etc. Detector Description - Geant4 Course

Sensitive detector, digitizer & magnetic field
PART IV Sensitive detector, digitizer & magnetic field

Detector sensitivity A logical volume becomes sensitive if it has a pointer to a concrete class derived from G4VSensitiveDetector A sensitive detector either constructs one or more hit objects or accumulates values to existing hits using information given in a G4Step object NOTE: you must get the volume information from the “PreStepPoint” Detector Description - Geant4 Course

Sensitive detector and Hit
Each “Logical Volume” can have a pointer to a sensitive detector Hit is a snapshot of the physical interaction of a track or an accumulation of interactions of tracks in the sensitive region of your detector A sensitive detector creates hit(s) using the information given in G4Step object. The user has to provide his/her own implementation of the detector response Hit objects, which still are the user’s class objects, are collected in a G4Event object at the end of an event. The UserSteppingAction class should NOT do this Detector Description - Geant4 Course

Hit class – 1 Hit is a user-defined class derived from G4VHit You can store various types information by implementing your own concrete Hit class For example: Position and time of the step Momentum and energy of the track Energy deposition of the step Geometrical information or any combination of above Detector Description - Geant4 Course

Hit class - 2 Hit objects of a concrete hit class must be stored in a dedicated collection which is instantiated from G4THitsCollection template class The collection will be associated to a G4Event object via G4HCofThisEvent Hits collections are accessible through G4Event at the end of event, through G4SDManager during processing an event Used for Event filtering Example of use of hit collections during event processing is its use in Event filtering. Prompt particles can be simulated first, using the urgent stack. When these are exhausted, the hits collection of a veto counter or trigger can be enquired to determine whether the full event should be simulated. Detector Description - Geant4 Course

Readout geometry Readout geometry is a virtual and artificial geometry which can be defined in parallel to the real detector geometry A readout geometry is optional Each one is associated to a sensitive detector Detector Description - Geant4 Course

Digitization Digit represents a detector output (e.g. ADC/TDC count, trigger signal) Digit is created with one or more hits and/or other digits by a concrete implementation derived from G4VDigitizerModule In contradiction to the Hit which is generated at tracking time automatically, the digitize() method of each G4VDigitizerModule must be explicitly invoked by the user’s code (e.g. EventAction) Detector Description - Geant4 Course

Defining a sensitive detector
Basic strategy G4LogicalVolume* myLogCalor = ……; G4VSensitiveDetector* pSensitivePart = new MyCalorimeterSD(“/mydet/calorimeter”); G4SDManager* SDMan = G4SDManager::GetSDMpointer(); SDMan->AddNewDetector(pSensitivePart); myLogCalor->SetSensitiveDetector(pSensitivePart); Detector Description - Geant4 Course

Magnetic field (1) Create your Magnetic field class Uniform field : Use an object of the G4UniformMagField class G4MagneticField* magField = new G4UniformMagField(G4ThreeVector(1.*Tesla,0.,0.); Non-uniform field : Create your own concrete class derived from G4MagneticField and implement GetFieldValue method. void MyField::GetFieldValue( const double Point[4], double *field) const Point[0..2] are position in global coordinate system, Point[3] is time field[0..2] are returning magnetic field Detector Description - Geant4 Course

Field integration In order to propagate a particle inside a field (e.g. magnetic, electric or both), we solve the equation of motion of the particle in the field. We use a Runge-Kutta method for the integration of the ordinary differential equations of motion. Several Runge-Kutta ‘steppers’ are available. In specific cases other solvers can also be used: In a uniform field, using the analytical solution. In a smooth but varying field, with RK+helix. Using the method to calculate the track's motion in a field, Geant4 breaks up this curved path into linear chord segments. We determine the chord segments so that they closely approximate the curved path. ‘Tracking’ Step Chords Real Trajectory Detector Description - Geant4 Course

Tracking in field We use the chords to interrogate the G4Navigator, to see whether the track has crossed a volume boundary. One physics/tracking step can create several chords. In some cases, one step consists of several helix turns. User can set the accuracy of the volume intersection, By setting a parameter called the “miss distance” It is a measure of the error in whether the approximate track intersects a volume. It is quite expensive in CPU performance to set too small “miss distance”. ‘Tracking’ Step Chords Real Trajectory Detector Description - Geant4 Course "miss distance"

Magnetic field (2) Tell Geant4 to use your field Find the global Field Manager G4FieldManager* globalFieldMgr = G4TransportationManager::GetTransportationManager() ->GetFieldManager(); Set the field for this FieldManager, globalFieldMgr->SetDetectorField(magField); and create a Chord Finder. globalFieldMgr->CreateChordFinder(magField); /example/novice/N04/ExN04 is a good starting point Detector Description - Geant4 Course

PART V Detector Description: Visualization attributes & Optimization technique

Detector Description Visualization attributes & Optimization technique
Geant4: Detector description module Detector Description Visualization attributes & Optimization technique Visualization attributes Optimization technique & tuning

Visualization of Detector
Each logical volume can have associated a G4VisAttributes object Visibility, visibility of daughter volumes Color, line style, line width Force flag to wire-frame or solid-style mode For parameterised volumes, attributes can be dynamically assigned to the logical volume Lifetime of visualization attributes must be at least as long as the objects they’re assigned to Detector Description - Geant4 Course

Visualization of Hits and Trajectories
Each G4VHit concrete class must have an implementation of Draw() method. Colored marker Colored solid Change the color of detector element G4Trajectory class has a Draw() method. Blue : positive Green : neutral Red : negative You can implement alternatives by yourself Detector Description - Geant4 Course

Geometry optimisation
For each mother volume a one-dimensional virtual division is performed the virtual division is along a chosen axis the axis is chosen by using an heuristic Subdivisions (slices) containing same volumes are gathered into one Subdivisions containing many volumes are refined applying a virtual division again using a second Cartesian axis the third axis can be used for a further refinement, in case Smart voxels are computed at initialisation time When the detector geometry is closed Do not require large memory or computing resources At tracking time, searching is done in a hierarchy of virtual divisions Detector Description - Geant4 Course

Detector description tuning
Geant4: Detector description module Detector description tuning Some geometry topologies may require ‘special’ tuning for ideal and efficient optimisation for example: a dense nucleus of volumes included in very large mother volume Granularity of voxelisation can be explicitly set Methods Set/GetSmartless() from G4LogicalVolume Critical regions for optimisation can be detected Helper class G4SmartVoxelStat for monitoring time spent in detector geometry optimisation Automatically activated if /run/verbose greater than 1 Percent Memory Heads Nodes Pointers Total CPU Volume k Calorimeter k Layer Detector Description - Geant4 Course

Visualising voxel structure
Geant4: Detector description module Visualising voxel structure The computed voxel structure can be visualized with the final detector geometry Helper class G4DrawVoxels Visualize voxels given a logical volume G4DrawVoxels::DrawVoxels(const G4LogicalVolume*) Allows setting of visualization attributes for voxels G4DrawVoxels::SetVoxelsVisAttributes(…) useful for debugging purposes Can also be done through a visualization command at run-time: /vis/scene/add/logicalVolume <logical-volume-name> [<depth>] Detector Description - Geant4 Course

Customising optimisation
Geant4: Detector description module Customising optimisation Detector regions may be excluded from optimisation (ex. for debug purposes) Optional argument in constructor of G4LogicalVolume or through provided set methods SetOptimisation/IsToOptimise() Optimisation is turned on by default Optimisation for parameterised volumes can be chosen Along one single Cartesian axis Specifying the axis in the constructor for G4PVParameterised Using 3D voxelisation along the 3 Cartesian axes Specifying in kUndefined in the constructor for G4PVParameterised Detector Description - Geant4 Course

PART VI Detector Description: Advanced features

Detector Description Advanced features
Geant4: Detector description module Detector Description Advanced features Grouping volumes Reflections of volumes and hierarchies Detector regions User defined solids Debugging tools

Assembly volume

Grouping volumes To represent a regular pattern of positioned volumes, composing a more or less complex structure structures which are hard to describe with simple replicas or parameterised volumes structures which may consist of different shapes Too densely positioned to utilize a mother volume Assembly volume acts as an envelope for its daughter volumes its role is over once its logical volume has been placed daughter physical volumes become independent copies in the final structure Participating daughter logical volumes are treated as triplets logical volume translation w.r.t. envelop rotation w.r.t. envelop Detector Description - Geant4 Course

G4AssemblyVolume G4AssemblyVolume::AddPlacedVolume ( G4LogicalVolume* volume, G4ThreeVector& translation, G4RotationMatrix* rotation ); Helper class to combine daughter logical volumes in arbitrary way Imprints of the assembly volume are made inside a mother logical volume through G4AssemblyVolume::MakeImprint(…) Each physical volume name is generated automatically Format: av_WWW_impr_XXX_YYY_ZZZ WWW – assembly volume instance number XXX – assembly volume imprint number YYY – name of the placed logical volume in the assembly ZZZ – index of the associated logical volume Generated physical volumes (and related transformations) are automatically managed (creation and destruction) Be careful in the usage of G4AssemblyVolume. Unnecessary or incorrect use of it can lead to ‘proliferation’ of many volumes all placed in the same mother. Detector Description - Geant4 Course

G4AssemblyVolume : example
Geant4: Detector description module G4AssemblyVolume : example G4AssemblyVolume* assembly = new G4AssemblyVolume(); G4RotationMatrix Ra; G4ThreeVector Ta; Ta.setX(…); Ta.setY(…); Ta.setZ(…); assembly->AddPlacedVolume( plateLV, Ta, Ra ); … // repeat placement for each daughter for( unsigned int i = 0; i < layers; i++ ) { G4RotationMatrix Rm(…); G4ThreeVector Tm(…); assembly->MakeImprint( worldLV, Tm, Rm ); } Detector Description - Geant4 Course

Assembly of volumes: example -1
Geant4: Detector description module Assembly of volumes: example -1 // Define a plate G4VSolid* PlateBox = new G4Box( "PlateBox", plateX/2., plateY/2., plateZ/2. ); G4LogicalVolume* plateLV = new G4LogicalVolume( PlateBox, Pb, "PlateLV", 0, 0, 0 ); // Define one layer as one assembly volume G4AssemblyVolume* assemblyDetector = new G4AssemblyVolume(); // Rotation and translation of a plate inside the assembly G4RotationMatrix Ra; G4ThreeVector Ta; // Rotation of the assembly inside the world G4RotationMatrix Rm; // Fill the assembly by the plates Ta.setX( caloX/4. ); Ta.setY( caloY/4. ); Ta.setZ( 0. ); assemblyDetector->AddPlacedVolume( plateLV, G4Transform3D(Ra,Ta) ); Ta.setX( -1*caloX/4. ); Ta.setY( caloY/4. ); Ta.setZ( 0. ); Ta.setX( -1*caloX/4. ); Ta.setY( -1*caloY/4. ); Ta.setZ( 0. ); Ta.setX( caloX/4. ); Ta.setY( -1*caloY/4. ); Ta.setZ( 0. ); // Now instantiate the layers for( unsigned int i = 0; i < layers; i++ ) { // Translation of the assembly inside the world G4ThreeVector Tm( 0,0,i*(caloZ + caloCaloOffset) - firstCaloPos ); assemblyDetector->MakeImprint( worldLV, G4Transform3D(Rm,Tm) ); } Detector Description - Geant4 Course

Assembly of volumes: example -2
Geant4: Detector description module Assembly of volumes: example -2 In Geant4 8.1 (June) it will be possible to make assemblies of assemblies (new feature) Detector Description - Geant4 Course

Reflected volume

Reflecting solids Let's take an example of a pair of mirror symmetric volumes. Such geometry cannot be made by parallel transformation or 180 degree rotation. G4ReflectedSolid (derived from G4VSolid) Utility class representing a solid shifted from its original reference frame to a new mirror symmetric one The reflection (G4Reflect[X/Y/Z]3D) is applied as a decomposition into rotation and translation G4ReflectionFactory Singleton object using G4ReflectedSolid for generating placements of reflected volumes Reflections are currently limited to simple CSG solids. will be extended soon to all solids Detector Description - Geant4 Course

Reflecting hierarchies of volumes - 1
Geant4: Detector description module Reflecting hierarchies of volumes - 1 G4ReflectionFactory::Place(…) Used for normal placements: Performs the transformation decomposition Generates a new reflected solid and logical volume Retrieves it from a map if the reflected object is already created Transforms any daughter and places them in the given mother Returns a pair of physical volumes, the second being a placement in the reflected mother G4PhysicalVolumesPair Place(const G4Transform3D& transform3D, // the transformation const G4String& name, // the actual name G4LogicalVolume* LV, // the logical volume G4LogicalVolume* motherLV, // the mother volume G4bool noBool, // currently unused G4int copyNo) // optional copy number Detector Description - Geant4 Course

Reflecting hierarchies of volumes - 2
Geant4: Detector description module Reflecting hierarchies of volumes - 2 G4ReflectionFactory::Replicate(…) Creates replicas in the given mother volume Returns a pair of physical volumes, the second being a replica in the reflected mother G4PhysicalVolumesPair Replicate(const G4String& name, // the actual name G4LogicalVolume* LV, // the logical volume G4LogicalVolume* motherLV, // the mother volume Eaxis axis // axis of replication G4int replicaNo // number of replicas G4int width, // width of single replica G4int offset=0) // optional mother offset Detector Description - Geant4 Course

Cuts by Region Geant4 has had a unique production threshold (‘cut’) expressed in length (i.e. minimum range of secondary) For all volumes Possibly different for each particle. Yet appropriate length scales can vary greatly between different areas of a large detector E.g. a vertex detector (5 mm) and a muon detector (2.5 cm) Having a unique (low) cut can create a performance penalty Geant4 allows for several cuts Globally or per particle Enabling the tuning of production thresholds at the level of a sub-detector, i.e. region Cuts are applied only for gamma, electron and positron and only for processes which have infrared divergence Detector Description - Geant4 Course

Detector Region Concept of region: Set of geometry volumes, typically of a sub-system barrel + end-caps of the calorimeter; “Deep” areas of support structures can be a region. Or any group of volumes A set of cuts in range is associated to a region a different range cut for each particle among gamma, e-, e+ is allowed in a region Region B Default Region B Region A C Some Details: A region - Has one or several ‘root’ volumes The world is in a predefined ‘default region’ Detector Description - Geant4 Course

World Volume - Default Region
Region and cut World Volume - Default Region Root logical - Region A Each region has its unique set of cuts. World volume is recognized as the default region. The default cuts defined in Physics list are used for it. User is not allowed to define a region to the world volume or a cut to the default region A logical volume becomes a root logical volume once it is assigned to a region. All daughter volumes belonging to the root logical volume share the same region (and cut), unless a daughter volume itself becomes to another root Important restriction : No logical volume can be shared by more than one regions, regardless of root volume or not Root logical - Region B Detector Description - Geant4 Course

User defined solids All solids should derive from G4VSolid and implement its abstract interface will guarantee the solid is treated as any other solid predefined in the kernel Basic functionalities required for a solid Compute distances to/from the shape Detect if a point is inside the shape Compute the surface normal to the shape at a given point Compute the extent of the shape Provide few visualization/graphics utilities Detector Description - Geant4 Course

What a solid should reply to…- 1
Geant4: Detector description module What a solid should reply to…- 1 EInside Inside(const G4ThreeVector& p) const; Should return, considering a predefined tolerance: kOutside - if the point at offset p is outside the shapes boundaries kSurface - if the point is close less than Tolerance/2 from the surface kInside - if the point is inside the shape boundaries G4ThreeVector SurfaceNormal(const G4ThreeVector& p) const; Should return the outwards pointing unit normal of the shape for the surface closest to the point at offset p. G4double DistanceToIn(const G4ThreeVector& p, const G4ThreeVector& v) const; Should return the distance along the normalized vector v to the shape from the point at offset p. If there is no intersection, returns kInfinity. The first intersection resulting from ‘leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape Detector Description - Geant4 Course

What a solid should reply to…- 2
Geant4: Detector description module What a solid should reply to…- 2 G4double DistanceToIn(const G4ThreeVector& p) const; Calculates the distance to the nearest surface of a shape from an outside point p. The distance can be an underestimate G4double DistanceToOut(const G4ThreeVector& p, const G4ThreeVector& v, const G4bool calcNorm=false, G4bool* validNorm=0, G4ThreeVector* n=0) const; Returns the distance along the normalised vector v to the shape, from a point at an offset p inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored. If calcNorm is true, then it must also set validNorm to either: True - if the solid lies entirely behind or on the exiting surface. Then it must set n to the outwards normal vector (the Magnitude of the vector is not defined) False - if the solid does not lie entirely behind or on the exiting surface G4double DistanceToOut(const G4ThreeVector& p) const; Calculates the distance to the nearest surface of a shape from an inside point p. The distance can be an underestimate Detector Description - Geant4 Course

Solid: more functions…
Geant4: Detector description module Solid: more functions… G4bool CalculateExtent(const EAxis pAxis, const G4VoxelLimits& pVoxelLimit, const G4AffineTransform& pTransform, G4double& pMin, G4double& pMax) const; Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits. If the solid is not intersected by the region, return false, else return true Member functions for the purpose of visualization: void DescribeYourselfTo (G4VGraphicsScene& scene) const; “double dispatch” function which identifies the solid to the graphics scene G4VisExtent GetExtent () const; Provides extent (bounding box) as possible hint to the graphics view Detector Description - Geant4 Course

GGE (Graphical Geometry Editor)
Geant4: Detector description module GGE (Graphical Geometry Editor) Implemented in JAVA, GGE is a graphical geometry editor compliant to Geant4. It allows to: Describe a detector geometry including: materials, solids, logical volumes, placements Graphically visualize the detector geometry using a Geant4 supported visualization system, e.g. DAWN Store persistently the detector description Generate the C++ code according to the Geant4 specifications GGE can be downloaded from Web as a separate tool: Detector Description - Geant4 Course

Visualizing detector geometry tree
Geant4: Detector description module Visualizing detector geometry tree Built-in commands defined to display the hierarchical geometry tree As simple ASCII text structure Graphical through GUI (combined with GAG) As XML exportable format Implemented in the visualization module As an additional graphics driver G3 DTREE capabilities provided and more Detector Description - Geant4 Course

Computing volumes and masses
Geant4: Detector description module Computing volumes and masses Geometrical volume of a generic solid or boolean composition can be computed from the solid: G4double GetCubicVolume(); Overall mass of a geometry setup (subdetector) can be computed from the logical volume: G4double GetMass(G4Bool forced=false, G4Material* parameterisedMaterial=0); GetCubicVolume: Returns an estimation of the solid volume in internal units. Should be overloaded by the concrete solid implementation to perform exact computation of the volume quantity and eventually “cache” the computed value, such that it is NOT recomputed each time the method is called. GetMass: Returns the mass of the logical-volume tree computed from the estimated geometrical volume of each solid and material associated to the logical volume and its daughters. The computation may require a considerable amount of time, depending from the complexity of the geometry tree. The returned value is cached and can be used for successive calls (default), unless re-computation is forced by providing 'true' for the ‘forced’ argument in input. Computation should be forced if the geometry setup has changed after the previous call. An optional argument to specify a parameterised material is provided. Detector Description - Geant4 Course

Debugging geometries An overlapping volume is a contained volume which actually protrudes from its mother volume Volumes are also often positioned in a same volume with the intent of not provoking intersections between themselves. When volumes in a common mother actually intersect themselves are defined as overlapping Geant4 does not allow for malformed geometries The problem of detecting overlaps between volumes is bounded by the complexity of the solid models description Utilities are provided for detecting wrong positioning Graphical tools Kernel run-time commands Detector Description - Geant4 Course

Debugging tools: DAVID
Geant4: Detector description module Debugging tools: DAVID DAVID is a graphical debugging tool for detecting potential intersections of volumes Accuracy of the graphical representation can be tuned to the exact geometrical description. physical-volume surfaces are automatically decomposed into 3D polygons intersections of the generated polygons are parsed. If a polygon intersects with another one, the physical volumes associated to these polygons are highlighted in color (red is the default). DAVID can be downloaded from the Web as external tool for Geant4 Detector Description - Geant4 Course

Debugging run-time commands
Geant4: Detector description module Debugging run-time commands Built-in run-time commands to activate verification tests for the user geometry. Tests can be applied recursively to all depth levels (may require CPU time!): [recursion_flag] geometry/test/run [recursion_flag] or geometry/test/grid_test [recursion_flag] to start verification of geometry for overlapping regions based on a standard grid setup geometry/test/cylinder_test [recursion_flag] shoots lines according to a cylindrical pattern geometry/test/line_test [recursion_flag] to shoot a line along a specified direction and position geometry/test/position and geometry/test/direction to specify position & direction for the line_test Resolution/dimensions of grid/cylinders can be tuned To avoid spurious errors caused by round off, a tolerance of 0.1 micron is used by default. The tolerance can be adjusted as needed by the application through the run-time command: geometry/test/tolerance <new-value> Detector Description - Geant4 Course

Debugging run-time commands - 2
Geant4: Detector description module Debugging run-time commands - 2 Example layout: GeomTest: no daughter volume extending outside mother detected. GeomTest Error: Overlapping daughter volumes The volumes Tracker[0] and Overlap[0], both daughters of volume World[0], appear to overlap at the following points in global coordinates: (list truncated) length (cm) start position (cm) end position (cm) ----- Which in the mother coordinate system are: . . . Which in the coordinate system of Tracker[0] are: Which in the coordinate system of Overlap[0] are: Detector Description - Geant4 Course

Overlap Checking at Construction
Since Geant4 v8.0 it has been possible to check for overlaps at the time of construction Points are generated on the surface of a volume and checked against all other volumes already constructed Activated by including boolean flag in G4VPhysicalVolume(): G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog, “aBoxPhys”, pMotherLog, 0, copyNo, G4bool olap_test); Detector Description - Geant4 Course

Debugging tools: OLAP Uses tracking of neutral particles to verify boundary crossing in opposite directions Stand-alone batch application Provided as extended example Can be combined with a graphical environment and GUI (ex. Qt library) Integrated in the CMS Iguana Framework Detector Description - Geant4 Course

Debugging tools: OLAP Detector Description - Geant4 Course

Dynamic Geometries

Dynamic Geometries In some applications, it is essential to simulate the movement of some volumes. E.g. particle therapy simulation Geant4 can deal with moving volume In case speed of the moving volume is slow enough compared to speed of elementary particles, so that you can assume the position of moving volume is still within one event. Two tips to simulate moving objects : Use parameterized volume to represent the moving volume. Do not optimize (voxelize) the mother volume of the moving volume(s). Detector Description - Geant4 Course

Moving objects - tip Use parameterized volume to represent the moving volume. Use event number as a time stamp and calculate position/rotation of the volume as a function of event number. void MyMovingVolumeParameterisation::ComputeTransformation (const G4int copyNo, G4VPhysicalVolume *physVol) const { static G4RotationMatrix rMat; G4int eID = 0; const G4Event* evt = G4RunManager::GetRunManager()->GetCurrentEvent(); if(evt) eID = evt->GetEventID(); G4double t = 0.1*s*eID; G4double r = rotSpeed*t; G4double z = velocity*t+orig; while(z>0.*m) {z-=8.*m;} rMat.set(HepRotationX(-r)); physVol->SetTranslation(G4ThreeVector(0.,0.,z)); physVol->SetRotation(&rMat0); } Null pointer must be protected. This method is also invoked while geometry is being closed at the beginning of run, i.e. event loop has not yet began. Here, event number is converted to time. (0.1 sec/event) You are responsible not to make the moving volume get out of (protrude from) the mother volume. Position and rotation are set as the function of event number. Detector Description - Geant4 Course

Courtesy of the LHCb Collaboration Detector Description - Geant4 Course Vertex Locator in LHCb

SUSY events in the CMS detector
Courtesy of the CMS Collaboration SUSY events in the CMS detector

Snapshot of the ATLAS detector
Courtesy of the ATLAS Collaboration Snapshot of the ATLAS detector

Kamioka Liquid-scintillator Anti-Neutrino Detector
Courtesy of H.Ikeda (Tohoku)

Space Environments and Effects Section Courtesy T. Ersmark, KTH Stockholm Detector Description - Geant4 Course

Detector Description Summary
Geant4: Detector description module Detector Description Summary Part I The Basics Part II Logical and physical volumes Part III Solids, touchables Part IV Sensitive detector, digitizer & magnetic field Part V Visualization attributes & Optimization technique Part VI Advanced features and tips Detector Description - Geant4 Course

Geant4: Detector description module

Similar presentations

Presentation on theme: "Geant4: Detector description module"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Geant4: Detector description module

Similar presentations

Presentation on theme: "Geant4: Detector description module"— Presentation transcript:

Similar presentations

About project

Feedback