LArFCS_StepInfoSD Class Reference

#include <LArFCS_StepInfoSD.h>

Inheritance diagram for LArFCS_StepInfoSD:

Collaboration diagram for LArFCS_StepInfoSD:

Public Member Functions
	LArFCS_StepInfoSD (G4String a_name, const FCS_Param::Config &config)
	Constructor.
virtual	~LArFCS_StepInfoSD ()
	Destructor.
G4bool	ProcessHits (G4Step *a_step, G4TouchableHistory *) override
	Main processing method.
void	EndOfAthenaEvent (ISF_FCS_Parametrization::FCS_StepInfoCollection *hitContnainer)
	End of athena event processing.
void	setupHelpers (const LArEM_ID *EM, const LArFCAL_ID *FCAL, const LArHEC_ID *HEC, const TileID *tile)
	Sets the ID helper pointers.

Protected Member Functions
void	getCaloDDManager ()
	Keep a map instead of trying to keep the full vector.
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.
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
Identifier	ConvertID (const LArG4Identifier &a_ident) const
	Helper function for making "real" identifiers from LArG4Identifiers.
double	getMaxTime (const CaloCell_ID::CaloSample &layer) const

Private Attributes
ILArCalculatorSvc *	m_calculator
	Member variable - the calculator we'll use.

Detailed Description

Definition at line 28 of file LArFCS_StepInfoSD.h.

Constructor & Destructor Documentation

LArFCS_StepInfoSD()

LArFCS_StepInfoSD::LArFCS_StepInfoSD	(	G4String	a_name,
		const FCS_Param::Config &	config )

Constructor.

Geant4 headers.

Athena headers

Definition at line 21 of file LArFCS_StepInfoSD.cxx.

    : FCS_StepInfoSD(std::move(a_name), config),
      m_calculator(m_config.m_LArCalculator) {}

~LArFCS_StepInfoSD()

LArFCS_StepInfoSD::~LArFCS_StepInfoSD ( )

virtual

Destructor.

Definition at line 26 of file LArFCS_StepInfoSD.cxx.

{}

Member Function Documentation

ConvertID()

Identifier LArFCS_StepInfoSD::ConvertID ( const LArG4Identifier & a_ident ) const

private

Helper function for making "real" identifiers from LArG4Identifiers.

Definition at line 349 of file LArFCS_StepInfoSD.cxx.

                                                                            {
  Identifier id;
  if (a_ident[0] == 4) {
    // is LAr
    if (a_ident[1] == 1) {
      // is LAr EM
      try {
        id = m_larEmID->channel_id(a_ident[2],   // barrel_ec
                                   a_ident[3],   // sampling
                                   a_ident[4],   // region
                                   a_ident[5],   // eta
                                   a_ident[6]);  // phi
      } catch (LArID_Exception& e) {
        G4ExceptionDescription description;
        description << "ConvertID: LArEM_ID error code " << e.code() << " "
                    << (std::string)e;
        G4Exception("LArFCS_StepInfoSD", "ConvertIDEM", FatalException,
                    description);
        abort();
      }
    } else if (a_ident[1] == 2) {
      // is EM HEC
      try {
        id = m_larHecID->channel_id(a_ident[2],   // zSide
                                    a_ident[3],   // sampling
                                    a_ident[4],   // region
                                    a_ident[5],   // eta
                                    a_ident[6]);  // phi
      } catch (LArID_Exception& e) {
        G4ExceptionDescription description;
        description << "ConvertID: LArHEC_ID error code " << e.code() << " "
                    << (std::string)e;
        G4Exception("LArFCS_StepInfoSD", "ConvertIDHEC", FatalException,
                    description);
        abort();
      }
    } else if (a_ident[1] == 3) {
      // FCAL
      if (a_ident[3] > 0) {
        // is EM FCAL
        try {
          id = m_larFcalID->channel_id(a_ident[2],   // zSide
                                       a_ident[3],   // sampling
                                       a_ident[4],   // eta
                                       a_ident[5]);  // phi
        } catch (LArID_Exception& e) {
          G4ExceptionDescription description;
          description << "ConvertID: LArFCAL_ID error code " << e.code() << " "
                      << (std::string)e;
          G4Exception("LArFCS_StepInfoSD", "ConvertIDFCAL", FatalException,
                      description);
          abort();
        }
      } else {
        G4ExceptionDescription description;
        description << "ConvertID: Unsupported ID.  ";
        G4Exception("LArFCS_StepInfoSD", "ConvertIDMiniFCAL", FatalException,
                    description);
        abort();
      }
    }
  }
  return id;
}

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;
}

ProcessHits()

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

overridevirtual

Main processing method.

Reimplemented from FCS_StepInfoSD.

Definition at line 28 of file LArFCS_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) {
    if (!m_calo_dd_man.get()) {
      getCaloDDManager();
    }
 
    const double StepLength = a_step->GetStepLength() / CLHEP::mm;
    const G4ThreeVector preStepPosition =
        a_step->GetPreStepPoint()
            ->GetPosition();  // pre step is the position we're interested in
    const G4ThreeVector postStepPosition =
        a_step->GetPostStepPoint()->GetPosition();
    std::vector<const G4Step*> steps;
    bool madeSubSteps(false);
    if (m_config.shorten_lar_step && StepLength > m_config.substpsize) {
      // create smaller substeps instead
      G4int nsub_step = (int)(StepLength / m_config.substpsize) + 1;
      G4double delta = 1. / ((double)nsub_step);
      // G4cout <<"Orig prestep: "<<preStepPosition<<std::endl;
      for (G4int i = 0; i < nsub_step; i++) {
        G4double fraction1 = ((G4double)i) * delta;
        G4double fraction2 = (((G4double)i) + 1.) * delta;
        G4ThreeVector subpoint1 =
            preStepPosition * (1 - fraction1) + postStepPosition * fraction1;
        G4ThreeVector subpoint2 =
            preStepPosition * (1 - fraction2) + postStepPosition * fraction2;
        G4StepPoint* startpoint = new G4StepPoint(*(a_step->GetPreStepPoint()));
        G4StepPoint* endpoint = new G4StepPoint(*(a_step->GetPostStepPoint()));
        startpoint->SetPosition(subpoint1);
        endpoint->SetPosition(subpoint2);
 
        G4Step* newstep = new G4Step(*a_step);
        newstep->SetPreStepPoint(startpoint);
        newstep->SetPostStepPoint(endpoint);
        newstep->SetStepLength((subpoint1 - subpoint2).mag());
        newstep->SetTotalEnergyDeposit(a_step->GetTotalEnergyDeposit() /
                                       nsub_step);
        steps.push_back(newstep);
        madeSubSteps = true;
      }
    } else {
      steps.push_back(a_step);
    }
 
    if (m_config.verboseLevel > 4) {
      G4cout << "LArFCS_StepInfoSD::ProcessHits(): original step in Volume: "
             << a_step->GetPreStepPoint()->GetPhysicalVolume()->GetName()
             << " position: " << a_step->GetPreStepPoint()->GetPosition()
             << " Length=" << a_step->GetStepLength() / CLHEP::mm
             << " E=" << a_step->GetTotalEnergyDeposit() << G4endl;
      std::vector<LArHitData> processedHits;
      if (m_calculator->Process(a_step, processedHits)) {
        if (m_config.verboseLevel > -1) {
          G4cout << "  #LArHitData=" << processedHits.size();
          for (const auto& lhd : processedHits) {
            G4cout << " ; id=" << (std::string)lhd.id << " E=" << lhd.energy
                   << G4endl;
          }
          G4cout << G4endl;
        }
      }
      G4cout << "LArFCS_StepInfoSD::ProcessHits(): #substep=" << steps.size()
             << G4endl;
    }
 
    double et_all = 0;  // Total collected charge in all substeps
    for (const G4Step* substep : steps) {
      double et(0.);  // Total collected charge in this substep
      G4ThreeVector stepPosition =
          0.5 * (substep->GetPreStepPoint()->GetPosition() +
                 substep->GetPostStepPoint()->GetPosition());
      std::vector<LArHitData> processedHits;
      if (m_config.verboseLevel > 4) {
        G4cout << "  LArFCS_StepInfoSD::ProcessHits(): substep in Volume: "
               << substep->GetPreStepPoint()->GetPhysicalVolume()->GetName()
               << " position: " << substep->GetPreStepPoint()->GetPosition()
               << " Length=" << substep->GetStepLength() / CLHEP::mm
               << " E=" << substep->GetTotalEnergyDeposit() << G4endl;
      }
      if (m_calculator->Process(substep, processedHits)) {
        for (const auto& larhit : processedHits) {
          et += larhit.energy;
          et_all += larhit.energy;
        }
        if (m_config.verboseLevel > 4) {
          G4cout << "    substep #LArHitData=" << processedHits.size();
          for (const auto& lhd : processedHits) {
            G4cout << " ; id=" << (std::string)lhd.id << " E=" << lhd.energy
                   << G4endl;
          }
          G4cout << G4endl;
        }
      } else {
        if (m_config.verboseLevel > 4) {
          // Maybe 0 hits or something like that...
          G4cout << this->GetName()
                 << " WARNING ProcessHits: Call to ILArCalculatorSvc::Process "
                    "failed! Details:"
                 << G4endl << "          " << "Volume: "
                 << a_step->GetPreStepPoint()->GetPhysicalVolume()->GetName()
                 << " " << m_calculator << " position: " << stepPosition
                 << " SL: " << StepLength << G4endl << "          "
                 << "Orig position: "
                 << substep->GetPreStepPoint()->GetPosition() << "  /  "
                 << substep->GetPostStepPoint()->GetPosition() << G4endl
                 << "          " << "StepLength: " << StepLength
                 << " step: " << preStepPosition << " / " << postStepPosition
                 << G4endl;
        }
        continue;
      }
 
      // drop hits with zero deposited energy (could still happen with negative
      // corrections from calculator)
      // Or if total energy is <0
      if (et <= 0.) {
        if (m_config.verboseLevel > 4) {
          G4cout << this->GetName()
                 << " WARNING ProcessHits: Total negative energy: " << et
                 << " not processing..." << G4endl;
        }
        continue;
      }
 
      const size_t numberOfProcessedHits = processedHits.size();
      const G4ThreeVector originalStepPosition = stepPosition;
      double maxSubHitEnergy = -999.;
      int maxSubHitEnergyindex = -1;
      if (numberOfProcessedHits > 0) {
        maxSubHitEnergy = processedHits[0].energy;
        maxSubHitEnergyindex = 0;
      }
      // Figure out the subhit with most energy
      for (size_t i = 1; i < numberOfProcessedHits; ++i) {
        if (maxSubHitEnergy < processedHits[i].energy) {
          maxSubHitEnergy = processedHits[i].energy;
          maxSubHitEnergyindex = i;
        }
      }
      if (maxSubHitEnergyindex ==
          -1) {  // because there were no hits; numberOfProcessedHits ==0
        G4cout << this->GetName()
               << " WARNING ProcessHits: numberOfProcessedHits is zero"
               << G4endl;
        continue;
      }
      // Identifier for the subhit with max energy
      Identifier maxEnergyIdentifier =
          this->ConvertID(processedHits[maxSubHitEnergyindex].id);
      const CaloDetDescrElement* maxEnergyCell =
          m_calo_dd_man.get()->get_element(maxEnergyIdentifier);
 
      Identifier invalidIdentifier;
      // for (size_t i=0; i<numberOfProcessedHits; ++i) {
      for (const auto& larhit : processedHits) {
        Identifier id = this->ConvertID(larhit.id);
        if (larhit.id[0] == 10) {
          if (m_config.verboseLevel > 9) {
            G4cout << this->GetName()
                   << " VERBOSE ProcessHits: Dead Material LArG4Identifier: "
                   << (std::string)larhit.id << G4endl << "          " << id
                   << G4endl << "          " << id.getString() << G4endl
                   << "          "
                   << a_step->GetPreStepPoint()
                          ->GetPhysicalVolume()
                          ->GetLogicalVolume()
                          ->GetName()
                   << G4endl << "          numberOfProcessedHits: "
                   << numberOfProcessedHits << G4endl;
            G4cout << "          " << invalidIdentifier << G4endl;
          }
        } else if (id == invalidIdentifier) {
          G4cout
              << this->GetName()
              << " WARNING ProcessHits: Something wrong with LArG4Identifier: "
              << (std::string)larhit.id << G4endl << "          " << id
              << G4endl << "          " << id.getString() << G4endl
              << "          "
              << a_step->GetPreStepPoint()
                     ->GetPhysicalVolume()
                     ->GetLogicalVolume()
                     ->GetName()
              << G4endl
              << "          numberOfProcessedHits: " << numberOfProcessedHits
              << G4endl;
          G4cout << "          " << invalidIdentifier << G4endl;
        }
        // need to get the cell information
        if (numberOfProcessedHits > 1) {
          if (!m_larEmID->is_em_barrel(id)) {
            // It didn't seem to happen outside em_barrel, so flag up if it
            // does:
            G4cout << this->GetName()
                   << " WARNING ProcessHits: Outside LAr barrel, but "
                      "numberOfProcessedHits="
                   << numberOfProcessedHits
                   << ", LArG4Identifier: " << (std::string)larhit.id << G4endl;
          } else {
            if (m_config.shift_lar_subhit) {
              // find subhit with largest energy
              if (maxSubHitEnergyindex == -1) {
                G4cout
                    << this->GetName()
                    << " WARNING ProcessHits: no subhit index with e>-999??? "
                    << G4endl;
                continue;
              }
              if (m_config.verboseLevel > 9) {
                G4cout << this->GetName()
                       << " VERBOSE ProcessHits: shifting subhits: largest "
                          "energy subhit index is "
                       << maxSubHitEnergyindex << " E: " << maxSubHitEnergy
                       << " identifier: " << maxEnergyIdentifier.getString()
                       << G4endl;
              }
              // from identifier
              const CaloDetDescrElement* thiscell =
                  m_calo_dd_man.get()->get_element(id);
              if (!maxEnergyCell) {
                // How often does this happen? Do not shift.
                G4cout << this->GetName()
                       << " WARNING ProcessHits: maxEnergyCell failed: "
                       << maxEnergyIdentifier.getString() << G4endl
                       << "          "
                       << m_calo_dd_man.get()->get_element(id)->getSampling()
                       << G4endl << "          " << originalStepPosition.eta()
                       << G4endl << "          " << originalStepPosition.phi()
                       << G4endl;
                stepPosition = originalStepPosition;
              } else if (maxEnergyCell == thiscell) {
                // The cells match, so do not shift this hit.
                if (m_config.verboseLevel > 9) {
                  G4cout << this->GetName()
                         << " VERBOSE ProcessHits: Original step position: "
                         << originalStepPosition.x() << " "
                         << originalStepPosition.y() << " "
                         << originalStepPosition.z() << G4endl << "          "
                         << "This cell: " << thiscell->x() << " "
                         << thiscell->y() << " " << thiscell->z() << G4endl
                         << "          " << "No shift" << G4endl;
                }
                stepPosition = originalStepPosition;
              } else {
                // the two cells do not match => shift
                G4ThreeVector diff(thiscell->x() - maxEnergyCell->x(),
                                   thiscell->y() - maxEnergyCell->y(),
                                   thiscell->z() - maxEnergyCell->z());
                stepPosition = originalStepPosition + diff;
                if (m_config.verboseLevel > 9) {
                  const CaloDetDescrElement* bestcell =
                      m_calo_dd_man.get()->get_element(
                          m_calo_dd_man.get()->get_element(id)->getSampling(),
                          originalStepPosition.eta(),
                          originalStepPosition.phi());
                  G4cout << this->GetName()
                         << " VERBOSE ProcessHits: Original step position: "
                         << originalStepPosition.x() << " "
                         << originalStepPosition.y() << " "
                         << originalStepPosition.z() << G4endl << "          "
                         << "This cell: " << thiscell->x() << " "
                         << thiscell->y() << " " << thiscell->z() << G4endl
                         << "          "
                         << "Highest E cell: " << maxEnergyCell->x() << " "
                         << maxEnergyCell->y() << " " << maxEnergyCell->z()
                         << G4endl << "          "
                         << "(Best cell: " << bestcell->x() << " "
                         << bestcell->y() << " " << bestcell->z() << ")"
                         << G4endl << "          "
                         << "Shifted step position: " << stepPosition.x() << " "
                         << stepPosition.y() << " " << stepPosition.z()
                         << G4endl;
                }
              }
            }
          }
        }
        // Finalize time for LAr hits?: NO
        // double time = larhit.energy)==0 ? 0. : (double)
        // larhit.time/larhit.energy/CLHEP::ns;
        double time = larhit.time;
        double energy = larhit.energy / CLHEP::MeV;
        // Drop any hits that don't have a good identifier attached
        if (!m_calo_dd_man.get()->get_element(id)) {
          if (m_config.verboseLevel > 4) {
            G4cout << this->GetName()
                   << " DEBUG update_map: bad identifier: " << id.getString()
                   << " skipping this hit." << G4endl;
          }
          continue;
        }
        this->update_map(
            stepPosition, id, energy, time, true,
            numberOfProcessedHits);  // store numberOfProcessedHits as info
      }  // numberOfProcessedHits
    }  // istep
    if (madeSubSteps) {
      // only delete steps when doing substeps. Do not delete the original
      // G4Step!
      while (!steps.empty()) {
        delete steps.back();
        steps.pop_back();
      }
    }
    if (m_config.verboseLevel > 4) {
      G4cout << "LArFCS_StepInfoSD::ProcessHits(): Etotal substeps=" << et_all
             << G4endl << G4endl << G4endl;
    }
  }
 
  return result;
}

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

ILArCalculatorSvc* LArFCS_StepInfoSD::m_calculator

private

Member variable - the calculator we'll use.

Definition at line 44 of file LArFCS_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.

{nullptr};

m_larFcalID

const LArFCAL_ID* FCS_StepInfoSD::m_larFcalID {nullptr}

protectedinherited

Definition at line 103 of file FCS_StepInfoSD.h.

{nullptr};

m_larHecID

const LArHEC_ID* FCS_StepInfoSD::m_larHecID {nullptr}

protectedinherited

Definition at line 104 of file FCS_StepInfoSD.h.

{nullptr};

m_tileID

const TileID* FCS_StepInfoSD::m_tileID {nullptr}

protectedinherited

Definition at line 105 of file FCS_StepInfoSD.h.

{nullptr};

---

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

• LArFCS_StepInfoSD.h
• LArFCS_StepInfoSD.cxx