TileFCS_StepInfoSD Class Reference

#include <TileFCS_StepInfoSD.h>

Inheritance diagram for TileFCS_StepInfoSD:

Collaboration diagram for TileFCS_StepInfoSD:

Public Member Functions
	TileFCS_StepInfoSD (G4String name, const FCS_Param::Config &config)
	Geant4 headers. More...
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override final
	Main processing method. More...
	TileFCS_StepInfoSD (const TileFCS_StepInfoSD &)=delete
TileFCS_StepInfoSD &	operator= (const TileFCS_StepInfoSD &)=delete
void	EndOfAthenaEvent (ISF_FCS_Parametrization::FCS_StepInfoCollection *hitContnainer)
	End of athena event processing. More...
void	setupHelpers (const LArEM_ID *EM, const LArFCAL_ID *FCAL, const LArHEC_ID *HEC, const TileID *tile)
	Sets the ID helper pointers. More...

Protected Member Functions
void	getCaloDDManager ()
	Keep a map instead of trying to keep the full vector. More...
void	update_map (const CLHEP::Hep3Vector &l_vec, const Identifier &l_identifier, double l_energy, double l_time, bool l_valid, int l_detector)

Protected Attributes
FCS_Param::Config	m_config
const LArEM_ID *	m_larEmID {nullptr}
	Pointers to the identifier helpers. More...
const LArFCAL_ID *	m_larFcalID {nullptr}
const LArHEC_ID *	m_larHecID {nullptr}
const TileID *	m_tileID {nullptr}
CxxUtils::CachedPointer< const CaloDetDescrManager >	m_calo_dd_man
std::map< Identifier, std::vector< ISF_FCS_Parametrization::FCS_StepInfo * > * >	m_hit_map

Private Member Functions
bool	C10_connected (int module) const
	A copy of the method in TileCablingService.cxx. More...
bool	cellReadOutByOnePMT (const Identifier &id) const
	Some Tile Cells are only read out by one PMT rather than two. More...
double	getMaxTime (const CaloCell_ID::CaloSample &layer) const

Private Attributes
ITileCalculator *	m_calculator

Detailed Description

Definition at line 29 of file TileFCS_StepInfoSD.h.

Constructor & Destructor Documentation

TileFCS_StepInfoSD() [1/2]

TileFCS_StepInfoSD::TileFCS_StepInfoSD	(	G4String	name,
		const FCS_Param::Config &	config
	)

Geant4 headers.

Athena headers

Definition at line 29 of file TileFCS_StepInfoSD.cxx.

    : FCS_StepInfoSD(std::move(name), config),
      m_calculator(config.m_TileCalculator) {}

TileFCS_StepInfoSD() [2/2]

TileFCS_StepInfoSD::TileFCS_StepInfoSD ( const TileFCS_StepInfoSD &  )

delete

Member Function Documentation

C10_connected()

bool TileFCS_StepInfoSD::C10_connected ( int  module ) const

inlineprivate

A copy of the method in TileCablingService.cxx.

Definition at line 48 of file TileFCS_StepInfoSD.h.

                                                              {
  const bool C = true;
  const bool NC = false;
  const bool cell_present[64] = {
      // counting from 1 in comments
      C,  C,  C, C, C, C, C,  C,   // 1-8
      C,  C,  C, C, C, C, C,  C,   // 9-16
      C,  C,  C, C, C, C, C,  C,   // 17-24
      C,  C,  C, C, C, C, C,  C,   // 25-32
      C,  C,  C, C, C, C, NC, NC,  // 33-40  39-40 do not exist
      NC, NC, C, C, C, C, C,  C,   // 41-48  41-42 do not exist
      C,  C,  C, C, C, C, NC, NC,  // 49-56  55-56 do not exist
      NC, NC, C, C, C, C, C,  C    // 57-64  57-58 do not exist
  };
  return cell_present[module];
}

cellReadOutByOnePMT()

bool TileFCS_StepInfoSD::cellReadOutByOnePMT ( const Identifier &  id ) const

inlineprivate

Some Tile Cells are only read out by one PMT rather than two.

Definition at line 65 of file TileFCS_StepInfoSD.h.

                                {
  return m_tileID->is_tile_gapscin(id) ||  // gap/crack cells
         ((m_tileID->section(id) == TileID::GAPDET &&
           m_tileID->sample(id) == TileID::SAMP_C &&
           !(this->C10_connected(m_tileID->module(id)))));  // Special C10 cells
}

EndOfAthenaEvent()

void FCS_StepInfoSD::EndOfAthenaEvent ( ISF_FCS_Parametrization::FCS_StepInfoCollection *  hitContnainer )

inherited

End of athena event processing.

Definition at line 146 of file FCS_StepInfoSD.cxx.

                                                                 {
  // Unpack map into vector
  for (auto it : m_hit_map) {
    for (auto* a_s : *it.second) {
      // Giving away ownership of the objects!
      hitContainer->push_back(a_s);
    }
    it.second->clear();
    delete it.second;
  }  // Vector of IDs in the map
  m_hit_map.clear();
  if (m_config.verboseLevel > 4) {
    G4cout << this->GetName()
           << " DEBUG EndOfAthenaEvent: After initial cleanup, N="
           << hitContainer->size() << G4endl;
  }
  return;
}

getCaloDDManager()

void FCS_StepInfoSD::getCaloDDManager ( )

protectedinherited

Keep a map instead of trying to keep the full vector.

At the end of the event we'll push the map back into the FCS_StepInfoCollection in StoreGate.

Definition at line 49 of file FCS_StepInfoSD.cxx.

                                      {
  SG::ReadCondHandleKey<CaloDetDescrManager> caloMgrKey{"CaloDetDescrManager"};
  if (caloMgrKey.initialize().isFailure()) {
    G4ExceptionDescription description;
    description << "Failed to get CaloDetDescrManager!";
    G4Exception("FCS_StepInfoSD", "FCSBadCall", FatalException, description);
    abort();
  }
  SG::ReadCondHandle<CaloDetDescrManager> caloMgr(
      caloMgrKey, Gaudi::Hive::currentContext());
  m_calo_dd_man.set(*caloMgr);
}

getMaxTime()

double FCS_StepInfoSD::getMaxTime ( const CaloCell_ID::CaloSample &  layer ) const

inlineprivateinherited

NB The result of this function should actually be constant for each SD

Definition at line 34 of file FCS_StepInfoSD.cxx.

                                              {
  if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
    return m_config.m_maxTimeLAr;
  }
  if (layer >= CaloCell_ID::HEC0 && layer <= CaloCell_ID::HEC3) {
    return m_config.m_maxTimeHEC;
  }
  if (layer >= CaloCell_ID::FCAL0 && layer <= CaloCell_ID::FCAL2) {
    return m_config.m_maxTimeFCAL;
  }
  return m_config.m_maxTime;
}

operator=()

TileFCS_StepInfoSD& TileFCS_StepInfoSD::operator= ( const TileFCS_StepInfoSD &  )

delete

ProcessHits()

G4bool TileFCS_StepInfoSD::ProcessHits ( G4Step *  a_step, G4TouchableHistory *    )

finaloverridevirtual

Main processing method.

Reimplemented from FCS_StepInfoSD.

Definition at line 34 of file TileFCS_StepInfoSD.cxx.

                                                              {
  G4bool result(false);
  // If there's no energy, there's no hit.  (Aside: Isn't this energy
  // the same as the energy from the calculator?  Not necessarily.
  // The calculator may include detector effects such as
  // charge-collection which are not modeled by Geant4.)
  if (a_step->GetTotalEnergyDeposit() <= 0.) {
    return result;
  }
 
  if (m_calculator) {
    // calculation of MicroHit with a_step
    TileHitData hitData;
    TileMicroHit micHit = m_calculator->GetTileMicroHit(a_step, hitData);
    Identifier invalid_id;
 
    // Check if MicroHit is not in scintillator
    if ((micHit.pmt_up == invalid_id) && (micHit.pmt_down == invalid_id)) {
      G4cout << this->GetName() << " WARNING ProcessHits: Invalid hit in Tile??"
             << G4endl;
      return result;
    } else {
      // Some cells is the gap scintillator are only read out by one
      // PMT, so only print warnings if this is not the case.
      if ((micHit.pmt_up == invalid_id) &&
          !(cellReadOutByOnePMT(micHit.pmt_down))) {
        G4cout << this->GetName()
               << " WARNING ProcessHits: Something wrong in identifier: tile "
                  "pmt_up: "
               << micHit.pmt_up << std::endl;
        G4cout << this->GetName()
               << " WARNING ProcessHits: tile pmt_down : " << micHit.pmt_down
               << " " << m_tileID->to_string(micHit.pmt_down, -1) << std::endl;
        G4cout << this->GetName()
               << " WARNING ProcessHits: E up: " << micHit.e_up
               << " E down: " << micHit.e_down << " T up: " << micHit.time_up
               << " T down: " << micHit.time_down << std::endl;
      }
      if ((micHit.pmt_down == invalid_id) &&
          !(cellReadOutByOnePMT(micHit.pmt_up))) {
        G4cout << this->GetName()
               << " WARNING ProcessHits: Something wrong in identifier: tile "
                  "pmt_down: "
               << micHit.pmt_down << std::endl;
        G4cout << this->GetName()
               << " WARNING ProcessHits: tile pmt_up: " << micHit.pmt_up << " "
               << m_tileID->to_string(micHit.pmt_up, -1) << std::endl;
        G4cout << this->GetName()
               << " WARNING ProcessHits: E up: " << micHit.e_up
               << " E down: " << micHit.e_down << " T up: " << micHit.time_up
               << " T down: " << micHit.time_down << std::endl;
      }
      // Store TileHits Information
      const G4ThreeVector pos =
          0.5 * (a_step->GetPreStepPoint()->GetPosition() +
                 a_step->GetPostStepPoint()->GetPosition());
      const int numberOfProcessedHits(1);
      if (!m_calo_dd_man.get()) {
        getCaloDDManager();
      }
      this->update_map(pos, micHit.pmt_up, micHit.e_up, micHit.time_up, true,
                       numberOfProcessedHits);
      this->update_map(pos, micHit.pmt_down, micHit.e_down, micHit.time_down,
                       true, numberOfProcessedHits);
    }
  }
  return true;
}

setupHelpers()

void FCS_StepInfoSD::setupHelpers ( const LArEM_ID *  EM, const LArFCAL_ID *  FCAL, const LArHEC_ID *  HEC, const TileID *  tile  )

inlineinherited

Sets the ID helper pointers.

Definition at line 84 of file FCS_StepInfoSD.h.

                                                              {
    m_larEmID = EM;
    m_larFcalID = FCAL;
    m_larHecID = HEC;
    m_tileID = tile;
  }

update_map()

void FCS_StepInfoSD::update_map ( const CLHEP::Hep3Vector &  l_vec, const Identifier &  l_identifier, double  l_energy, double  l_time, bool  l_valid, int  l_detector  )

protectedinherited

Definition at line 62 of file FCS_StepInfoSD.cxx.

{
  // NB l_identifier refers to:
  // - the cell identifier for LAr
  // - the PMT identifier for Tile
 
  // Drop any hits that don't have a good identifier attached
  if (!m_calo_dd_man.get()->get_element(l_identifier)) {
    if (m_config.verboseLevel > 4) {
      G4cout << this->GetName() << " DEBUG update_map: bad identifier: "
             << l_identifier.getString() << " skipping this hit." << G4endl;
    }
    return;
  }
 
  auto map_item = m_hit_map.find(l_identifier);
  if (map_item == m_hit_map.end()) {
    m_hit_map[l_identifier] =
        new std::vector<ISF_FCS_Parametrization::FCS_StepInfo*>;
    m_hit_map[l_identifier]->reserve(200);
    m_hit_map[l_identifier]->push_back(
        new ISF_FCS_Parametrization::FCS_StepInfo(l_vec, l_identifier, l_energy,
                                                  l_time, l_valid, l_detector));
  } else {
 
    // Get the appropriate merging limits
    const CaloCell_ID::CaloSample& layer =
        m_calo_dd_man.get()->get_element(l_identifier)->getSampling();
 
    double timeWindow = m_config.m_maxTime;
    const double distWinLong = m_config.m_maxRadiusLongitudinal.at(layer);
    const double distWinLat = m_config.m_maxRadiusLateral.at(layer);
 
    const double tsame(this->getMaxTime(layer));
    bool match = false;
    for (auto* map_it : *map_item->second) {
      // Time check ... both a global flag and a check on the layer
      const double delta_t = std::fabs(map_it->time() - l_time);
      if (delta_t >= tsame) {
        continue;
      }
      if (delta_t >= timeWindow) {
        continue;
      }
 
      // Distance check
      const CLHEP::Hep3Vector& currentPosition = map_it->position();
      const double currentPosition_mag = currentPosition.mag();
      const double proj_longitudinal =
          currentPosition.dot(l_vec) / currentPosition_mag;
      const double delta_longitudinal = currentPosition_mag - proj_longitudinal;
      if (std::fabs(delta_longitudinal) >= distWinLong) {
        continue;
      }
 
      // Lateral distance check
      double delta_lateral_2 = l_vec.mag2() - proj_longitudinal * proj_longitudinal;
      if (delta_lateral_2 < 0) {
        delta_lateral_2 = 0;  // Avoid negative square root
      }
      const double delta_lateral =
          std::sqrt(delta_lateral_2);
      if (delta_lateral >= distWinLat) {
        continue;
      }
 
      // Found a match.  Make a temporary that will be deleted!
      const ISF_FCS_Parametrization::FCS_StepInfo my_info(
          l_vec, l_identifier, l_energy, l_time, l_valid, l_detector);
      *map_it += my_info;
      match = true;
      break;
    }  // End of search for match in time and space
    if (!match) {
      map_item->second->push_back(new ISF_FCS_Parametrization::FCS_StepInfo(
          l_vec, l_identifier, l_energy, l_time, l_valid, l_detector));
    }  // Didn't match
  }  // ID already in the map
  return;
}  // That's it for updating the map!

Member Data Documentation

m_calculator

ITileCalculator* TileFCS_StepInfoSD::m_calculator

private

Definition at line 45 of file TileFCS_StepInfoSD.h.

m_calo_dd_man

CxxUtils::CachedPointer<const CaloDetDescrManager> FCS_StepInfoSD::m_calo_dd_man

protectedinherited

Definition at line 106 of file FCS_StepInfoSD.h.

m_config

FCS_Param::Config FCS_StepInfoSD::m_config

protectedinherited

Definition at line 100 of file FCS_StepInfoSD.h.

m_hit_map

std::map<Identifier, std::vector<ISF_FCS_Parametrization::FCS_StepInfo*>*> FCS_StepInfoSD::m_hit_map

protectedinherited

Definition at line 108 of file FCS_StepInfoSD.h.

m_larEmID

const LArEM_ID* FCS_StepInfoSD::m_larEmID {nullptr}

protectedinherited

Pointers to the identifier helpers.

Definition at line 102 of file FCS_StepInfoSD.h.

m_larFcalID

const LArFCAL_ID* FCS_StepInfoSD::m_larFcalID {nullptr}

protectedinherited

Definition at line 103 of file FCS_StepInfoSD.h.

m_larHecID

const LArHEC_ID* FCS_StepInfoSD::m_larHecID {nullptr}

protectedinherited

Definition at line 104 of file FCS_StepInfoSD.h.

m_tileID

const TileID* FCS_StepInfoSD::m_tileID {nullptr}

protectedinherited

Definition at line 105 of file FCS_StepInfoSD.h.

---

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

• TileFCS_StepInfoSD.h
• TileFCS_StepInfoSD.cxx