LArG4::BarrelCryostat::CalibrationMixedCalculator Class Reference

#include <CryostatCalibrationMixedCalculator.h>

Inheritance diagram for LArG4::BarrelCryostat::CalibrationMixedCalculator:

Collaboration diagram for LArG4::BarrelCryostat::CalibrationMixedCalculator:

Public Member Functions
	CalibrationMixedCalculator (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode	initialize () override final
virtual	~CalibrationMixedCalculator ()
virtual G4bool	Process (const G4Step *step, LArG4Identifier &identifier, std::vector< G4double > &energies, const eCalculatorProcessing process=kEnergyAndID) const override final

Private Attributes
CaloG4::SimulationEnergies	m_energyCalculator
ServiceHandle< ILArCalibCalculatorSvc >	m_backupCalculator

Detailed Description

Definition at line 44 of file LArG4Barrel/src/CryostatCalibrationMixedCalculator.h.

Constructor & Destructor Documentation

CalibrationMixedCalculator()

LArG4::BarrelCryostat::CalibrationMixedCalculator::CalibrationMixedCalculator	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 39 of file CryostatCalibrationMixedCalculator.cxx.

  : LArCalibCalculatorSvcImp(name, pSvcLocator)
  , m_backupCalculator("BarrelCryostatCalibrationLArCalculator",name)
    {
       declareProperty("BackupCalculator", m_backupCalculator);
    }

~CalibrationMixedCalculator()

LArG4::BarrelCryostat::CalibrationMixedCalculator::~CalibrationMixedCalculator ( )

virtual

Definition at line 54 of file CryostatCalibrationMixedCalculator.cxx.

    {
      // Cleanup pointers.
      //delete m_backupCalculator;
      //m_backupCalculator = 0;
    }

Member Function Documentation

initialize()

StatusCode LArG4::BarrelCryostat::CalibrationMixedCalculator::initialize ( )

finaloverride

Definition at line 46 of file CryostatCalibrationMixedCalculator.cxx.

                                                      {
      // Get a "backup" calculator.
      ATH_CHECK(m_backupCalculator.retrieve());
 
      return StatusCode::SUCCESS;
    }

Process()

G4bool LArG4::BarrelCryostat::CalibrationMixedCalculator::Process ( const G4Step *  step, LArG4Identifier &  identifier, std::vector< G4double > &  energies, const eCalculatorProcessing  process = kEnergyAndID  ) const

finaloverridevirtual

Definition at line 79 of file CryostatCalibrationMixedCalculator.cxx.

    {
      // Use the calculators to determine the energies and the
      // identifier associated with this G4Step.  Note that the
      // default is to process both the energy and the ID.
 
      if ( process == kEnergyAndID  ||  process == kOnlyEnergy )
        {
          m_energyCalculator.Energies( step, energies );
        }
      else
        for (unsigned int i=0; i != 4; i++) energies.push_back( 0. );
 
 
      identifier.clear();
      if ( process == kEnergyAndID  ||  process == kOnlyID )
        {
          // Calculate the identifier.
 
          // Note:
          // LArG4::BarrelCryostat::CryostatCalibrationCalculator uses
          // a table-based approach to determine the identifier.  The
          // following code uses an "if-statement" approach.
 
          // The fixed parameters (only a couple of which are readily
          // accessible from the database):
 
          constexpr double oneOverDeta = 10.;       //   1/Deta = 1./0.1 = 10.
          constexpr double oneOverDphi = 32./M_PI;  //   1/Dphi
 
          // Calculate the mid-point of the step, and the simple geometry variables.
          G4VPhysicalVolume* physical = step->GetPreStepPoint()->GetPhysicalVolume();
          //G4int copyNumber = physical->GetCopyNo();
          G4String volumeName = physical->GetLogicalVolume()->GetName();
 
          G4StepPoint* pre_step_point = step->GetPreStepPoint();
          G4StepPoint* post_step_point = step->GetPostStepPoint();
 
          G4ThreeVector startPoint = pre_step_point->GetPosition();
          G4ThreeVector endPoint   = post_step_point->GetPosition();
          G4ThreeVector p = (startPoint + endPoint) * 0.5;
 
          G4double rho = p.perp();
          G4double eta = fabs( p.pseudoRapidity() );
          G4double phi = p.phi();
          if ( phi < 0. ) phi += 2.*M_PI; // Normalize for phiBin calculation
 
          // Initialize identifier variables with (invalid) default
          // values (INT_MIN is defined in <climits>).
          G4int sampling = INT_MIN;
          G4int region = INT_MIN;
          G4int etaBin = INT_MIN;
          // subdet = +/-4    "+" or " -" according to sign of Z in World coorinate
          G4int subdet = ( p.z() > 0.) ? 4 : -4;
          G4int type = 1;
          G4int phiBin = (int) ( phi * oneOverDphi );
          if (phiBin>63) phiBin=0;
 
          constexpr double rho12 = 1386.+10.; // use old hardcoded 1386 for Sampling 1-2 transition
                                              // and add 10mm for safety (misalignment)
 
          if ( eta < 1.0 )
            {
              if ( rho < rho12) // LAr::Barrel::Cryostat::OuterWall
                {
                  sampling = 1;
                  region = 1;
                  etaBin = (int) ( eta * oneOverDeta );
                }
              else
                {
                  sampling = 2;
                  region = 0;
                  etaBin = (int) ( eta * oneOverDeta );
                }
            }
          else if ( eta < 1.5 )
            {
              if ( rho < rho12) // LAr::Barrel::Cryostat::OuterWall
                {
                  sampling = 1;
                  region = 1;
                  etaBin = (int) ( eta * oneOverDeta );
                }
              else
                {
                  sampling = 2;
                  region = 2;
                  etaBin = (int) ( (eta-1.) * oneOverDeta );
                }
            }
          else if ( eta < 1.6 )
            {
              sampling = 1;
              region = 4;
              etaBin = (int) ( (eta-1.5) * oneOverDeta );
            }
          else if ( eta < 1.8 )
            {
              sampling = 1;
              region = 5;
              etaBin = (int) ( (eta-1.5) * oneOverDeta );
            }
          else
            {
              sampling = 1;
              region = 6;
              etaBin = (int) ( (eta-1.3) * oneOverDeta );
            }
 
          // What if we have a G4Step that isn't handled by the above
          // code?  Answer: Use a "backup" calculator to try to
          // process the step.
 
          if ( type     == INT_MIN  ||
               region   == INT_MIN  ||
               sampling == INT_MIN  ||
               etaBin   == INT_MIN  ||
               phiBin   <  0 )
            {
#if defined (DEBUG_VOLUMES) || defined (DEBUG_HITS)
              constexpr G4int messageMax = 10;
              static std::atomic<G4int> messageCount = 0;
              if ( messageCount++ < messageMax )
                {
                  std::cout << "LArG4::BarrelCryostat::CalibrationMixedCalculator::Process"
                            << " (error " << messageCount << " of " << messageMax << " max displayed)"
                            << std::endl
                            << "   G4Step in '"
                            << step->GetPreStepPoint()->GetPhysicalVolume()->GetName()
                            << "', using backup calculator"
                            << std::endl;
                }
#endif
              m_backupCalculator->Process(step, identifier, energies, process);
            }
          else
            {
              // Append the cell ID to the (empty) identifier.
              identifier << 10         // Calorimeter
                           << subdet     // LAr +/-4 where "+" or " -" according to
                                         // the sign of Z in World coorinate
                           << type
                           << sampling
                           << region
                           << etaBin
                           << phiBin;
            }
        }
 
#ifdef DEBUG_HITS
      G4double energy = accumulate(energies.begin(),energies.end(),0.);
      std::cout << "LArG4::BarrelCryostat::CalibrationMixedCalculator::Process"
                << " ID=" << std::string(identifier)
                << " energy=" << energy
                << " energies=(" << energies[0]
                << "," << energies[1]
                << "," << energies[2]
                << "," << energies[3] << ")"
                << std::endl;
#endif
 
      // Check for bad result.
      if ( identifier == LArG4Identifier() )
        return false;
 
      return true;
    }

Member Data Documentation

m_backupCalculator

ServiceHandle<ILArCalibCalculatorSvc> LArG4::BarrelCryostat::CalibrationMixedCalculator::m_backupCalculator

private

Definition at line 69 of file LArG4Barrel/src/CryostatCalibrationMixedCalculator.h.

m_energyCalculator

CaloG4::SimulationEnergies LArG4::BarrelCryostat::CalibrationMixedCalculator::m_energyCalculator

private

Definition at line 67 of file LArG4Barrel/src/CryostatCalibrationMixedCalculator.h.

---

The documentation for this class was generated from the following files:

• LArG4Barrel/src/CryostatCalibrationMixedCalculator.h
• CryostatCalibrationMixedCalculator.cxx