Luminosity_Monitor.cc

Go to the documentation of this file.

//! \file
//!
//! Source file for Luminosity_Monitor class.
//!
//! The Luminosity_Monitor class is used to build the Luminosity Monitor
//! for the OLYMPUS detector simulation.
//!
//! \author D.K. Hasell
//! \version 1.0
//! \date 2010-10-31
//!
//! \ingroup detector

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

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

#include "Luminosity_Monitor.h"
#include "LM_SD.h"

// Include the GEANT4 header files used here.

#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 to define the OLYMPUS Luminosity_Monitor class.

// Constructor.

Luminosity_Monitor::Luminosity_Monitor() {}

// Destructor.

Luminosity_Monitor::~Luminosity_Monitor() {}

// Member function to build the beamline.

void Luminosity_Monitor::Build( G4VPhysicalVolume * World_phys ) {

   // Building the LM detector.
   
   G4cout << "Building the Lumi detectors:\n" << flush;
   
   // Define the LM position and dimensions.
   
//   G4double R[N_LM]      = { 187.0, 237.0, 287.0, 187.0, 237.0, 287.0 };
   G4double R[N_LM]      = { 187.0, 222.0, 256.0, 187.0, 222.0, 256.0 };
   
   G4double Theta[N_LM]  = {  12.0,  12.0,  12.0,  12.0,  12.0,  12.0 };

   G4double Phi[N_LM]    = {   0.0,   0.0,   0.0, 180.0, 180.0, 180.0 };

   G4double Alpha[N_LM]  = { -12.0, -12.0, -12.0,  12.0,  12.0,  12.0 };

   // Set the units properly.
   
   for( int i = 0; i < N_LM; ++i ) {
      R[i]      *= cm;
      Theta[i]  *= degree;
      Phi[i]    *= degree;
      Alpha[i]  *= degree;
   }

   G4double Width  = 12.5 * cm;
   G4double Height = 12.5 * cm;
   G4double Thick  =  1.5 * cm;

   // Create an instance of the LM sensitive detector.

   LM_SD * SD = new LM_SD( "OLYMPUS/LM" );

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

   // Loop over the detectors.

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

     // Create the LM and place it.
   
     G4Box * LM_solid = new
       G4Box( "LM_solid", Width / 2.0, Height / 2.0, Thick / 2.0 );
   
     G4LogicalVolume * LM_log = new
       G4LogicalVolume( LM_solid, G4Material::GetMaterial( "WC_gas" ),
         "LM_log", 0, 0, 0, true );
      
     LM_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 the detectors are identical.

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

     new G4PVPlacement( Rotation, G4ThreeVector( R[i] * sintheta * cosphi,
                   R[i] * sintheta * sinphi,
                   R[i] * costheta ),
         "LM_phys", LM_log, World_phys, false, i, false );

     // Create and place the Gas volume.
   
     G4Box * LM_Gas_solid = new
       G4Box( "LM_Gas_solid", ( Width - 2.5 * cm ) / 2.0,
             ( Height - 2.5 * cm ) / 2.0, ( Thick + 0.01 * cm ) / 2.0 );
   
     G4LogicalVolume * LM_Gas_log = new
       G4LogicalVolume( LM_Gas_solid, G4Material::GetMaterial( "WC_gas" ),
         "LM_Gas_log", 0, 0, 0, true );
   
     LM_Gas_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
     new G4PVPlacement( 0, G4ThreeVector(), 
         LM_Gas_log, "LM_Gas_phys", LM_log, false, i, false );
      
     // Create the Frame volume.
      
     G4SubtractionSolid * LM_Frame_solid = new
       G4SubtractionSolid( "LM_Frame_solid", LM_solid, LM_Gas_solid );
      
     G4LogicalVolume * LM_Frame_log = new
       G4LogicalVolume( LM_Frame_solid, G4Material::GetMaterial( "NemaG10" ),
         "LM_Frame_log", 0, 0, 0, true );
      
     LM_Frame_log->SetVisAttributes( G4VisAttributes( true,
                        G4Colour( 0, 0.8, 0 ) ) );
      
     new G4PVPlacement( 0, G4ThreeVector(),
         LM_Frame_log, "LM_Frame_phys", LM_log, false, i, false );
      
     // Create the Drift volume.
   
     G4Box * LM_Drift_solid = new
       G4Box( "LM_Drift_solid", ( Width - 2.5 * cm ) / 2.0,
         ( Height - 2.5 * cm ) / 2.0, ( 0.3 * cm ) / 2.0 );
   
     G4LogicalVolume * LM_Drift_log = new
       G4LogicalVolume( LM_Drift_solid, G4Material::GetMaterial( "WC_gas" ),
                       "LM_Drift_log", 0, 0, 0, true );
   
     LM_Drift_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
     new G4PVPlacement( 0, G4ThreeVector( 0.0, 0.0, ( 0.3 * cm - Thick ) / 2.0 ),
         LM_Drift_log, "LM_Drift_phys", LM_log, false, i, false );
      
     // Make the Drift volume sensitive.
      
     LM_Drift_log->SetSensitiveDetector( SD );
   
   }

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

   // That's All Folks !

   return;

}