LArBarrelCalibrationCalculator.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/********************************************************************
 
NAME:     CalibrationCalculator.cxx
PACKAGE:  offline/LArCalorimeter/LArG4/LArG4Barrel
 
AUTHORS:  G. Unal, L. Carminati (on a template from Bill Selingman)
CREATED:  September, 2004
 
PURPOSE:  This class calculates the values needed for calibration hits
          in the barrel LAr calorimeter. This calculator is called
          in calibration runs (see LArBarrelSDConsultant) for calibration
          hits in the accordion (no presampler).
 
UPDATES:
 
********************************************************************/
 
//#define DEBUG_HITS
 
#include "LArBarrelCalibrationCalculator.h"
 
#include "LArG4Code/LArG4Identifier.h"
 
#include "G4Step.hh"
#include "globals.hh"
#include <algorithm>
 
namespace LArG4 {
 
  namespace Barrel {
 
    CalibrationCalculator::CalibrationCalculator(const std::string& name, ISvcLocator *pSvcLocator)
      : LArCalibCalculatorSvcImp(name, pSvcLocator)
    {
    }
 
    StatusCode CalibrationCalculator::initialize() {
      // Initialize the geometry calculator.
      ATH_CHECK(m_geometryCalculator.retrieve());
      return StatusCode::SUCCESS;
    }
 
    G4bool CalibrationCalculator::Process(const G4Step* step,
                                          LArG4Identifier & identifier,
                                          LArG4Identifier & identifier_sr,
                                          std::vector<G4double> & energies,
                                          const eCalculatorProcessing process) const
    {
      // 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 ) {
#ifdef DEBUG_HITS
          std::cout << "LArG4::Barrel::CalibrationCalculator::Process"
                    << " calling SimulationEnergies" << std::endl;
#endif
          m_energyCalculator.Energies( step, energies );
      }
      else {
        for (unsigned int i=0; i != 4; i++) energies.push_back( 0. );
      }
 
 
      if ( process == kEnergyAndID  ||  process == kOnlyID )
        {
          // Calculate the identifier.
          identifier = m_geometryCalculator->CalculateIdentifier( step );
          if ( m_calculateSuperResolutionIdentifier )
            {
              identifier_sr = m_geometryCalculator->CalculateSuperResolutionIdentifier( step );
            }
        }
      else{
        identifier = LArG4Identifier();
        identifier_sr = LArG4Identifier();
      }
      
        [[maybe_unused]] unsigned short sr_value = 0;
        if (identifier_sr.fields() > 0) {
            sr_value = static_cast<unsigned short>(identifier_sr[0]); // Get the first field as unsigned
        }
 
        else{
          sr_value = 0; // Default value if no fields
        }
#ifdef DEBUG_HITS
      G4double energy = accumulate(energies.begin(),energies.end(),0.);
      std::cout << "LArG4::Barrel::CalibrationCalculator::Process"
                << " ID=" << std::string(identifier)
                << " energy=" << energy
                << " energies=(" << energies[0]
                << "," << energies[1]
                << "," << energies[2]
                << "," << energies[3] << ")"
                << std::endl;
#endif
        
      // Check for bad result.
      return ( identifier != LArG4Identifier() && ( !m_calculateSuperResolutionIdentifier || identifier_sr != LArG4Identifier() ) ) ;
    }
 
  } // namespace Barrel
 
} // namespace LAr