#include <CryostatCalibrationCalculator.h>

Inheritance diagram for LArG4::BarrelCryostat::CalibrationCalculator:

Collaboration diagram for LArG4::BarrelCryostat::CalibrationCalculator:

Public Member Functions
	CalibrationCalculator (const std::string &name, ISvcLocator *pSvcLocator)

StatusCode	initialize () override final

virtual	~CalibrationCalculator ()=default

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 {this, "BackupCalculator", "BarrelCryostatCalibrationLArCalculator"}

Detailed Description

Definition at line 45 of file LArG4Barrel/src/CryostatCalibrationCalculator.h.

Constructor & Destructor Documentation

◆ CalibrationCalculator()

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

Definition at line 443 of file CryostatCalibrationCalculator.cxx.

       : LArCalibCalculatorSvcImp(name, pSvcLocator)
     {
     }

◆ ~CalibrationCalculator()

virtual LArG4::BarrelCryostat::CalibrationCalculator::~CalibrationCalculator ( )

virtualdefault

Member Function Documentation

◆ initialize()

StatusCode LArG4::BarrelCryostat::CalibrationCalculator::initialize ( )

finaloverride

Definition at line 448 of file CryostatCalibrationCalculator.cxx.

                                                 {
       // Get the "backup" calculator.
       ATH_CHECK(m_backupCalculator.retrieve());
  
 #if defined (DEBUG_HITS) || defined (DEBUG_MAPS)
       G4cout << "LArG4::BarrelCryostat::CalibrationCalculator::CalibrationCalculator - "
              << " numberOfVolumes=" << numberOfVolumes
              << ", sizeof(volumes)=" << sizeof(volumes)
              << ", sizeof(VolumeInfo_t)=" << sizeof(VolumeInfo_t)
              << G4endl;
 #endif
  
       // Intialize the maps.
       volumeMap();
  
  
  
 #if defined (DEBUG_HITS) || defined (DEBUG_MAPS)
       G4cout << "LArG4::BarrelCryostat::CalibrationCalculator::CalibrationCalculator - "
              << G4endl
              << "   initialization complete; map size="
              << volumeMap().size()
              << G4endl;
 #endif
  
       return StatusCode::SUCCESS;
     }

◆ Process()

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

finaloverridevirtual

Definition at line 476 of file CryostatCalibrationCalculator.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.
  
           // First, find the physical volume copy number, and the
           // logical volume name.
  
           G4VPhysicalVolume* physical = step->GetPreStepPoint()->GetPhysicalVolume();
           G4int copyNumber = physical->GetCopyNo();
           G4String volumeName = physical->GetLogicalVolume()->GetName();
  
 #ifdef DEBUG_HITS
           G4cout << "LArG4::BarrelCryostat::CalibrationCalculator::Process - "
                  << G4endl
                  << "   searching for volume '"
                  << volumeName
                  << "' copyNumber="
                  << copyNumber
                  << G4endl;
 #endif
  
           if(volumeName.find("LArMgr::") == 0) volumeName.erase(0,8);
           if(volumeName.find("LAr::Barrel::Cryostat::Sector")==0) { // ears, legs, Ti blocks
             volumeName = "LAr::Barrel::Cryostat::Sector";
             if(copyNumber != 7 && copyNumber !=12) copyNumber=1; // assignment arbitrary copyNumber to Ti block
           }else if(volumeName.find("LAr::Barrel::Cryostat::Cylinder")==0){
             volumeName = "LAr::Barrel::Cryostat::Cylinder";
           }else if(volumeName.find("LAr::Barrel::Cryostat::InnerWall")==0){
             volumeName = "LAr::Barrel::Cryostat::InnerWall";
             copyNumber = 1; // assignment arbitrary copyNumber
           }
  
           // Search the maps for this volume/copy number combination.
           const auto v = volumeMap().find( volumeName );
           if ( v != volumeMap().end() )
             {
  
               // Recall that maps are made from pair <key,value>, and
               // you access a pair with the "first" and "second"
               // members.  In this case, "second" is a map.  We don't
               // need to copy the entire map; it's enough to get its
               // reference.
  
               const identifierMap_t& identifierMap = (*v).second;
               const auto i = identifierMap.find( copyNumber );
  
               if ( i != identifierMap.end() )
                 {
                   const IdentifierInfo_t* info = (*i).second;
  
                   // Find our (x,y,z) location from the G4Step.
  
                   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;
  
                   // Determine the geometric eta and phi.  Note that we do not
                   // adjust for any endcap shifts; the values are assigned to
                   // the volumes based on their design positions.
  
                   G4double eta = fabs( p.pseudoRapidity() );
                   G4double phi = p.phi();
                   // For this calculation, we need 0<phi<2*PI.  (The
                   // official ATLAS standard of -PI<phi<PI is
                   // meaningless here.)
                   if ( phi < 0 ) phi += 2*M_PI;
  
                   // The region can depend on eta.  Search through the
                   // list of regions within this IdentifierInfo record
                   // to find which one has etaMin<eta<etaMax.
  
                   G4int regions = info->numberOfRegions;
                   const RegionInfo_t* region = info->regionInfoArray;
  
 #ifdef DEBUG_HITS
                   G4cout << "LArG4::BarrelCryostat::CalibrationCalculator::Process - "
                          << G4endl
                          << "   found volume, number of regions="
                          << regions
                          << " eta=" << eta << " phi=" << phi
                          << G4endl;
 #endif
  
                   G4int r;
                   for ( r = 0; r < regions; r++, region++ )
                     {
                       if ( eta > region->etaMin  &&
                            eta < region->etaMax )
                         break;
                     }
  
                   // If the following statement is not true, we're in
                   // trouble.  It means that the eta of our energy
                   // deposit is outside the assumed eta limits of the
                   // volume.
  
                   if ( r < regions )
                     {
                       // Convert eta and phi to their integer equivalents for the
                       // identifier.
  
                       G4int etaInteger = G4int( (eta - region->etaMin) / region->deltaEta );
                       G4int phiInteger = G4int( phi / region->deltaPhi );
                       // phiInteger should be less than 64
                       if (phiInteger > 63) phiInteger = 0;
  
 #ifdef DEBUG_HITS
                       G4cout << "LArG4::BarrelCryostat::CalibrationCalculator::Process - "
                              << G4endl
                              << "   found region="
                              << region->regionNumber
                              << " eta bin=" << etaInteger << " phi bin=" << phiInteger
                              << G4endl;
 #endif
  
                       // The sign of subdet will depend on whether z is positive
                       // or negative.
                       G4int subDetSign = 1;
                       if ( p.z() < 0 ) subDetSign = -1;
  
                       // A quick check against a bad value of etaMin.
                       if ( etaInteger >= 0 )
                         {
                           // Build the full identifier.
                           identifier << info->detector
                                      << info->subdet * subDetSign
                                      << info->type
                                      << info->sampling
                                      << region->regionNumber
                                      << etaInteger
                                      << phiInteger;
  
                         } // etaInteger valid
                     } // eta valid
                 } // copy number valid
             } // volume name valid
  
           // If a volume is not found on one of the above tables, try
           // the "backup identifier" calculator.
  
           if ( identifier == LArG4Identifier() )
             {
 #if defined (DEBUG_HITS) || defined (DEBUG_VOLUMES)
               std::cout << "LArG4::BarrelCryostat::CalibrationCalculator::Process"
                         << std::endl
                         << "    volume '"
                         << volumeName
                         << "' copy# "
                         << copyNumber
                         << " not found on tables, using backup calculator"
                         << std::endl;
 #endif
               m_backupCalculator->Process(step, identifier, energies, process);
             }
         } // calculate identifier
  
 #ifdef DEBUG_HITS
       //G4double energy = accumulate(energies.begin(),energies.end(),0.);
       std::cout << "LArG4::BarrelCryostat::CalibrationCalculator::Process"
                 << " vName " <<  step->GetPreStepPoint()->GetPhysicalVolume()->GetName()
                 << " 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() );
     }

Member Data Documentation

◆ m_backupCalculator

ServiceHandle<ILArCalibCalculatorSvc> LArG4::BarrelCryostat::CalibrationCalculator::m_backupCalculator {this, "BackupCalculator", "BarrelCryostatCalibrationLArCalculator"}

private

Definition at line 74 of file LArG4Barrel/src/CryostatCalibrationCalculator.h.