MWPC.cc

Go to the documentation of this file.

//! \file
//!
//! Source file for MWPC class.
//!
//! The MWPC class is used to build the GEM tracking detector
//! 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 MW header file and the user header files referenced here.

#include "MWPC.h"
#include "MW_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 "G4UnionSolid.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 MWPC class.

// Constructor.

MWPC::MWPC() {}

// Destructor.

MWPC::~MWPC() {}

// Member function to build the MWPC.

void MWPC::Build( G4VPhysicalVolume * World_phys ) {

   // Building the MW detector.
   
   G4cout << "Building the MWPC detectors:\n" << flush;
   
   // Define the MW position and dimensions.
   
   G4double R[N_MW]      = { 200.0, 234.0, 268.0, 200.0, 234.0, 268.0 };
   
   G4double Theta[N_MW]  = {  12.0,  12.0,  12.0,  12.0,  12.0,  12.0 };

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

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

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

   G4double Width  = 18.0 * cm;
   G4double Height = 18.0 * cm;
   G4double Thick  =  5.0 * cm;

   // Create an instance of the MW sensitive detector.

   MW_SD * SD = new MW_SD( "OLYMPUS/MW" );

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

   // Loop over the detectors.

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

     // Create the MW and place it.
   
     G4Box * MW_Active = new
       G4Box( "MW_Active", Width / 2.0, Height / 2.0, Thick / 2.0 );
   
     // Add the electronics boxes.

     G4Box * MW_Elect = new
        G4Box( "MW_Elect", 33.5 * cm / 2.0, 5.4 * cm / 2.0,
               18.0 * cm / 2.0 );

     G4RotationMatrix * RotE1 = new G4RotationMatrix;
     RotE1->rotateZ( -22.05 * degree );

     G4UnionSolid * MW_S1 = new
        G4UnionSolid( "MW_S1", MW_Active, MW_Elect,
                      RotE1, G4ThreeVector( 0.5 * cm,  8.7 * cm, 11.5 * cm ) );

     G4RotationMatrix * RotE2 = new G4RotationMatrix;
     RotE2->rotateZ(  22.05 * degree );

     G4UnionSolid * MW_solid = new
        G4UnionSolid( "MW_solid", MW_S1, MW_Elect,
                      RotE2, G4ThreeVector( 0.5 * cm, -8.7 * cm, 11.5 * cm ) );

     G4LogicalVolume * MW_log = new
       G4LogicalVolume( MW_solid, G4Material::GetMaterial( "WC_gas" ),
         "MW_log", 0, 0, 0, true );
      
     MW_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 ),
                        "MW_phys", MW_log, World_phys, false, i, false );

     // Create and place the Gas volume.
   
     G4Box * MW_Gas_solid = new
       G4Box( "MW_Gas_solid", ( Width - 2.5 * cm ) / 2.0,
             ( Height - 2.5 * cm ) / 2.0, ( Thick + 0.01 * cm ) / 2.0 );
   
     G4LogicalVolume * MW_Gas_log = new
       G4LogicalVolume( MW_Gas_solid, G4Material::GetMaterial( "WC_gas" ),
         "MW_Gas_log", 0, 0, 0, true );
   
     MW_Gas_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
     new G4PVPlacement( 0, G4ThreeVector(), 
         MW_Gas_log, "MW_Gas_phys", MW_log, false, i, false );
      
     // Create the Frame volume.
      
     G4SubtractionSolid * MW_Frame_solid = new
       G4SubtractionSolid( "MW_Frame_solid", MW_solid, MW_Gas_solid );
      
     G4LogicalVolume * MW_Frame_log = new
       G4LogicalVolume( MW_Frame_solid, G4Material::GetMaterial( "NemaG10" ),
         "MW_Frame_log", 0, 0, 0, true );
      
     MW_Frame_log->SetVisAttributes( G4VisAttributes( true,
                        G4Colour( 1.0, 0.0, 0 ) ) );
      
     new G4PVPlacement( 0, G4ThreeVector(),
         MW_Frame_log, "MW_Frame_phys", MW_log, false, i, false );
      
     // Create the Drift volume.
   
     G4Box * MW_Drift_solid = new
       G4Box( "MW_Drift_solid", ( Width - 2.5 * cm ) / 2.0,
         ( Height - 2.5 * cm ) / 2.0, ( 1.0 * cm ) / 2.0 );
   
     G4LogicalVolume * MW_Drift_log = new
       G4LogicalVolume( MW_Drift_solid, G4Material::GetMaterial( "WC_gas" ),
                       "MW_Drift_log", 0, 0, 0, true );
   
     MW_Drift_log->SetVisAttributes( G4VisAttributes( false, G4Color() ) );
      
     new G4PVPlacement( 0, G4ThreeVector( 0.0, 0.0, 0.0 ),
         MW_Drift_log, "MW_Drift_phys", MW_log, false, i, false );
      
     // Make the Drift volume sensitive.
      
     MW_Drift_log->SetSensitiveDetector( SD );

     // Place the electronics.

     G4LogicalVolume * MW_Elect_log = new
       G4LogicalVolume( MW_Elect, G4Material::GetMaterial( "G4_C" ),
                       "MW_Elect_log", 0, 0, 0, true );
   
     MW_Elect_log->SetVisAttributes(
        G4VisAttributes( true, G4Color( 1.0, 1.0, 0.0 ) ) );
      
     new G4PVPlacement( RotE1, G4ThreeVector( 0.5 * cm,  8.7 * cm, 11.5 * cm ),
         MW_Elect_log, "MW_Elect_phys", MW_log, false, i, false );
      
     new G4PVPlacement( RotE2, G4ThreeVector( 0.5 * cm, -8.7 * cm, 11.5 * cm ),
         MW_Elect_log, "MW_Elect_phys", MW_log, false, i, false );
      
   }

   // Add the support beams.

   G4Box * MW_Beam_solid = new
      G4Box( "MW_Beam_solid", 3.0 * cm / 2.0, 3.0 * cm / 2.0, 120 * cm / 2.0 );
   
   G4LogicalVolume * MW_Beam_log = new
      G4LogicalVolume( MW_Beam_solid, G4Material::GetMaterial( "G4_Al" ),
                       "MW_Beam_log", 0, 0, 0, true );
   
   MW_Beam_log->SetVisAttributes(
      G4VisAttributes( true, G4Color( 0.663, 0.675, 0.714 ) ) );
   
   G4double R_B = 240.0 * cm;
   G4double angle = 12.0 * degree;
   G4double cosang = cos( angle );
   G4double sinang = sin( angle );

   G4RotationMatrix * Rot1 = new G4RotationMatrix;
   Rot1->rotateY( -angle );

   new G4PVPlacement( Rot1,
                      G4ThreeVector( R_B * sinang + 12.0 * cm * cosang,
                                     5.0 * cm,
                                     R_B * cosang - 12.0 * cm * sinang ),
                      "MW_Beam_phys",
                      MW_Beam_log, World_phys, false, 0, false );

   new G4PVPlacement( Rot1,
                      G4ThreeVector( R_B * sinang + 12.0 * cm * cosang,
                                     -5.0 * cm,
                                     R_B * cosang - 12.0 * cm * sinang ),
                      "MW_Beam_phys",
                      MW_Beam_log, World_phys, false, 1, false );

   G4RotationMatrix * Rot2 = new G4RotationMatrix;
   Rot2->rotateY( angle );

   new G4PVPlacement( Rot2,
                      G4ThreeVector( -R_B * sinang - 12.0 * cm * cosang,
                                     5.0 * cm,
                                     R_B * cosang - 12.0 * cm * sinang ),
                      "MW_Beam_phys",
                      MW_Beam_log, World_phys, false, 2, false );

   new G4PVPlacement( Rot2,
                      G4ThreeVector( -R_B * sinang - 12.0 * cm * cosang,
                                     -5.0 * cm,
                                     R_B * cosang - 12.0 * cm * sinang ),
                      "MW_Beam_phys",
                      MW_Beam_log, World_phys, false, 3, false );

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

   // That's All Folks !

   return;

}