Symmetric_Moeller.cc

Go to the documentation of this file.

//! \file
//!
//! Source file for Symmetric_Moeller class.
//!
//! This defines the Symmetric_Moeller class and the member routines which
//! construct the OLYMPUS symmetric Moeller detector.
//!
//! \author Y. Ma based on code for olympus simulation package by D.K. Hasell
//! \version 1.0
//! \date 2010-10-11
//!
//! \ingroup detector

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

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

#include "Symmetric_Moeller.h"
#include "SM_SD.h"

// Include the GEANT4 header files used here.

#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4Tubs.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;

// Routines to define the OLYMPUS Luminosity_Monitor class.

// Constructor.

Symmetric_Moeller::Symmetric_Moeller() {}

// Destructor.

Symmetric_Moeller::~Symmetric_Moeller() {}

// Member function to build the SM detector.

void Symmetric_Moeller::Build( G4VPhysicalVolume * World_phys ) {

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

   G4double Width[N_SM]  = {10.,//collimator and PbF2 of positive x side
                            2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5,
                            10.,//collimator and PbF2 of negative x side
                            2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5};

   G4double Height[N_SM] = {10.,//collimator and PbF2 of positive x side
                            2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5,
                            10.,//collimator and PbF2 of negative x side
                            2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5};

   G4double Length[N_SM]  = {10.,//collimator and PbF2 of positive x side
                             16., 16., 16., 16., 16., 16., 16., 16., 16.,
                             10.,//collimator and PbF2 of negative x side
                             16., 16., 16., 16., 16., 16., 16., 16., 16.};

   G4double x[N_SM] = {3.8+5., //collimator and PbF2 of positive x side
                       3.8+6.25, 3.8+3.75, 3.8+1.25 ,3.8+6.25, 3.8+3.75,
                       3.8+1.25, 3.8+6.25, 3.8+3.75, 3.8+1.25,
                       -(3.8+5.), //collimator and PbF2 of negative x side
                       -(3.8+1.25), -(3.8+3.75), -(3.8+6.25),-(3.8+1.25),
                       -(3.8+3.75), -(3.8+6.25), -(3.8+1.25), -(3.8+3.75),
                       -(3.8+6.25)};

   G4double y[N_SM] = {0., //collimator and PbF2 of positive x side
                       2.5, 2.5, 2.5, 0., 0., 0., -2.5, -2.5, -2.5,
                       0.,//collimator and PbF2 of negative x side
                       2.5, 2.5, 2.5, 0., 0., 0., -2.5, -2.5, -2.5};

   G4double z[N_SM] = {335., //collimator and PbF2 of positive x side
                       345., 345, 345., 345., 345., 345., 345., 345., 345., 
                       335.,//collimator and PbF2 of negative x side
                       345., 345, 345., 345., 345., 345., 345., 345., 345.};

   // Set the units properly.
   
   for( int i = 0; i < N_SM; i++ ) {
      x[i] *= cm;
      y[i] *= cm;
      z[i] *= cm;

      Width[i]  *= cm;
      Height[i] *= cm;
      Length[i] *= cm;

      z[i] = z[i] + Length[i] / 2.0;
   }

   G4double Deg360 = 360.0 * degree;

   // Create an instance of the SM sensitive detector.

   SM_SD * SD = new SM_SD( "OLYMPUS/SM" );

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

   // Loop over the detectors.

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

      // Create the SM and place it.
  
      G4Box * SM_solid = new
         G4Box( "SM_solid", Width[i] / 2.0, Height[i] / 2.0, Length[i] / 2.0 );

     // If this is the collimator.

      if( i == 0 ) {
         
         G4Tubs * Col_hole = new
            G4Tubs( "Col_hole", 0.0, 1.0 * cm, 10.0 * cm, 0.0, Deg360 );   

         G4ThreeVector xTrans( -1.0 * cm, 0.0 , 0.0 );
       
         G4SubtractionSolid * SM_col =
            new G4SubtractionSolid( "SM_solid-Col_hole", SM_solid, Col_hole,
                                    0, xTrans );
       
         G4LogicalVolume * SM_log = new
            G4LogicalVolume( SM_col, G4Material::GetMaterial( "G4_Pb" ),
                             "SM_log", 0, 0, 0, true );

         SM_log->SetVisAttributes(
            G4VisAttributes( true, G4Color( 1.0, 1.0, 1.0 ) ) );

         new G4PVPlacement( 0, G4ThreeVector( x[i], y[i], z[i] ),
                            "SM_phys", SM_log, World_phys, false, i, false );

         // Make the SM sensitive.

         SM_log->SetSensitiveDetector( SD );
      }

      //for collimator

      else if( i == 10 ) {

         G4Tubs * Col_hole = new
            G4Tubs( "Col_hole", 0.0, 1.0 * cm, 10.0 * cm, 0.0, Deg360 );   

         G4ThreeVector xTrans( 1.0 * cm, 0.0, 0.0 );
       
         G4SubtractionSolid* SM_col = new
            G4SubtractionSolid("SM_solid-Col_hole", SM_solid, Col_hole,
                               0, xTrans );

         G4LogicalVolume * SM_log = new
            G4LogicalVolume( SM_col, G4Material::GetMaterial( "G4_Pb" ),
                             "SM_log", 0, 0, 0, true );

         SM_log->SetVisAttributes( G4VisAttributes( true, G4Color().White() ) );
         new G4PVPlacement( 0, G4ThreeVector( x[i], y[i], z[i] ),
                            "SM_phys", SM_log, World_phys, false, i, false );

         // Make the SM sensitive.

         SM_log->SetSensitiveDetector( SD );
      }

      //for PbF2 crystals

      else {

         G4LogicalVolume * SM_log = new
            G4LogicalVolume( SM_solid, G4Material::GetMaterial( "PbF2" ),
                             "SM_log", 0, 0, 0, true );

         SM_log->SetVisAttributes(
            G4VisAttributes( true, G4Color( 1.0, 1.0, 1.0 ) ) );

         new G4PVPlacement( 0, G4ThreeVector( x[i], y[i], z[i] ),
                            "SM_phys", SM_log, World_phys, false, i, false );

         // Make the SM sensitive.

         SM_log->SetSensitiveDetector( SD );
      }

   }

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

   // That's All Folks !

   return;
   
}