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. More...
virtual	~LArFCS_StepInfoSD ()
	Destructor. More...
G4bool	ProcessHits (G4Step *a_step, G4TouchableHistory *) override
	Main processing method. More...
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, double timeWindow, double distanceWindow)

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
Identifier	ConvertID (const LArG4Identifier &a_ident) const
	Helper function for making "real" identifiers from LArG4Identifiers. More...
double	getMaxTime (const CaloCell_ID::CaloSample &layer) const
double	getMaxRadius (const CaloCell_ID::CaloSample &layer) const
double	getMaxDeltaR (const CaloCell_ID::CaloSample &layer) const
double	getMaxDeltaEta (const CaloCell_ID::CaloSample &layer) const
double	getMaxDeltaPhi (const CaloCell_ID::CaloSample &layer) const

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

Detailed Description

Definition at line 29 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 27 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 266 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 209 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 145 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);
}

getMaxDeltaEta()

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

inlineprivateinherited

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

Definition at line 94 of file FCS_StepInfoSD.cxx.

{
  if(m_config.m_maxRadiusLAr != 25) return 999.;
  if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
    if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
      // PS default is 1mm in eta, 5mm in phi, no cut in r
      return m_config.m_maxEtaPS;
    }
    else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
      // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
      return m_config.m_maxEtaEM1;
    }
    else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
      // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
      return m_config.m_maxEtaEM2;
    }
    else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
      // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
      return m_config.m_maxEtaEM3;
    }
  }
  return 999.;
}

getMaxDeltaPhi()

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

inlineprivateinherited

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

Definition at line 119 of file FCS_StepInfoSD.cxx.

{
  if(m_config.m_maxRadiusLAr != 25) return 999.;
  if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
    if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
      // PS default is 1mm in eta, 5mm in phi, no cut in r
      return m_config.m_maxPhiPS;
    }
    else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
      // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
      return m_config.m_maxPhiEM1;
    }
    else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
      // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
      return m_config.m_maxPhiEM2;
    }
    else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
      // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
       return m_config.m_maxPhiEM3;
    }
  }
  return 999.;
}

getMaxDeltaR()

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

inlineprivateinherited

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

Definition at line 69 of file FCS_StepInfoSD.cxx.

{
  if(m_config.m_maxRadiusLAr != 25) return 999.;
  if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
    if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
      // PS default is 1mm in eta, 5mm in phi, no cut in r
      return m_config.m_maxrPS;
    }
    else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
      // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
      return m_config.m_maxrEM1;
    }
    else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
      // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
      return m_config.m_maxrEM2;
    }
    else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
      // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
      return m_config.m_maxrEM3;
    }
  }
  return 999.;
}

getMaxRadius()

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

inlineprivateinherited

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

Definition at line 54 of file FCS_StepInfoSD.cxx.

{
  if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
    return m_config.m_maxRadiusLAr;
  }
  if (layer >= CaloCell_ID::HEC0  && layer <= CaloCell_ID::HEC3) {
    return m_config.m_maxRadiusHEC;
  }
  if (layer >=CaloCell_ID::FCAL0 && layer <= CaloCell_ID::FCAL2) {
        return m_config.m_maxRadiusFCAL;
  }
  return m_config.m_maxRadius;
}

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 39 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 31 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;
        }
        // Get the appropriate merging limits
        const CaloCell_ID::CaloSample& layer = m_calo_dd_man.get()->get_element(id)->getSampling();
        const double timeWindow(m_config.m_maxTime);
        const double distanceWindow((layer == CaloCell_ID::EMB1 || layer == CaloCell_ID::EME1) ? m_config.m_maxRadiusFine : m_config.m_maxRadius); //Default 1mm merging in layers 1 & 5, 5mm merging elsewhere
        this->update_map(stepPosition, id, energy, time, true, numberOfProcessedHits, timeWindow, distanceWindow); //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 106 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, double  timeWindow, double  distanceWindow  )

protectedinherited

Definition at line 158 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();
    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 hit_diff2 = currentPosition.diff2( l_vec );
      // Global distance check
      if ( hit_diff2 >= distanceWindow ) { 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 47 of file LArFCS_StepInfoSD.h.

m_calo_dd_man

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

protectedinherited

Definition at line 128 of file FCS_StepInfoSD.h.

m_config

FCS_Param::Config FCS_StepInfoSD::m_config

protectedinherited

Definition at line 122 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 129 of file FCS_StepInfoSD.h.

m_larEmID

const LArEM_ID* FCS_StepInfoSD::m_larEmID {nullptr}

protectedinherited

Pointers to the identifier helpers.

Definition at line 124 of file FCS_StepInfoSD.h.

m_larFcalID

const LArFCAL_ID* FCS_StepInfoSD::m_larFcalID {nullptr}

protectedinherited

Definition at line 125 of file FCS_StepInfoSD.h.

m_larHecID

const LArHEC_ID* FCS_StepInfoSD::m_larHecID {nullptr}

protectedinherited

Definition at line 126 of file FCS_StepInfoSD.h.

m_tileID

const TileID* FCS_StepInfoSD::m_tileID {nullptr}

protectedinherited

Definition at line 127 of file FCS_StepInfoSD.h.

---

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

• LArFCS_StepInfoSD.h
• LArFCS_StepInfoSD.cxx