LArG4::BarrelCryostat::CalibrationCalculator Class Reference

#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 ()
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 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)
      , m_backupCalculator("BarrelCryostatCalibrationLArCalculator",name)
    {
      declareProperty("BackupCalculator",m_backupCalculator);
    }

~CalibrationCalculator()

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

virtual

Definition at line 479 of file CryostatCalibrationCalculator.cxx.

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

Member Function Documentation

initialize()

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

finaloverride

Definition at line 450 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 486 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.
      if ( identifier == LArG4Identifier() )
        return false;
 
      return true;
    }

Member Data Documentation

m_backupCalculator

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

private

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

m_energyCalculator

CaloG4::SimulationEnergies LArG4::BarrelCryostat::CalibrationCalculator::m_energyCalculator

private

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

---

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

• LArG4Barrel/src/CryostatCalibrationCalculator.h
• CryostatCalibrationCalculator.cxx