Gem_Tracker.cc

Go to the documentation of this file.

//! \file
//!
//! Source file for Gem_Tracker class.
//!
//! The Gem_Tracker class is used to build the GEM tracking detector
//! for the OLYMPUS detector simulation.
//!
//! \author D.K. Hasell
//! \version 1.0
//! \date 2010-10-15
//!
//! \ingroup detector

// *+****1****+****2****+****3****+****4****+****5****+****6****+****7****+****

// Include the GT header file and the user header files referenced here.

#include "Gem_Tracker.h"
#include "GT_SD.h"

// Include the GEANT4 header files referenced in this file.

#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4SubtractionSolid.hh"
#include "G4Material.hh"
#include "G4ThreeVector.hh"
#include "G4RotationMatrix.hh"
#include "G4VisAttributes.hh"
#include "G4Colour.hh"

#include "G4SDManager.hh"

// Use the standard namespace.

using namespace std;

// *+****1****+****2****+****3****+****4****+****5****+****6****+****7****+****

// Routines in the OLYMPUS Gem_Tracker class.

// Constructor.

Gem_Tracker::Gem_Tracker() {}

// Destructor.

Gem_Tracker::~Gem_Tracker() {}

// Member function to build the Gem_Tracker.

void Gem_Tracker::Build( G4VPhysicalVolume * World_phys ) {

   // Building the GT detector.
   
   G4cout << "Building the Gem_Tracker.\n" << flush;
   
   // Define the GT position and dimensions.

   G4double R[N_GT]     = {  50.00,  50.00 };
   
   G4double Theta[N_GT] = {  41.00,  41.00 };
   
   G4double Phi[N_GT]   = {   0.00, 180.00 };
   
   G4double Alpha[N_GT] = { -73.54,  73.54 };

   // Convert to proper units.

   for( int i = 0; i < N_GT; ++i ) {
      R[i]     *= cm;
      Theta[i] *= degree;
      Phi[i]   *= degree;
      Alpha[i] *= degree;
   }

   G4double SizeX  = 50.0 * 2.54 * cm;
   G4double SizeY  = 20.5 * 2.54 * cm;
   G4double SizeZ  =  1.5 * 2.54 * cm;
   G4double Frame  =  1.0 * 2.54 * cm;

   // Create an instance of the GT sensitive detector.

   GT_SD * SD = new GT_SD( "OLYMPUS/GT" );

   G4SDManager::GetSDMpointer()->AddNewDetector( SD );      

   // Loop over the detectors.

   for( int i = 0; i < N_GT; ++i ) {

      // Create the GT and place it.
   
      G4Box * GT_solid = new
         G4Box( "GT_solid", SizeX / 2.0, SizeY/ 2.0, SizeZ/ 2.0 );
   
      G4LogicalVolume * GT_log = new
         G4LogicalVolume( GT_solid, G4Material::GetMaterial( "WC_gas" ),
                          "GT_log", 0, 0, 0, true );
      
      GT_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );

      G4double costheta = cos( Theta[i] );
      G4double sintheta = sin( Theta[i] );
      G4double cosphi   = cos( Phi[i] );
      G4double sinphi   = sin( Phi[i] );

      // Note these rotations produce the correct local coordinates in the left
      // and right sectors assuming both detectors are identical.

      G4RotationMatrix * Rotation = new G4RotationMatrix;
      Rotation->rotateY( Alpha[i] );
      if( i == 1 ) Rotation->rotateZ( 180.0 * degree );

      new G4PVPlacement( Rotation, G4ThreeVector( R[i] * sintheta * cosphi,
                                                  R[i] * sintheta * sinphi,
                                                  R[i] * costheta ),
                         "GT_phys", GT_log, World_phys, false, i, false );
      
      // Create and place the gas volume.
   
      G4Box * GT_Gas_solid = new
         G4Box( "GT_Gas_solid", SizeX / 2.0 - Frame,
                SizeY / 2.0 - Frame, ( SizeZ + 0.01 * cm ) / 2.0 );
   
      G4LogicalVolume * GT_Gas_log = new
         G4LogicalVolume( GT_Gas_solid, G4Material::GetMaterial( "WC_gas" ),
                          "GT_Gas_log", 0, 0, 0, true );
   
      GT_Gas_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
      new G4PVPlacement( 0, G4ThreeVector(),
                         GT_Gas_log, "GT_Gas_phys", GT_log, false, i, false );
      
      // Create and place the frame.
      
      G4SubtractionSolid * GT_Frame_solid = new
         G4SubtractionSolid( "GT_Frame_solid", GT_solid, GT_Gas_solid );
      
      G4LogicalVolume * GT_Frame_log = new
         G4LogicalVolume( GT_Frame_solid, G4Material::GetMaterial( "NemaG10" ),
                          "GT_Frame_log", 0, 0, 0, true );

      GT_Frame_log->SetVisAttributes(
         G4VisAttributes( true, G4Colour( 0, 0.8, 0.8) ) );
      
      new G4PVPlacement( 0, G4ThreeVector(), GT_Frame_log, "GT_Frame_phys",
                         GT_log, false, i, false );
      
      // Create and place the drift volume.
   
      G4Box * GT_Drift_solid = new
         G4Box( "GT_Drift_solid", SizeX / 2.0 - Frame,
                SizeY / 2.0 - Frame, 0.3 * cm / 2.0 );
   
      G4LogicalVolume * GT_Drift_log = new
         G4LogicalVolume( GT_Drift_solid, G4Material::GetMaterial( "WC_gas" ),
                          "GT_Drift_log", 0, 0, 0, true );
   
      GT_Drift_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
      new G4PVPlacement( 0, G4ThreeVector( 0.0, 0.0,
                                           ( 0.3 * cm - SizeZ )/ 2.0 ),
                         GT_Drift_log, "GT_Drift_phys",
                         GT_Gas_log, false, i, false );
      
      // Make the drift volume sensitive.
      
      GT_Drift_log->SetSensitiveDetector( SD );
   
   }

   G4cout << "     Done.\n" << endl << flush;

   // That's All Folks !

   return;

}