eflowCellSubtractionFacilitator Class Reference

This class deals with the removal of calorimeter cells from calorimeter clusters. More...

#include <eflowCellSubtractionFacilitator.h>

Inheritance diagram for eflowCellSubtractionFacilitator:

Collaboration diagram for eflowCellSubtractionFacilitator:

Public Member Functions
	eflowCellSubtractionFacilitator ()
double	subtractCells (eflowRingSubtractionManager &ringSubtractionManager, eflowRecTrack &theTrack, xAOD::CaloCluster *tracksClus, eflowCellList &orderedCells, bool &annFlag, const bool &addCPData) const
double	subtractCells (eflowRingSubtractionManager &ringSubtractionManager, eflowRecTrack &theTrack, std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClus, eflowCellList &orderedCells, bool &annFlag, const bool &addCPData) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
void	subtractPartialRings (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, CellIt beginRing, CellIt endRing, double targetRingEnergy, double eRing, eflowRecTrack &theTrack, const bool &addCPData) const
void	subtractFullRings (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, CellIt beginRing, CellIt endRing, eflowRecTrack &theTrack, const bool &addCPData) const
bool	subtractRings (eflowRingSubtractionManager &ringSubtractionManager, const std::pair< eflowCaloENUM, short > &ring, double &eSubtracted, const double eExpect, eflowCellList &orderedCells, std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, bool &annFlag, eflowRecTrack &theTrack, const bool &addCPData) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static CaloClusterCellLink::iterator	getCellIterator (xAOD::CaloCluster *thisCluster, const CaloCell *thisCell)
static void	updateClusterKinematics (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters)
static void	updateClusterKinematics (xAOD::CaloCluster *)
static double	getTotalEnergy (const std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters)
static double	getRingsEnergy (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, CellIt beginRing, CellIt endRing)
static bool	subtractCaloCell (double &eSubtracted, const double eExpect, xAOD::CaloCluster *cluster, const CaloCell *cell, eflowRecTrack &theTrack, const bool &addCPData)
static void	annihilateClusters (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, bool &annFlag, eflowRecTrack &theTrack, const bool &addCPData)
static bool	subtractReorderedCells (std::vector< std::pair< xAOD::CaloCluster *, bool > > &tracksClusters, double eSubtracted, const double eExpect, eflowCellList &orderedCells, eflowRecTrack &theTrack, const bool &addCPData)

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

This class deals with the removal of calorimeter cells from calorimeter clusters.

The main entry points are the subtractCells methods which find out how much energy they should subtract from the eflowRingSubtractionManager. The eflowRingSubtractionManager also contains a list of calorimeter cell rings (a ring is a list of calorimeter cells, in a given calorimeter layer, between two radii r1 and r2). The cell information is stored in the eflowCellList. Rings are removed one by one in the order they are stored until the summed cell ring energy is >= to the expected energy deposit from the track in the calorimeter.

Definition at line 36 of file eflowCellSubtractionFacilitator.h.

Constructor & Destructor Documentation

eflowCellSubtractionFacilitator()

eflowCellSubtractionFacilitator::eflowCellSubtractionFacilitator

(

)

Definition at line 19 of file eflowCellSubtractionFacilitator.cxx.

  : AsgMessaging("eflowCellSubtractionFacilitator")
{}

Member Function Documentation

annihilateClusters()

void eflowCellSubtractionFacilitator::annihilateClusters ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, bool & annFlag, eflowRecTrack & theTrack, const bool & addCPData )

staticprivate

Definition at line 96 of file eflowCellSubtractionFacilitator.cxx.

{
  for (auto& thisPair : tracksClusters) {
    xAOD::CaloCluster* thisCluster = thisPair.first;
    CaloClusterCellLink* theCellLink = thisCluster->getOwnCellLinks();
    CaloClusterCellLink::iterator theFirstCell = theCellLink->begin();
    CaloClusterCellLink::iterator theLastCell = theCellLink->end();
 
    //We don't advance the iterator, theCell, because we call removeCell. This avoids issues with
    //invalid iterators that would otherwise occur and cause only a subset of cells to be processed.
    //We also have to reset the lastCell iterator after each call to ensure the loop exits at the end, 
    //instead of being stuck in an infinite loop.
    for (; theFirstCell != theLastCell;){
      if (addCPData) theTrack.addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theFirstCell.index()),theFirstCell.weight());
      thisCluster->removeCell(*theFirstCell);
      theLastCell = theCellLink->end();
    }
    thisCluster->setCalE(0.0);
    thisCluster->setRawE(0.0);
    // set the subtracted status to true
    thisPair.second = true;
  }
  annFlag = true;
}

getCellIterator()

CaloClusterCellLink::iterator eflowCellSubtractionFacilitator::getCellIterator ( xAOD::CaloCluster * thisCluster, const CaloCell * thisCell )

staticprivate

Definition at line 400 of file eflowCellSubtractionFacilitator.cxx.

{
 
  // SLOW! Can we move to directly work with iterators in future?
 
  // We have to use non-const iterators so that we are allowed to modify the
  // cell weights
  CaloClusterCellLink* theCells = thisCluster->getOwnCellLinks();
 
  CaloClusterCellLink::iterator itCell = theCells->begin();
  CaloClusterCellLink::iterator endCell = theCells->end();
  for (; itCell != endCell; ++itCell) {
    const CaloCell* pCell = (*itCell);
    if (pCell == thisCell) { // Pointer comparison!
      return itCell;
    }
  }
 
  // if no match is found then return end of container
  return endCell;
}

getRingsEnergy()

double eflowCellSubtractionFacilitator::getRingsEnergy ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, CellIt beginRing, CellIt endRing )

staticprivate

Definition at line 71 of file eflowCellSubtractionFacilitator.cxx.

{
  /* Get total energy of ringes from beginRing to endRing */
 
  double eRing(0.0);
  for (CellIt it = beginRing; it != endRing; ++it) {
    /* Loop over Rings */
    for (auto thisCell : it->second) {
      /* Loop over Cells */
      std::pair<const CaloCell*, int> thisPair = thisCell;
      xAOD::CaloCluster* clus = tracksClusters[thisPair.second].first;
      CaloClusterCellLink::iterator theIterator =
        eflowCellSubtractionFacilitator::getCellIterator(clus, thisPair.first);
      double cellWeight = theIterator.weight();
      eRing += thisPair.first->energy() * cellWeight;
    }
  }
 
  return eRing;
}

getTotalEnergy()

double eflowCellSubtractionFacilitator::getTotalEnergy ( const std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters )

staticprivate

Definition at line 60 of file eflowCellSubtractionFacilitator.cxx.

{
  double eClustersOld = 0;
  /* Summed energy of all clusters before subtraction */
  for (auto thisPair : tracksClusters)
    eClustersOld += (thisPair.first)->e();
  return eClustersOld;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

subtractCaloCell()

bool eflowCellSubtractionFacilitator::subtractCaloCell ( double & eSubtracted, const double eExpect, xAOD::CaloCluster * cluster, const CaloCell * cell, eflowRecTrack & theTrack, const bool & addCPData )

staticprivate

Definition at line 257 of file eflowCellSubtractionFacilitator.cxx.

{
 
  CaloClusterCellLink::iterator theIterator =
    eflowCellSubtractionFacilitator::getCellIterator(cluster, cell);
  double oldCellWeight = theIterator.weight();
  double oldCellEnergy = cell->energy() * oldCellWeight;
 
  if (oldCellEnergy != 0. && eSubtracted + oldCellEnergy > eExpect) {
    /* Target cell energy is cell energy minus the energy that still needs to be
     * subtracted */
    double targetCellEnergy = oldCellEnergy - (eExpect - eSubtracted);
 
    double energyWeight = targetCellEnergy / oldCellEnergy;
    double newCellWeight = oldCellWeight * energyWeight;
    theIterator.reweight(newCellWeight);
    if (addCPData) theTrack.addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theIterator.index()), energyWeight*theIterator.weight());
 
    eSubtracted = eExpect;
 
    /* Update the cluster four-momenta having done the subtraction */
    updateClusterKinematics(cluster);
 
    return true;
 
  } else {
    if (addCPData) theTrack.addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theIterator.index()),theIterator.weight());
    cluster->removeCell(cell);
    eSubtracted += oldCellEnergy;
 
    /* Update the clusters having done the subtraction */
    updateClusterKinematics(cluster);
    return false;
  }
}

subtractCells() [1/2]

double eflowCellSubtractionFacilitator::subtractCells	(	eflowRingSubtractionManager &	ringSubtractionManager,
		eflowRecTrack &	theTrack,
		std::vector< std::pair< xAOD::CaloCluster *, bool > > &	tracksClus,
		eflowCellList &	orderedCells,
		bool &	annFlag,
		const bool &	addCPData ) const

Definition at line 334 of file eflowCellSubtractionFacilitator.cxx.

{
 
  const double trackEnergy = theTrack.getTrack()->e();
  const double eExpect = cellSubtractionManager.fudgeMean() * trackEnergy;
  const double sigmaEExpect =
    cellSubtractionManager.fudgeStdDev() * trackEnergy;
  ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: For track with trackEnergy "
                << trackEnergy << " expect to subtract " << eExpect
                << " with width of " << sigmaEExpect);
 
  double eSubtracted = 0.0;
 
  /*
   * Ring subtraction
   */
  std::map<double, RingId>::const_iterator ringIt =
    cellSubtractionManager.rankBegin();
  std::map<double, RingId>::const_iterator ringEnd =
    cellSubtractionManager.rankEnd();
  for (; ringIt != ringEnd; ++ringIt) {
    bool isFinished = subtractRings(cellSubtractionManager,
                                    ringIt->second,
                                    eSubtracted,
                                    eExpect,
                                    orderedCells,
                                    tracksClusters,
                                    annFlag,
                                    theTrack,
                                    addCPData);
    if (isFinished) {
      return sigmaEExpect;
    }
  }
 
  /* Update the cluster four-momenta */
  updateClusterKinematics(tracksClusters);
 
  if (orderedCells.mapSize() <= 0 || eSubtracted >= eExpect) {
    return sigmaEExpect;
  }
 
  /*
   * Cell subtraction
   */
  /* Increasing dR (not by layer) for cell subtraction */
  orderedCells.reorderWithoutLayers();
 
  bool isFinished =
    subtractReorderedCells(tracksClusters, eSubtracted, eExpect, orderedCells, theTrack, addCPData);
  if (isFinished) {
    return sigmaEExpect;
  }
 
  /* Update the cluster four-momenta */
  updateClusterKinematics(tracksClusters);
 
  return sigmaEExpect;
}

subtractCells() [2/2]

double eflowCellSubtractionFacilitator::subtractCells	(	eflowRingSubtractionManager &	ringSubtractionManager,
		eflowRecTrack &	theTrack,
		xAOD::CaloCluster *	tracksClus,
		eflowCellList &	orderedCells,
		bool &	annFlag,
		const bool &	addCPData ) const

Definition at line 24 of file eflowCellSubtractionFacilitator.cxx.

{
  std::vector<std::pair<xAOD::CaloCluster*, bool>> localClusterBoolPairVec(
    1, std::pair(tracksCluster, false));
  return subtractCells(
    cellSubtractionManager, theTrack, localClusterBoolPairVec, orderedCells, annFlag, addCPData);
}

subtractFullRings()

void eflowCellSubtractionFacilitator::subtractFullRings ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, CellIt beginRing, CellIt endRing, eflowRecTrack & theTrack, const bool & addCPData ) const

private

Definition at line 157 of file eflowCellSubtractionFacilitator.cxx.

{
  /* Subtract full ring */
 
  for (CellIt itRing = beginRing; itRing != endRing; ++itRing) {
    /* Loop over Rings */
    for (auto thisCell : itRing->second) {
      /* Loop over Cells */
      std::pair<const CaloCell*, int> thisPair = thisCell;
      xAOD::CaloCluster* cluster = tracksClusters[thisPair.second].first;
      // flag this cluster as having had subtraction applied to it
      tracksClusters[thisPair.second].second = true;
      ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: Cluster with e "
                    << cluster->e() << " is removing cell with e "
                    << thisPair.first->e());
      CaloClusterCellLink::iterator theIterator = this->getCellIterator(cluster, thisPair.first);
      if (addCPData) theTrack.addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theIterator.index()),theIterator.weight());
      cluster->removeCell(thisPair.first);
    }
  }
}

subtractPartialRings()

void eflowCellSubtractionFacilitator::subtractPartialRings ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, CellIt beginRing, CellIt endRing, double targetRingEnergy, double eRing, eflowRecTrack & theTrack, const bool & addCPData ) const

private

Definition at line 124 of file eflowCellSubtractionFacilitator.cxx.

{
  for (CellIt itRing = beginRing; itRing != endRing; ++itRing) {
    /* Loop over Rings */
    for (auto thisCell : itRing->second) {
      /* Loop over Cells */
      std::pair<const CaloCell*, int> thisPair = thisCell;
      xAOD::CaloCluster* cluster = tracksClusters[thisPair.second].first;
      // flag this cluster as having had subtraction applied to it
      tracksClusters[thisPair.second].second = true;
      const CaloCell* cell = thisPair.first;
      CaloClusterCellLink::iterator theIterator =
        eflowCellSubtractionFacilitator::getCellIterator(cluster, cell);
      double oldCellWeight = theIterator.weight();
      double ringWeight = targetRingEnergy / eRings;
      const double newCellWeight = oldCellWeight * ringWeight;
      ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: Cluster with e "
                    << cluster->e()
                    << " is changing weight of cell with energy " << cell->e()
                    << " from " << oldCellWeight << " to " << newCellWeight);
      theIterator.reweight(newCellWeight);
      if (addCPData) theTrack.addSubtractedCaloCell(ElementLink<CaloCellContainer>("AllCalo",theIterator.index()),newCellWeight);
    }
  }
}

subtractReorderedCells()

bool eflowCellSubtractionFacilitator::subtractReorderedCells ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, double eSubtracted, const double eExpect, eflowCellList & orderedCells, eflowRecTrack & theTrack, const bool & addCPData )

staticprivate

Definition at line 299 of file eflowCellSubtractionFacilitator.cxx.

{
  CellIt itCellPosition = reorderedCells.begin();
  CellIt endCellPosition = reorderedCells.end();
  while (itCellPosition != endCellPosition) {
    /* Loop cells */
    std::vector<std::pair<const CaloCell*, int>>::iterator itEntry =
      itCellPosition->second.begin();
    std::vector<std::pair<const CaloCell*, int>>::iterator endEntry =
      itCellPosition->second.end();
    for (; itEntry != endEntry; ++itEntry) {
      const std::pair<const CaloCell*, int> thisPair = *itEntry;
      xAOD::CaloCluster* cluster = tracksClusters[thisPair.second].first;
      // flag this cluster as having had subtraction applied to it
      tracksClusters[thisPair.second].second = true;
      const CaloCell* cell = thisPair.first;
      bool isFinished = subtractCaloCell(eSubtracted, eExpect, cluster, cell, theTrack, addCPData);
      if (isFinished)
        return true;
    }
    /* Erase the CellPosition from the cell list */
    CellIt tmp = itCellPosition;
    ++itCellPosition;
    reorderedCells.deleteFromList(tmp);
  }
  return false;
}

subtractRings()

bool eflowCellSubtractionFacilitator::subtractRings ( eflowRingSubtractionManager & ringSubtractionManager, const std::pair< eflowCaloENUM, short > & ring, double & eSubtracted, const double eExpect, eflowCellList & orderedCells, std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters, bool & annFlag, eflowRecTrack & theTrack, const bool & addCPData ) const

private

Definition at line 184 of file eflowCellSubtractionFacilitator.cxx.

{
  /* Subtract energy from ring, return TRUE if the whole expected energy is
   * subtracted */
 
  const eflowCaloENUM subtLayer = ring.first;
  const short ringNo = ring.second;
 
  const double r1 = ringNo * cellSubtractionManager.ringThickness(subtLayer);
  const double r2 =
    (ringNo + 1) * cellSubtractionManager.ringThickness(subtLayer);
 
  CellIt beginRing = orderedCells.getLowerBound(subtLayer, r1);
  CellIt endRing = orderedCells.getLowerBound(subtLayer, r2);
 
  /* Get total energy of Rings from beginRing to endRing */
  double eRings = getRingsEnergy(tracksClusters, beginRing, endRing);
 
  if (eSubtracted + eRings > eExpect) {
    /* Subtract partial ring */
 
    ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: Subtracting partial ring, "
                  "eSubtracted, eRings and eExpect are "
                  << eSubtracted << ", " << eRings << ", " << eExpect);
 
    /* Target ring energy is ring energy minus the energy that still needs to be
     * subtracted */
    double targetRingEnergy = eRings - (eExpect - eSubtracted);
    ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: targetRingEnergy is "
                  << targetRingEnergy);
    subtractPartialRings(
      tracksClusters, beginRing, endRing, targetRingEnergy, eRings, theTrack, addCPData);
    eSubtracted = eExpect;
 
    /* Update the cluster four-momenta having done the subtraction */
    updateClusterKinematics(tracksClusters);
 
    return true;
 
  } else {
    /* Subtract full ring */
 
    ATH_MSG_DEBUG("eflowCellSubtractionFacilitator: Subtracting full ring ");
 
    subtractFullRings(tracksClusters, beginRing, endRing, theTrack, addCPData);
    orderedCells.deleteFromList(beginRing, endRing);
    eSubtracted += eRings;
 
    /* If no energy left */
    double eClustersOld = getTotalEnergy(tracksClusters);
    if (fabs(eClustersOld - eSubtracted) < 1.0e-6 * eClustersOld) {
      /* Annihilate clusters, clear orderedCells, and update subtracted cluster
       * kinematics */
      annihilateClusters(tracksClusters,annFlag, theTrack, addCPData);
      orderedCells.eraseList();
      updateClusterKinematics(tracksClusters);
 
      return true;
    }
 
    return false;
  }
}

updateClusterKinematics() [1/2]

void eflowCellSubtractionFacilitator::updateClusterKinematics ( std::vector< std::pair< xAOD::CaloCluster *, bool > > & tracksClusters )

staticprivate

Definition at line 38 of file eflowCellSubtractionFacilitator.cxx.

{
  for (auto thisPair : tracksClusters)
    updateClusterKinematics(thisPair.first);
}

updateClusterKinematics() [2/2]

void eflowCellSubtractionFacilitator::updateClusterKinematics ( xAOD::CaloCluster * theCluster )

staticprivate

Definition at line 46 of file eflowCellSubtractionFacilitator.cxx.

{
  float oldEnergy = theCluster->e();
  CaloClusterKineHelper::calculateKine(theCluster, true, true);
  if (0.0 != oldEnergy) {
    float energyAdjustment = theCluster->e() / oldEnergy;
    theCluster->setRawE(theCluster->rawE() * energyAdjustment);
    theCluster->setRawEta(theCluster->eta());
    theCluster->setRawPhi(theCluster->phi());
  }
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• eflowCellSubtractionFacilitator.h
• eflowCellSubtractionFacilitator.cxx