BeamBackgroundFiller Class Reference

Implementation of the Beam Background Identification Method. More...

#include <BeamBackgroundFiller.h>

Inheritance diagram for BeamBackgroundFiller:

Collaboration diagram for BeamBackgroundFiller:

Classes
struct	Cache

Public Member Functions
	BeamBackgroundFiller (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~BeamBackgroundFiller ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	FillMatchMatrix (const EventContext &ctx, Cache &cache) const
	This function selects the muon segments with the direction parallel to the beam pipe and calorimeter clusters above certain energy threshold.
void	SegmentMethod (Cache &cache) const
	This function looks at the segments found by the FillMatchMatrix function.
void	OneSidedMethod (Cache &cache) const
	This function is the implementation of the "No-Time Method" and the "One-Sided Method".
void	TwoSidedMethod (Cache &cache) const
	This function is the implementation of the "Two-Sided No-Time Method" and the "Two-Sided Method" that looks at the clusters matched with at least one muon segment on side A and one muon segment on side C.
void	ClusterShapeMethod (Cache &cache) const
	This function is the implementation of the "Cluster-Shape Method".
double	GetSegmentTime (const Muon::MuonSegment &pMuonSegment) const
void	FindFakeJets (const EventContext &ctx, Cache &cache) const
	This function checks whether the matched clusters are contained in any jets.
void	FillBeamBackgroundData (SG::WriteHandle< BeamBackgroundData > &beamBackgroundDataWriteHandle, Cache &cache) const
	This function stores all the results in BeamBackgroundData.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKeyArray< Trk::SegmentCollection >	m_segmentKeys
	ReadHandleKey for Trk::SegmentCollection from CSC.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_caloClusterContainerReadHandleKey
	ReadHandleKey for CaloClusterContainer.
SG::ReadHandleKey< xAOD::JetContainer >	m_jetContainerReadHandleKey
	ReadHandleKey for JetContainer.
SG::WriteHandleKey< BeamBackgroundData >	m_beamBackgroundDataWriteHandleKey
ToolHandle< Muon::IMuonSegmentSelectionTool >	m_segmentSelector {this, "SegmentSelector",""}
Gaudi::Property< double >	m_thetaCutNCB {this, "cutThetaNCB", 5. * Gaudi::Units::deg}
	Inclanation cut between the segment position and its direction.
Gaudi::Property< double >	m_cutDphiSegAC {this,"cutPhi", 4.* Gaudi::Units::deg}
Gaudi::Property< double >	m_clusEnergyCut {this,"clustEnergy", 10. *Gaudi::Units::GeV}
	Minimum cut on the cluster energy to be considered.
Gaudi::Property< double >	m_clusRadiusLow {this, "cutRadiusLow", 881. * Gaudi::Units::mm}
Gaudi::Property< double >	m_clusRadiusHigh {this,"cutRadiusHigh", 4250. * Gaudi::Units::mm}
Gaudi::Property< double >	m_cutDphiClusSeg {this, "cutDphiClusSeg", 4.* Gaudi::Units::deg}
Gaudi::Property< double >	m_cutDradClusSeg {this,"cutDrClusSet", 40. * Gaudi::Units::cm}
Gaudi::Property< double >	m_cutMuonTime {this, "cutMuonTime", 25.}
Gaudi::Property< double >	m_cutClusTime {this,"cutClusTime", 2.5}
Gaudi::Property< double >	m_cutTimeDiffAC {this,"cutTimeDiffAC", 25.}
Gaudi::Property< double >	m_cutDrdz {this,"cutDrdz", 0.15}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Implementation of the Beam Background Identification Method.

This implementation defines the selection criteria for identifying beam background muons, and looks for them based on several methods. The result are stored in BeamBackgroundData.

Author

David Salek David.nosp@m..Sal.nosp@m.ek@ce.nosp@m.rn.c.nosp@m.h

Revision

693115

Date

2015-09-04 09:22:39 +0200 (Fri, 04 Sep 2015)

Definition at line 38 of file BeamBackgroundFiller.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

BeamBackgroundFiller()

BeamBackgroundFiller::BeamBackgroundFiller	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 31 of file BeamBackgroundFiller.cxx.

    : AthReentrantAlgorithm(name, pSvcLocator) {
}

~BeamBackgroundFiller()

virtual BeamBackgroundFiller::~BeamBackgroundFiller ( )

virtualdefault

Member Function Documentation

ClusterShapeMethod()

void BeamBackgroundFiller::ClusterShapeMethod ( Cache & cache ) const

private

This function is the implementation of the "Cluster-Shape Method".

The shape of the cluster is described by the variable dr/dz which is the ratio of the standard deviation of the radial position of the contianed cells and the standard deviation of the z-position of the contained cells. Only the clusters matched with muon segments are checked.

Definition at line 575 of file BeamBackgroundFiller.cxx.

                                                                {
  cache.m_numClusterShape = 0;
  cache.m_drdzClus.clear();
 
  for (unsigned int clusIndex = 0; clusIndex < cache.m_indexClus.size();
       clusIndex++) {
 
    const xAOD::CaloCluster* clus = *(cache.m_indexClus[clusIndex]);
 
    double rClus(0.);
    if (!clus->retrieveMoment(xAOD::CaloCluster_v1::CENTER_MAG, rClus))
      rClus = 0;
    rClus = rClus / cosh(clus->eta());
    double zClus = rClus * sinh(clus->eta());
 
    // calculate dr/dz
    double dr = 0.;
    double dz = 0.;
    double drdz = -1.;
    int nCell = 0;
 
    if (clus->getCellLinks() != nullptr) {
      xAOD::CaloCluster::const_cell_iterator firstCell = clus->cell_begin();
      xAOD::CaloCluster::const_cell_iterator lastCell = clus->cell_end();
 
      for (; firstCell != lastCell; ++firstCell) {
        const CaloCell* cell = *firstCell;
 
        if (cell->time() == 0.)
          continue;
        if (cell->energy() < 100.)
          continue;
        nCell++;
 
        // double rCell = sqrt(cell->x()*cell->x() + cell->y()*cell->y());
        // double zCell = cell->z();
        const CaloDetDescrElement* dde = cell->caloDDE();
        const double rCell = dde->r();
        const double zCell = dde->z();
        dr = dr + (rCell - rClus) * (rCell - rClus);
        dz = dz + (zCell - zClus) * (zCell - zClus);
      }
    }
 
    if (nCell) {
      dr = sqrt(dr / nCell);
      dz = sqrt(dz / nCell);
      if (dz > 0.)
        drdz = dr / dz;
    }
 
    cache.m_drdzClus.push_back(drdz);
 
    // check dr/dz
    if (drdz < 0.)
      continue;
    if (drdz < m_cutDrdz) {
      for (unsigned int segIndex = 0; segIndex < cache.m_indexSeg.size();
           segIndex++) {
        if (!(cache.m_matchMatrix[clusIndex][segIndex] & 1))
          continue;
        cache.m_matchMatrix[clusIndex][segIndex] =
            cache.m_matchMatrix[clusIndex][segIndex] |
            BeamBackgroundData::ClusterShape;
        cache.m_resultSeg[segIndex] = cache.m_resultSeg[segIndex] |
                                      cache.m_matchMatrix[clusIndex][segIndex];
      }
      cache.m_resultClus[clusIndex] =
          cache.m_resultClus[clusIndex] | BeamBackgroundData::ClusterShape;
      cache.m_numClusterShape++;
    }
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode BeamBackgroundFiller::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 51 of file BeamBackgroundFiller.cxx.

                                                                      {
 
    Cache cache{};
    // find muon segments from beam background muon candidates and match them with
    // calorimeter clusters
    FillMatchMatrix(ctx, cache);
    // apply Beam Background Identifiaction Methods
    SegmentMethod(cache);
    OneSidedMethod(cache);
    TwoSidedMethod(cache);
    ClusterShapeMethod(cache);
    // identify fake jets
    FindFakeJets(ctx, cache);
 
    // fill the results into BeamBackgroundData
    SG::WriteHandle<BeamBackgroundData> writeHandle(m_beamBackgroundDataWriteHandleKey, ctx);
    ATH_CHECK(writeHandle.record(std::make_unique<BeamBackgroundData>()));
    FillBeamBackgroundData(writeHandle, cache);
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

FillBeamBackgroundData()

void BeamBackgroundFiller::FillBeamBackgroundData ( SG::WriteHandle< BeamBackgroundData > & beamBackgroundDataWriteHandle, Cache & cache ) const

private

This function stores all the results in BeamBackgroundData.

Definition at line 714 of file BeamBackgroundFiller.cxx.

                       {
 
  writeHandle->SetNumSegment(cache.m_numSegment);
  writeHandle->SetNumSegmentEarly(cache.m_numSegmentEarly);
  writeHandle->SetNumSegmentACNoTime(cache.m_numSegmentACNoTime);
  writeHandle->SetNumSegmentAC(cache.m_numSegmentAC);
  writeHandle->SetNumMatched(cache.m_numMatched);
  writeHandle->SetNumNoTimeLoose(cache.m_numNoTimeLoose);
  writeHandle->SetNumNoTimeMedium(cache.m_numNoTimeMedium);
  writeHandle->SetNumNoTimeTight(cache.m_numNoTimeTight);
  writeHandle->SetNumOneSidedLoose(cache.m_numOneSidedLoose);
  writeHandle->SetNumOneSidedMedium(cache.m_numOneSidedMedium);
  writeHandle->SetNumOneSidedTight(cache.m_numOneSidedTight);
  writeHandle->SetNumTwoSidedNoTime(cache.m_numTwoSidedNoTime);
  writeHandle->SetNumTwoSided(cache.m_numTwoSided);
  writeHandle->SetNumClusterShape(cache.m_numClusterShape);
  writeHandle->SetNumJet(cache.m_numJet);
 
  int decision = 0;
  for (unsigned int i = 0; i < cache.m_indexSeg.size(); i++) {
    decision |= cache.m_resultSeg[i];
  }
  for (unsigned int i = 0; i < cache.m_indexClus.size(); i++) {
    decision |= cache.m_resultClus[i];
  }
  writeHandle->SetDecision(decision);
 
  writeHandle->SetDirection(cache.m_direction);
 
  writeHandle->FillIndexSeg(cache.m_indexSeg);
  writeHandle->FillResultSeg(&cache.m_resultSeg);
  writeHandle->FillIndexClus(cache.m_indexClus);
  writeHandle->FillMatchMatrix(&cache.m_matchMatrix);
 
  writeHandle->FillResultClus(&cache.m_resultClus);
  writeHandle->FillIndexJet(cache.m_indexJet);
  writeHandle->FillDrdzClus(&cache.m_drdzClus);
 
  writeHandle->FillIndexJet(cache.m_indexJet);
  writeHandle->FillResultJet(&cache.m_resultJet);
 
  ATH_MSG_DEBUG("parallel segments "
                << cache.m_numSegment << " " << cache.m_numSegmentEarly << " "
                << cache.m_numSegmentACNoTime << " " << cache.m_numSegmentAC);
 
  ATH_MSG_DEBUG("matched clusters "
                << cache.m_numMatched << " " << cache.m_numNoTimeLoose << " "
                << cache.m_numNoTimeMedium << " " << cache.m_numNoTimeTight
                << " " << cache.m_numOneSidedLoose << " "
                << cache.m_numOneSidedMedium << " " << cache.m_numOneSidedTight
                << " " << cache.m_numTwoSidedNoTime << " "
                << cache.m_numTwoSided << " " << cache.m_numClusterShape);
}

FillMatchMatrix()

void BeamBackgroundFiller::FillMatchMatrix ( const EventContext & ctx, Cache & cache ) const

private

This function selects the muon segments with the direction parallel to the beam pipe and calorimeter clusters above certain energy threshold.

Matching matrix is created to store the results of beam background identification for each cluster and segment

Select only the segements from the EI station

match in phi

Definition at line 80 of file BeamBackgroundFiller.cxx.

                                                               {
  //
 
  for (const SG::ReadHandleKey<Trk::SegmentCollection>& key : m_segmentKeys) {
      // select only the CSC segments with the global direction parallel to the
      // beam pipe
      SG::ReadHandle<Trk::SegmentCollection> ncbSegmentHandle(key, ctx);
      if(!ncbSegmentHandle.isPresent()) {
          throw std::runtime_error("Could not load the " + key.key() + " segment container");
      }
      unsigned int ncbCounter = 0;
      for (const Trk::Segment *ncbSegment : *ncbSegmentHandle) {
        ++ncbCounter;
        const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(ncbSegment);
 
        const Identifier id = m_edmHelperSvc->chamberId(*seg);
        if (!id.is_valid()|| !m_idHelperSvc->isMuon(id)) {
           ATH_MSG_WARNING("Found a muon segment in the container which pretends not to be a muon segment..");
           continue;
        }
        Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
        if (stIndex != Muon::MuonStationIndex::StIndex::EI) {
            ATH_MSG_VERBOSE("Segment "<<m_idHelperSvc->toStringChamber(id)<<" is not in EI");
            continue;
        }
        const Amg::Vector3D& globalDir = seg->globalDirection();        
        if (std::abs(globalDir.theta()) < m_thetaCutNCB) {
           continue;
        }
        constexpr int highestSegQual = 3;
        if (!m_segmentSelector->select(*seg,false, highestSegQual)) {
             continue;
        }
        ElementLink<Trk::SegmentCollection> segLink{*ncbSegmentHandle, ncbCounter - 1};
        cache.m_indexSeg.push_back(segLink);
      }
  }
 
  cache.m_resultSeg.assign(cache.m_indexSeg.size(), 0);
 
  // find matching clusters
  SG::ReadHandle<xAOD::CaloClusterContainer> caloClusterContainerReadHandle(m_caloClusterContainerReadHandleKey,ctx);
  if (!caloClusterContainerReadHandle.isPresent()){
     throw std::runtime_error("Failed to load the calorimeter cluster container");
  }
  ATH_MSG_DEBUG(m_caloClusterContainerReadHandleKey<< " retrieved from StoreGate");
 
  constexpr std::array<CaloSampling::CaloSample, 24> caloLayers{CaloSampling::CaloSample::PreSamplerB,
                                                      CaloSampling::CaloSample::EMB1, CaloSampling::CaloSample::EMB2, CaloSampling::CaloSample::EMB3,
                                                      CaloSampling::CaloSample::PreSamplerE,
                                                      CaloSampling::CaloSample::EME1, CaloSampling::CaloSample::EME2, CaloSampling::CaloSample::EME3,
                                                      CaloSampling::CaloSample::FCAL0,
                                                      
                                                      CaloSampling::CaloSample::HEC0, CaloSampling::CaloSample::HEC1, CaloSampling::CaloSample::HEC2, CaloSampling::CaloSample::HEC3,
 
                                                      CaloSampling::CaloSample::TileBar0, CaloSampling::CaloSample::TileBar1, CaloSampling::CaloSample::TileBar2, 
                                                      CaloSampling::CaloSample::TileGap1, CaloSampling::CaloSample::TileGap2, CaloSampling::CaloSample::TileGap3, 
                                                      CaloSampling::CaloSample::TileExt0, CaloSampling::CaloSample::TileExt1, CaloSampling::CaloSample::TileExt2, CaloSampling::CaloSample::FCAL1,
                                                      CaloSampling::CaloSample::FCAL2};
    
    unsigned int caloClusterCounter = 0;
    for (const xAOD::CaloCluster* thisCaloCluster : *caloClusterContainerReadHandle) {
        ++caloClusterCounter;
        double eClus{0.};
        for (auto lay : caloLayers){
            eClus +=thisCaloCluster->eSample(lay);
        }
        // ignore low energy clusters
        if (eClus < m_clusEnergyCut){
          ATH_MSG_VERBOSE("Cluster with energy "<<eClus<<" is below threshold "<<m_clusEnergyCut);
          continue;
        }
        double rClus{0.};
        if (!thisCaloCluster->retrieveMoment(xAOD::CaloCluster_v1::CENTER_MAG, rClus)) {
            ATH_MSG_DEBUG("Failed to retrieve the CENTER_MAG moment");
            continue;
        }
        rClus = rClus / std::cosh(thisCaloCluster->eta());
 
        // remove clusters at low radius (outside the CSC acceptance)
        if (rClus < m_clusRadiusLow || rClus > m_clusRadiusHigh) {
            ATH_MSG_VERBOSE("Radius cut not passed "<<rClus<<" needs to be in "
                          <<m_clusRadiusLow<<" "<<m_clusRadiusHigh);
            continue;
        }
        const double phiClus = thisCaloCluster->phi();
        
 
        std::vector<int> matchedSegmentsPerCluster(cache.m_indexSeg.size(), 0);     
        bool matched{false};
 
        for (unsigned int j = 0; j < cache.m_indexSeg.size(); j++) {
            const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[j]));
        
            const Amg::Vector3D& globalPos = seg->globalPosition();
            const double phiSeg = globalPos.phi();

            if (P4Helpers::deltaPhi(phiClus, phiSeg) < std::abs(m_cutDphiClusSeg)) {
                ATH_MSG_VERBOSE("Delta phi "<<P4Helpers::deltaPhi(phiClus, phiSeg)
                              <<" exceeds maximum cut "<<m_cutDphiClusSeg
                              <<"Segment: "<<Amg::toString(globalPos)<<", phi: "<<globalPos.phi()
                              <<" --- Cluster: "<<phiClus);
                continue;
            }
 
            const double rSeg = globalPos.perp();
            // match in radius
            if (std::abs(rClus - rSeg) > m_cutDradClusSeg) {
                ATH_MSG_VERBOSE("Radial difference "<<std::abs(rClus - rSeg)<<" exceeds maximum cut "<<m_cutDradClusSeg
                            <<"Segment: "<<Amg::toString(globalPos)<<", phi: "<<globalPos.perp()
                            <<" --- Cluster: "<<rClus);            
                continue;
            }
            matchedSegmentsPerCluster[j] = 1;
            matched = true;
            cache.m_resultSeg[j] |= BeamBackgroundData::Matched;
        }
 
        if (!matched) {
            ATH_MSG_VERBOSE("Calo cluster does not match with segment");
            continue;
        }
        ElementLink<xAOD::CaloClusterContainer> clusLink;
        clusLink.toIndexedElement(*caloClusterContainerReadHandle, caloClusterCounter - 1);
        cache.m_indexClus.push_back(std::move(clusLink));
        cache.m_matchMatrix.push_back(std::move(matchedSegmentsPerCluster));
        ++cache.m_numMatched;
    }
  
    cache.m_resultClus.assign(cache.m_indexClus.size(), 1);
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

FindFakeJets()

void BeamBackgroundFiller::FindFakeJets ( const EventContext & ctx, Cache & cache ) const

private

This function checks whether the matched clusters are contained in any jets.

If yes, the jet is marked as fake jet and the corresponding result of the Beam Background Identification Method is stored (using the OR condition if more than one cluster is found within one jet)

Definition at line 656 of file BeamBackgroundFiller.cxx.

                                                            {
  cache.m_numJet = 0;
  cache.m_indexJet.clear();
  cache.m_resultJet.clear();
 
  // find the jet that contains this cluster
  SG::ReadHandle<xAOD::JetContainer> jetContainerReadHandle(
      m_jetContainerReadHandleKey, ctx);
 
  if (!jetContainerReadHandle.isValid()) {
    ATH_MSG_WARNING("Invalid ReadHandle to JetContainer with name: "
                    << m_jetContainerReadHandleKey);
  } else {
    ATH_MSG_DEBUG(m_jetContainerReadHandleKey << " retrieved from StoreGate");
 
    unsigned int jetCounter = 0;
    for (const auto *thisJet : *jetContainerReadHandle) {
      bool isFakeJet = false;
      int resultJet = 0;
 
      xAOD::JetConstituentVector vec = thisJet->getConstituents();
      xAOD::JetConstituentVector::iterator constIt = vec.begin();
      xAOD::JetConstituentVector::iterator constItE = vec.end();
 
      for (; constIt != constItE; ++constIt) {
        if (constIt->type() != xAOD::Type::CaloCluster)
          continue;
        const xAOD::CaloCluster* jetConst =
            dynamic_cast<const xAOD::CaloCluster*>(constIt->rawConstituent());
 
        for (unsigned int clusIndex = 0; clusIndex < cache.m_indexClus.size();
             clusIndex++) {
          const xAOD::CaloCluster* clus = *(cache.m_indexClus[clusIndex]);
 
          if (jetConst == clus) {
            isFakeJet = true;
            resultJet = resultJet | cache.m_resultClus[clusIndex];
          }
        }
      }
 
      if (isFakeJet) {
        ElementLink<xAOD::JetContainer> jetLink;
        jetLink.toIndexedElement(*jetContainerReadHandle, jetCounter);
        cache.m_indexJet.push_back(jetLink);
        cache.m_resultJet.push_back(resultJet);
        cache.m_numJet++;
      }
      jetCounter++;
    }
  }
}

GetSegmentTime()

double BeamBackgroundFiller::GetSegmentTime ( const Muon::MuonSegment & pMuonSegment ) const

private

Need to check how to translate the bcid bitmaps into timings

Definition at line 217 of file BeamBackgroundFiller.cxx.

                                                                                     {
    double time{0.};
    unsigned int nMeas{0};
    for (const Trk::MeasurementBase* meas : pMuonSegment.containedMeasurements()) {
        const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(meas);
        if (!rot) {
          continue;
        }
        ++nMeas;
        const Trk::PrepRawData* prd = rot->prepRawData();
        if (prd->type(Trk::PrepRawDataType::MMPrepData)) {
            const Muon::MMPrepData* mmPrd = static_cast<const Muon::MMPrepData*>(prd);
            time += mmPrd->time();
        } else if (prd->type(Trk::PrepRawDataType::sTgcPrepData)) {
            const Muon::sTgcPrepData* sTgcPrd = static_cast<const Muon::sTgcPrepData*>(prd);
            time += sTgcPrd->time();
        } else if (prd->type(Trk::PrepRawDataType::MdtPrepData)) {
            const Muon::MdtPrepData* mdtPrd = static_cast<const Muon::MdtPrepData*>(prd);
            constexpr double tdcBinSize = 0.78125;  //25/32; exact number: (1000.0/40.079)/32.0
            time += tdcBinSize * mdtPrd->tdc();
        } else if (prd->type(Trk::PrepRawDataType::TgcPrepData)) {
           --nMeas;
        } else if (prd->type(Trk::PrepRawDataType::CscPrepData)) {
          const Muon::CscPrepData* cscPrd = static_cast<const Muon::CscPrepData*>(prd);
          time += cscPrd->time();
        } else {
            ATH_MSG_WARNING("You can't have "<<m_idHelperSvc->toString(prd->identify())<<" in a EI segment.");
            --nMeas;
        }
      
    }
    return time / std::max(nMeas, 1u);
}

initialize()

StatusCode BeamBackgroundFiller::initialize ( )

overridevirtual

Definition at line 37 of file BeamBackgroundFiller.cxx.

                                            {
  CHECK(m_edmHelperSvc.retrieve());
  CHECK(m_idHelperSvc.retrieve());
 
  ATH_CHECK(m_segmentKeys.initialize());
  ATH_CHECK(m_segmentSelector.retrieve(EnableTool{!m_segmentKeys.empty()}));
  ATH_CHECK(m_caloClusterContainerReadHandleKey.initialize());
  ATH_CHECK(m_jetContainerReadHandleKey.initialize());
 
  ATH_CHECK(m_beamBackgroundDataWriteHandleKey.initialize());
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

OneSidedMethod()

void BeamBackgroundFiller::OneSidedMethod ( Cache & cache ) const

private

This function is the implementation of the "No-Time Method" and the "One-Sided Method".

The "One-Sided Method" compares the time of the calorimeter cluster with the expected time. The expected time is calculated based on the direction of the beam background muon which is reconstructed from the position and time of the muon segment. The "No-Time Method" does not use the time information of the muon segment thus the direction of the beam background muon is not known. Therefore, the cluster time is compared to two expected time values (corresponding to both A->C and C->A directions).

Definition at line 362 of file BeamBackgroundFiller.cxx.

                                                            {
  //
  for (unsigned int clusIndex = 0; clusIndex < cache.m_indexClus.size();
       clusIndex++) {
 
    const xAOD::CaloCluster* clus = *(cache.m_indexClus[clusIndex]);
 
    double rClus(0.);
    if (!clus->retrieveMoment(xAOD::CaloCluster_v1::CENTER_MAG, rClus)) {
         continue;
    }
    rClus = rClus / std::cosh(clus->eta());
    double zClus = rClus * std::sinh(clus->eta());
    double tClus = clus->time();
 
    // calculate expected cluster time
    double expectedClusterTimeAC =  -(zClus + std::hypot(rClus, zClus)) * inv_c;
    double expectedClusterTimeCA = -(-zClus + std::hypot(rClus, zClus)) * inv_c;
 
    for (unsigned int segIndex = 0; segIndex < cache.m_indexSeg.size(); segIndex++) {
 
      if (!(cache.m_matchMatrix[clusIndex][segIndex] & BeamBackgroundData::Matched)){
        continue;
      }
      const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[segIndex]));
 
      const Amg::Vector3D& globalPos = seg->globalPosition();
      double zSeg = globalPos.z();
 
      double tSeg = GetSegmentTime(*seg);
 
      // muon segment: in-time (1), early (2), ambiguous (0)
      int timeStatus = 0;
      double inTime = -(-std::abs(zSeg) + globalPos.mag()) * inv_c;
      double early = -(std::abs(zSeg) + globalPos.mag()) * inv_c;
      if (std::abs(tSeg - inTime) < m_cutMuonTime)
        timeStatus = 1;
      if (std::abs(tSeg - early) < m_cutMuonTime)
        timeStatus = 2;
 
      // reconstruct beam background direction: A->C (1), C->A (-1)
      int direction = 0;
      if ((zSeg > 0 && timeStatus == 2) || (zSeg < 0 && timeStatus == 1))
        direction = 1;
      if ((zSeg > 0 && timeStatus == 1) || (zSeg < 0 && timeStatus == 2))
        direction = -1;
 
      // check the cluster time without the beam background direction
      // information
      if (std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime ||
          std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime) {
        cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::NoTimeLoose;
      }
      if ((std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime && -tClus > m_cutClusTime) ||
          (std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime && -tClus > m_cutClusTime)) {
        cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::NoTimeMedium;
      }
      if ((std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime && -tClus > 2. * m_cutClusTime) ||
          (std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime && -tClus > 2. * m_cutClusTime)) {
        cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::NoTimeTight;
      }
 
      // check the cluster time with the beam background direction information
      if (direction == 1) {
        if (std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedLoose;
        }
        if (std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime && -tClus > m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedMedium;
        }
        if (std::abs(tClus - expectedClusterTimeAC) < m_cutClusTime && -tClus > 2. * m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedTight;
        }
      } else if (direction == -1) {
        if (std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedLoose;
        }
        if (std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime && -tClus > m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedMedium;
        }
        if (std::abs(tClus - expectedClusterTimeCA) < m_cutClusTime && -tClus > 2. * m_cutClusTime) {
          cache.m_matchMatrix[clusIndex][segIndex] |= BeamBackgroundData::OneSidedTight;
        }
      }
 
      cache.m_resultClus[clusIndex] |= cache.m_matchMatrix[clusIndex][segIndex];
      cache.m_resultSeg[segIndex] |=  cache.m_matchMatrix[clusIndex][segIndex];
    }
 
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::NoTimeLoose)
      cache.m_numNoTimeLoose++;
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::NoTimeMedium)
      cache.m_numNoTimeMedium++;
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::NoTimeTight)
      cache.m_numNoTimeTight++;
 
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::OneSidedLoose)
      cache.m_numOneSidedLoose++;
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::OneSidedMedium)
      cache.m_numOneSidedMedium++;
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::OneSidedTight)
      cache.m_numOneSidedTight++;
  }
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

SegmentMethod()

void BeamBackgroundFiller::SegmentMethod ( Cache & cache ) const

private

This function looks at the segments found by the FillMatchMatrix function.

The following results are set:

• number of segments with the direciton parallel to the beam pipe (all the segments in the matching matrix)
• number of such segments with early time
• number of segment pairs on side A and C
• number of segment pairs on side A and C with the corresponding time difference

take only the segments on side A (z > 0)

Definition at line 262 of file BeamBackgroundFiller.cxx.

                                                           {
  for (unsigned int segIndex = 0; segIndex < cache.m_indexSeg.size(); ++segIndex) {
 
    const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[segIndex]));
 
    const Amg::Vector3D& globalPos = seg->globalPosition();
    double zSeg = globalPos.z();

    if (zSeg < 0.) {
        continue;
    }
 
    
    double tSeg = GetSegmentTime(*seg);
    cache.m_numSegment++;
    cache.m_resultSeg[segIndex] |= BeamBackgroundData::Segment;
 
    // muon segment: in-time (1), early (2), ambiguous (0)
    int timeStatus = 0;
    double inTime = -(-std::abs(zSeg) + globalPos.mag()) * inv_c;
    double early = -(std::abs(zSeg) + globalPos.mag()) * inv_c;
    if (std::abs(tSeg - inTime) < m_cutMuonTime)
      timeStatus = 1;
    if (std::abs(tSeg - early) < m_cutMuonTime)
      timeStatus = 2;
 
    if (timeStatus == 2) {
      cache.m_numSegmentEarly++;
      cache.m_resultSeg[segIndex] |= BeamBackgroundData::SegmentEarly;
    }
 
 
 
    unsigned int segIndexA = segIndex;
 
    double tSegA = tSeg;
    int timeStatusA = timeStatus;
 
    double phiSegA = globalPos.phi();
 
    for (unsigned int segIndexC = 0; segIndexC < cache.m_indexSeg.size(); segIndexC++) {
 
      const Muon::MuonSegment* segC = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[segIndexC]));
 
      const Amg::Vector3D& globalPos = segC->globalPosition();
      double zSegC = globalPos.z();
 
      // take only the segments on side C (z < 0)
      if (zSegC > 0.) {
        continue;
      }
      double tSegC = GetSegmentTime(*segC);
 
 
 
      // muon segment: in-time (1), early (2), ambiguous (0)
      int timeStatusC = 0;
      double inTime = -(-std::abs(zSegC) + globalPos.mag()) * inv_c;
      double early = -(std::abs(zSegC) + globalPos.mag()) * inv_c;
      if (std::abs(tSegC - inTime) < m_cutMuonTime)
        timeStatusC = 1;
      if (std::abs(tSegC - early) < m_cutMuonTime)
        timeStatusC = 2;
 
      double phiSegC = globalPos.phi();
 
      // match in phi
      if (std::abs(P4Helpers::deltaPhi(phiSegA, phiSegC)) > m_cutDphiSegAC) {
        continue;
      }
      cache.m_numSegmentACNoTime++;
      cache.m_resultSeg[segIndexA] |= BeamBackgroundData::SegmentACNoTime;
      cache.m_resultSeg[segIndexC] |= BeamBackgroundData::SegmentACNoTime;
 
      if (timeStatusA == 0 || timeStatusC == 0)
        continue;
 
      // check the time difference
      if (std::abs(tSegA - tSegC) > m_cutTimeDiffAC) {
        cache.m_numSegmentAC++;
        cache.m_resultSeg[segIndexA] |= BeamBackgroundData::SegmentAC;
        cache.m_resultSeg[segIndexC] |= BeamBackgroundData::SegmentAC;
      }
    }
  }
}

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

TwoSidedMethod()

void BeamBackgroundFiller::TwoSidedMethod ( Cache & cache ) const

private

This function is the implementation of the "Two-Sided No-Time Method" and the "Two-Sided Method" that looks at the clusters matched with at least one muon segment on side A and one muon segment on side C.

In case of the "Two-Sided Method", corresponding time difference of the muon segments is required and the direction of the beam background muon is also stored.

Definition at line 476 of file BeamBackgroundFiller.cxx.

                                                            {
 
 
  for (unsigned int clusIndex = 0; clusIndex < cache.m_indexClus.size(); clusIndex++) {
 
    for (unsigned int segIndexA = 0; segIndexA < cache.m_indexSeg.size(); segIndexA++) {
 
      if (!(cache.m_matchMatrix[clusIndex][segIndexA] & BeamBackgroundData::Matched))
        continue;
 
      const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[segIndexA]));
 
      const Amg::Vector3D& globalPos = seg->globalPosition();
      double zSegA = globalPos.z();
      // take only the segments on side A (z > 0)
      if (zSegA < 0.) {
        continue;
      }
      double tSegA = GetSegmentTime(*seg);
 
      // muon segment: in-time (1), early (2), ambiguous (0)
      int timeStatusA = 0;
      double inTime = -(-std::abs(zSegA) + globalPos.mag()) * inv_c;
      double early = -(std::abs(zSegA) + globalPos.mag()) * inv_c;
      if (std::abs(tSegA - inTime) < m_cutMuonTime)
        timeStatusA = 1;
      if (std::abs(tSegA - early) < m_cutMuonTime)
        timeStatusA = 2;
 
  
      for (unsigned int segIndexC = 0; segIndexC < cache.m_indexSeg.size(); segIndexC++) {
 
        if (!(cache.m_matchMatrix[clusIndex][segIndexC] & BeamBackgroundData::Matched)){
          continue;
        }
        const Muon::MuonSegment* seg = static_cast<const Muon::MuonSegment*>(*(cache.m_indexSeg[segIndexC]));
 
        const Amg::Vector3D& globalPos = seg->globalPosition();
        double zSegC = globalPos.z();
 
        // take only the segments on side C (z < 0)
        if (zSegC > 0.) {
          continue;
        }
 
        double tSegC = GetSegmentTime(*seg);
 
        // muon segment: in-time (1), early (2), ambiguous (0)
        int timeStatusC = 0;
        double inTime = -(-std::abs(zSegC) + globalPos.mag()) * inv_c;
        double early = -(std::abs(zSegC) + globalPos.mag()) * inv_c;
        if (std::abs(tSegC - inTime) < m_cutMuonTime)
          timeStatusC = 1;
        if (std::abs(tSegC - early) < m_cutMuonTime)
          timeStatusC = 2;
 
 
 
        cache.m_matchMatrix[clusIndex][segIndexA] |=BeamBackgroundData::TwoSidedNoTime;
        cache.m_matchMatrix[clusIndex][segIndexC] |=BeamBackgroundData::TwoSidedNoTime;
        cache.m_resultSeg[segIndexA] |= cache.m_matchMatrix[clusIndex][segIndexA];
        cache.m_resultSeg[segIndexC] |= cache.m_matchMatrix[clusIndex][segIndexC];
 
        if (timeStatusA == 0 || timeStatusC == 0)
          continue;
 
        // check the time difference
        if (std::abs(tSegA - tSegC) > m_cutTimeDiffAC) {
          cache.m_matchMatrix[clusIndex][segIndexA] |= BeamBackgroundData::TwoSided;
          cache.m_matchMatrix[clusIndex][segIndexC] |= BeamBackgroundData::TwoSided;
          cache.m_resultSeg[segIndexA] |= cache.m_matchMatrix[clusIndex][segIndexA];
          cache.m_resultSeg[segIndexC] |= cache.m_matchMatrix[clusIndex][segIndexC];
 
          // direction of beam background
          if (timeStatusA == 2)
            cache.m_direction++;  // A->C
          if (timeStatusC == 2)
            cache.m_direction--;  // C->A
        }
      }
 
      cache.m_resultClus[clusIndex] |= cache.m_matchMatrix[clusIndex][segIndexA];
    }
 
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::TwoSidedNoTime)
      cache.m_numTwoSidedNoTime++;
    if (cache.m_resultClus[clusIndex] & BeamBackgroundData::TwoSided)
      cache.m_numTwoSided++;
  }
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_beamBackgroundDataWriteHandleKey

SG::WriteHandleKey<BeamBackgroundData> BeamBackgroundFiller::m_beamBackgroundDataWriteHandleKey

private

Initial value:

{
      this, "BeamBackgroundKey", "BeamBackgroundData",
      "WriteHandleKey for BeamBackgroundData"}

Definition at line 127 of file BeamBackgroundFiller.h.

                                                                         {
      this, "BeamBackgroundKey", "BeamBackgroundData",
      "WriteHandleKey for BeamBackgroundData"};

m_caloClusterContainerReadHandleKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> BeamBackgroundFiller::m_caloClusterContainerReadHandleKey

private

Initial value:

{
          this, "caloClusterContainerKey", "CaloCalTopoClusters",
          "ReadHandleKey for CaloClusterContainer"}

ReadHandleKey for CaloClusterContainer.

Definition at line 117 of file BeamBackgroundFiller.h.

                                         {
          this, "caloClusterContainerKey", "CaloCalTopoClusters",
          "ReadHandleKey for CaloClusterContainer"};

m_clusEnergyCut

Gaudi::Property<double> BeamBackgroundFiller::m_clusEnergyCut {this,"clustEnergy", 10. *Gaudi::Units::GeV}

private

Minimum cut on the cluster energy to be considered.

Definition at line 140 of file BeamBackgroundFiller.h.

{this,"clustEnergy", 10. *Gaudi::Units::GeV};

m_clusRadiusHigh

Gaudi::Property<double> BeamBackgroundFiller::m_clusRadiusHigh {this,"cutRadiusHigh", 4250. * Gaudi::Units::mm}

private

Definition at line 145 of file BeamBackgroundFiller.h.

{this,"cutRadiusHigh", 4250. * Gaudi::Units::mm};

m_clusRadiusLow

Gaudi::Property<double> BeamBackgroundFiller::m_clusRadiusLow {this, "cutRadiusLow", 881. * Gaudi::Units::mm}

private

Definition at line 144 of file BeamBackgroundFiller.h.

{this, "cutRadiusLow", 881. * Gaudi::Units::mm};

m_cutClusTime

Gaudi::Property<double> BeamBackgroundFiller::m_cutClusTime {this,"cutClusTime", 2.5}

private

Definition at line 153 of file BeamBackgroundFiller.h.

{this,"cutClusTime", 2.5};

m_cutDphiClusSeg

Gaudi::Property<double> BeamBackgroundFiller::m_cutDphiClusSeg {this, "cutDphiClusSeg", 4.* Gaudi::Units::deg}

private

Definition at line 147 of file BeamBackgroundFiller.h.

{this, "cutDphiClusSeg", 4.* Gaudi::Units::deg};

m_cutDphiSegAC

Gaudi::Property<double> BeamBackgroundFiller::m_cutDphiSegAC {this,"cutPhi", 4.* Gaudi::Units::deg}

private

Definition at line 137 of file BeamBackgroundFiller.h.

{this,"cutPhi", 4.* Gaudi::Units::deg};

m_cutDradClusSeg

Gaudi::Property<double> BeamBackgroundFiller::m_cutDradClusSeg {this,"cutDrClusSet", 40. * Gaudi::Units::cm}

private

Definition at line 148 of file BeamBackgroundFiller.h.

{this,"cutDrClusSet", 40. * Gaudi::Units::cm};

m_cutDrdz

Gaudi::Property<double> BeamBackgroundFiller::m_cutDrdz {this,"cutDrdz", 0.15}

private

Definition at line 155 of file BeamBackgroundFiller.h.

{this,"cutDrdz", 0.15};

m_cutMuonTime

Gaudi::Property<double> BeamBackgroundFiller::m_cutMuonTime {this, "cutMuonTime", 25.}

private

Definition at line 152 of file BeamBackgroundFiller.h.

{this, "cutMuonTime", 25.};

m_cutTimeDiffAC

Gaudi::Property<double> BeamBackgroundFiller::m_cutTimeDiffAC {this,"cutTimeDiffAC", 25.}

private

Definition at line 154 of file BeamBackgroundFiller.h.

{this,"cutTimeDiffAC", 25.};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> BeamBackgroundFiller::m_edmHelperSvc

private

Initial value:

{
      this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
      "Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 156 of file BeamBackgroundFiller.h.

                                                     {
      this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
      "Handle to the service providing the IMuonEDMHelperSvc interface"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> BeamBackgroundFiller::m_idHelperSvc

private

Initial value:

{
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 159 of file BeamBackgroundFiller.h.

                                                   {
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_jetContainerReadHandleKey

SG::ReadHandleKey<xAOD::JetContainer> BeamBackgroundFiller::m_jetContainerReadHandleKey

private

Initial value:

{
      this, "jetContainerKey", "AntiKt4EMTopoJets",
      "ReadHandleKey for JetContainer"}

ReadHandleKey for JetContainer.

Definition at line 122 of file BeamBackgroundFiller.h.

                                                               {
      this, "jetContainerKey", "AntiKt4EMTopoJets",
      "ReadHandleKey for JetContainer"};

m_segmentKeys

SG::ReadHandleKeyArray<Trk::SegmentCollection> BeamBackgroundFiller::m_segmentKeys

private

Initial value:

{
      this, "SegmentKeys", {"NCB_TrackMuonSegments", }  ,
      "Muon segment collections from the MS patterns"}

ReadHandleKey for Trk::SegmentCollection from CSC.

Definition at line 111 of file BeamBackgroundFiller.h.

                                                          {
      this, "SegmentKeys", {"NCB_TrackMuonSegments", /*"TrackMuonSegments" */}  ,
      "Muon segment collections from the MS patterns"};

m_segmentSelector

ToolHandle<Muon::IMuonSegmentSelectionTool> BeamBackgroundFiller::m_segmentSelector {this, "SegmentSelector",""}

private

Definition at line 131 of file BeamBackgroundFiller.h.

{this, "SegmentSelector",""};

m_thetaCutNCB

Gaudi::Property<double> BeamBackgroundFiller::m_thetaCutNCB {this, "cutThetaNCB", 5. * Gaudi::Units::deg}

private

Inclanation cut between the segment position and its direction.

Definition at line 135 of file BeamBackgroundFiller.h.

{this, "cutThetaNCB", 5. * Gaudi::Units::deg};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• BeamBackgroundFiller.h
• BeamBackgroundFiller.cxx