Detector construction class to define materials and geometry. More...

#include <Doxymodules_basic.h>

Inheritance diagram for B2bDetectorConstruction:

Public Member Functions
	B2bDetectorConstruction ()
virtual	~B2bDetectorConstruction ()
virtual G4VPhysicalVolume *	Construct ()
void	SetMagField (G4double)
void	SetTargetMaterial (G4String)
void	SetChamberMaterial (G4String)
void	SetMaxStep (G4double)
void	SetCheckOverlaps (G4bool)
Private Member Functions
void	DefineMaterials ()
G4VPhysicalVolume *	DefineVolumes ()
Private Attributes
G4LogicalVolume *	fLogicTarget
G4LogicalVolume *	fLogicChamber
G4Material *	fTargetMaterial
G4Material *	fChamberMaterial
G4UserLimits *	fStepLimit
B2bDetectorMessenger *	fMessenger
B2MagneticField *	fMagField
G4bool	fCheckOverlaps

Detailed Description

Detector construction class to define materials and geometry.

In addition a transverse uniform magnetic field is defined in SetMagField() method which can be activated via a command defined in the B2bDetectorMessenger class.

Definition at line 58 of file Doxymodules_basic.h.

Constructor & Destructor Documentation

B2bDetectorConstruction::B2bDetectorConstruction ( )

Definition at line 60 of file B2bDetectorConstruction.cc.

: 
 fLogicTarget(NULL), fLogicChamber(NULL), 
 fTargetMaterial(NULL), fChamberMaterial(NULL), 
 fStepLimit(NULL),
 fCheckOverlaps(true)
{
  fMessenger = new B2bDetectorMessenger(this);
  fMagField  = new B2MagneticField();
}

B2bDetectorConstruction::~B2bDetectorConstruction ( ) [virtual]

Definition at line 73 of file B2bDetectorConstruction.cc.

{
  delete fMagField;
  delete fStepLimit;
  delete fMessenger;             
}

Member Function Documentation

G4VPhysicalVolume * B2bDetectorConstruction::Construct ( ) [virtual]

Implements G4VUserDetectorConstruction.

Definition at line 82 of file B2bDetectorConstruction.cc.

{
  // Define materials
  DefineMaterials();

  // Define volumes
  return DefineVolumes();
}

void B2bDetectorConstruction::SetMagField ( G4double fieldValue )

Definition at line 331 of file B2bDetectorConstruction.cc.

{
  fMagField->SetMagFieldValue(fieldValue);
}

void B2bDetectorConstruction::SetTargetMaterial ( G4String materialName )

Definition at line 287 of file B2bDetectorConstruction.cc.

{
  G4NistManager* nistManager = G4NistManager::Instance();
  G4bool fromIsotopes = false;

  G4Material* pttoMaterial =
              nistManager->FindOrBuildMaterial(materialName, fromIsotopes);

  if (fTargetMaterial != pttoMaterial) {
     if ( pttoMaterial ) {
        fTargetMaterial = pttoMaterial;
        if (fLogicTarget) fLogicTarget->SetMaterial(fTargetMaterial);
        G4cout << "\n----> The target is made of " << materialName << G4endl;
     } else {
        G4cout << "\n-->  WARNING from SetTargetMaterial : "
               << materialName << " not found" << G4endl;
     }
  }
}

void B2bDetectorConstruction::SetChamberMaterial ( G4String materialName )

Definition at line 309 of file B2bDetectorConstruction.cc.

{
  G4NistManager* nistManager = G4NistManager::Instance();
  G4bool fromIsotopes = false;

  G4Material* pttoMaterial =
              nistManager->FindOrBuildMaterial(materialName, fromIsotopes);

  if (fChamberMaterial != pttoMaterial) {
     if ( pttoMaterial ) {
        fChamberMaterial = pttoMaterial;
        if (fLogicChamber) fLogicChamber->SetMaterial(fChamberMaterial);
        G4cout << "\n----> The chambers are made of " << materialName << G4endl;
     } else {
        G4cout << "\n-->  WARNING from SetChamberMaterial : "
               << materialName << " not found" << G4endl;
     }
  }
}

void B2bDetectorConstruction::SetMaxStep ( G4double maxStep )

Definition at line 338 of file B2bDetectorConstruction.cc.

{
  if ((fStepLimit)&&(maxStep>0.)) fStepLimit->SetMaxAllowedStep(maxStep);
}

void B2bDetectorConstruction::SetCheckOverlaps ( G4bool )

void B2bDetectorConstruction::DefineMaterials ( ) [private]

Definition at line 93 of file B2bDetectorConstruction.cc.

{
  // Material definition 

  G4NistManager* nistManager = G4NistManager::Instance();

  G4bool fromIsotopes = false;

  // Air defined using NIST Manager
  nistManager->FindOrBuildMaterial("G4_AIR", fromIsotopes);
  
  // Lead defined using NIST Manager
  fTargetMaterial  = nistManager->FindOrBuildMaterial("G4_Pb", fromIsotopes);

  // Xenon gas defined using NIST Manager
  fChamberMaterial = nistManager->FindOrBuildMaterial("G4_Xe", fromIsotopes);

  // Print materials
  G4cout << *(G4Material::GetMaterialTable()) << G4endl;
}

G4VPhysicalVolume * B2bDetectorConstruction::DefineVolumes ( ) [private]

Set additional contraints on the track, with G4UserSpecialCuts

G4double maxLength = 2*trackerLength, maxTime = 0.1*ns, minEkin = 10*MeV; trackerLV->SetUserLimits(new G4UserLimits(maxStep, maxLength, maxTime, minEkin));

Definition at line 116 of file B2bDetectorConstruction.cc.

{
  G4Material* air  = G4Material::GetMaterial("G4_AIR");

  // Sizes of the principal geometrical components (solids)
  
  G4int NbOfChambers = 5;
  G4double chamberSpacing = 80*cm; // from chamber center to center!

  G4double chamberWidth = 20.0*cm; // width of the chambers
  G4double targetLength =  5.0*cm; // full length of Target
  
  G4double trackerLength = (NbOfChambers+1)*chamberSpacing;

  G4double worldLength = 1.2 * (2*targetLength + trackerLength);

  G4double targetRadius  = 0.5*targetLength;   // Radius of Target
  targetLength = 0.5*targetLength;             // Half length of the Target  
  G4double trackerSize   = 0.5*trackerLength;  // Half length of the Tracker

  // Definitions of Solids, Logical Volumes, Physical Volumes

  // World

  G4GeometryManager::GetInstance()->SetWorldMaximumExtent(worldLength);

  G4cout << "Computed tolerance = "
         << G4GeometryTolerance::GetInstance()->GetSurfaceTolerance()/mm
         << " mm" << G4endl;

  G4Box* worldS
    = new G4Box("world",                                    //its name
                worldLength/2,worldLength/2,worldLength/2); //its size
  G4LogicalVolume* worldLV
    = new G4LogicalVolume(
                 worldS,   //its solid
                 air,      //its material
                 "World"); //its name
  
  //  Must place the World Physical volume unrotated at (0,0,0).
  // 
  G4VPhysicalVolume* worldPV
    = new G4PVPlacement(
                 0,               // no rotation
                 G4ThreeVector(), // at (0,0,0)
                 worldLV,         // its logical volume
                 "World",         // its name
                 0,               // its mother  volume
                 false,           // no boolean operations
                 0,               // copy number
                 fCheckOverlaps); // checking overlaps 

  // Target
  
  G4ThreeVector positionTarget = G4ThreeVector(0,0,-(targetLength+trackerSize));

  G4Tubs* targetS
    = new G4Tubs("target",0.,targetRadius,targetLength,0.*deg,360.*deg);
  fLogicTarget
    = new G4LogicalVolume(targetS, fTargetMaterial,"Target",0,0,0);
  new G4PVPlacement(0,              // no rotation
                    positionTarget, // at (x,y,z)
                    fLogicTarget,   // its logical volume
                    "Target",       // its name
                    worldLV,        // its mother volume
                    false,          // no boolean operations
                    0,              // copy number
                    fCheckOverlaps); // checking overlaps 

  G4cout << "Target is " << 2*targetLength/cm << " cm of "
         << fTargetMaterial->GetName() << G4endl;

  // Tracker
 
  G4ThreeVector positionTracker = G4ThreeVector(0,0,0);

  G4Tubs* trackerS
    = new G4Tubs("tracker",0,trackerSize,trackerSize, 0.*deg, 360.*deg);
  G4LogicalVolume* trackerLV
    = new G4LogicalVolume(trackerS, air, "Tracker",0,0,0);  
  new G4PVPlacement(0,               // no rotation
                    positionTracker, // at (x,y,z)
                    trackerLV,       // its logical volume
                    "Tracker",       // its name
                    worldLV,         // its mother  volume
                    false,           // no boolean operations
                    0,               // copy number
                    fCheckOverlaps); // checking overlaps 

  // Tracker segments
  
  // An example of Parameterised volumes
  // Dummy values for G4Tubs -- modified by parameterised volume

  G4Tubs* chamberS
    = new G4Tubs("tracker",0, 100*cm, 100*cm, 0.*deg, 360.*deg);
  fLogicChamber 
    = new G4LogicalVolume(chamberS,fChamberMaterial,"Chamber",0,0,0);
  
  G4double firstPosition = -trackerSize + chamberSpacing;
  G4double firstLength   = trackerLength/10;
  G4double lastLength    = trackerLength;

  G4VPVParameterisation* chamberParam =
    new B2bChamberParameterisation(
                                  NbOfChambers,   // NoChambers
                                  firstPosition,  // Z of center of first
                                  chamberSpacing, // Z spacing of centers
                                  chamberWidth,  // chamber width
                                  firstLength,    // initial length 
                                  lastLength);    // final length
                           
  // dummy value : kZAxis -- modified by parameterised volume

  new G4PVParameterised("Chamber",       // their name
                        fLogicChamber,   // their logical volume
                        trackerLV,       // Mother logical volume
                        kZAxis,          // Are placed along this axis 
                        NbOfChambers,    // Number of chambers
                        chamberParam,    // The parametrisation
                        fCheckOverlaps); // checking overlaps 

  G4cout << "There are " << NbOfChambers << " chambers in the tracker region. "
         << "\nThe chambers are " << chamberWidth/cm << " cm of " 
         << fChamberMaterial->GetName() << "\nThe distance between chamber is "
         << chamberSpacing/cm << " cm" << G4endl;

  // Sensitive detectors

  G4String trackerChamberSDname = "B2/TrackerChamberSD";
  B2TrackerSD* aTrackerSD = new B2TrackerSD(trackerChamberSDname,
                                            "TrackerHitsCollection");
  G4SDManager::GetSDMpointer()->AddNewDetector( aTrackerSD );
  fLogicChamber->SetSensitiveDetector( aTrackerSD );

  // Visualization attributes

  G4VisAttributes* boxVisAtt= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
  worldLV   ->SetVisAttributes(boxVisAtt);  
  fLogicTarget ->SetVisAttributes(boxVisAtt);
  trackerLV ->SetVisAttributes(boxVisAtt);

  G4VisAttributes* chamberVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,0.0));
  fLogicChamber->SetVisAttributes(chamberVisAtt);
  
  // Example of User Limits
  //
  // Below is an example of how to set tracking constraints in a given
  // logical volume
  //
  // Sets a max step length in the tracker region, with G4StepLimiter

  G4double maxStep = 0.5*chamberWidth;
  fStepLimit = new G4UserLimits(maxStep);
  trackerLV->SetUserLimits(fStepLimit);
  

  // Always return the physical world

  return worldPV;
}