TrigZFinder Class Reference

#include <TrigZFinder.h>

Inheritance diagram for TrigZFinder:

Collaboration diagram for TrigZFinder:

Public Member Functions
	TrigZFinder (const std::string &, const std::string &, const IInterface *)
virtual	~TrigZFinder ()
virtual StatusCode	initialize () override
virtual TrigVertexCollection *	findZ (const std::vector< TrigSiSpacePointBase > &spVec, const IRoiDescriptor &roi) const override
void	initializeInternal (long maxLayers, long lastBarrel)
std::vector< vertex > *	findZInternal (const std::vector< TrigSiSpacePointBase > &spVec, const IRoiDescriptor &roi) const
void	setLayers (long maxLayers, long lastBarrelLayer)
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Public Attributes
ToolHandle< ITrigL2LayerNumberTool >	m_numberingTool
	no private data members - all inherited from the TrigZFinderInternal class NB: BE CAREFUL !

Protected Member Functions
const std::string &	getType () const
const std::string &	getName () const
long	fillVectors (const std::vector< TrigSiSpacePointBase > &spVec, const IRoiDescriptor &roi, std::vector< double > &phi, std::vector< double > &rho, std::vector< double > &zed, std::vector< long > &lyr, std::vector< long > &filledLayers, long &numPhiSlices) const
double	computeZV (double r1, double z1, double r2, double z2) const
double	computeZV (double r1, double p1, double z1, double r2, double p2, double z2) const
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.

Protected Attributes
long	m_IdScan_MaxNumLayers
	maximum number of layers and last barrel layer
long	m_IdScan_LastBrlLayer
double	m_invPhiSliceSize = 0.0
long	m_NumPhiSlices = 0L
double	m_phiBinSize
bool	m_forcePhiBinSize = false
double	m_usedphiBinSize
double	m_ROIphiWidth
double	m_minZBinSize
double	m_zBinSizeEtaCoeff
long	m_numberOfPeaks
bool	m_pixOnly
std::string	m_type
std::string	m_name
bool	m_chargeAware
bool	m_zHistoPerPhi
double	m_dphideta
double	m_neighborMultiplier
std::vector< std::vector< long > >	m_extraPhi
int	m_nFirstLayers
double	m_vrtxDistCut
double	m_vrtxMixing
int	m_nvrtxSeparation
bool	m_preferCentralZ
bool	m_trustSPprovider
double	m_returnval = 0.0
bool	m_fullScanMode
int	m_tripletMode
double	m_tripletDZ
double	m_tripletDK
double	m_halfTripletDK
double	m_tripletDP
int	m_maxLayer
double	m_minVtxSignificance
double	m_percentile
double	m_weightThreshold
	to apply a threshold to the found vertex candidates
std::vector< int >	m_new2old

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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

Definition at line 40 of file TrigZFinder.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigZFinder()

TrigZFinder::TrigZFinder	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 26 of file TrigZFinder.cxx.

                                                                                                : 
  TrigZFinder::TrigZFinderInternal(type, name), AthAlgTool( type, name, parent ),
  m_numberingTool("TrigL2LayerNumberTool")
{
  declareInterface< ITrigZFinder >( this );
 
  //  std::cout << "ZFinder::ZFinder() " << name << " " << type << "\tm_nFirstLayers  " << m_nFirstLayers  << std::endl;
  //  std::cout << "ZFinder::ZFinder() version " << name << " " << type << "\tTrigZFinder-00-00-62"<< std::endl;
 
  declareProperty( "PhiBinSize",         m_phiBinSize       = 0.2   );
  declareProperty( "ForcePhiBinSize",    m_forcePhiBinSize  = false );
  declareProperty( "UseOnlyPixels",      m_pixOnly          = false );
  declareProperty( "MinZBinSize",        m_minZBinSize      = 0.2   );
  declareProperty( "nFirstLayers",       m_nFirstLayers     = 3     );
  declareProperty( "ZBinSizeEtaCoeff",   m_zBinSizeEtaCoeff = 0.1   );
  declareProperty( "DPhiDEta",           m_dphideta         = -0.02 );
  declareProperty( "NeighborMultiplier", m_neighborMultiplier = 1.);
  declareProperty( "NumberOfPeaks",      m_numberOfPeaks    = 1     );
  declareProperty( "ChargeAware",        m_chargeAware      = false );
  declareProperty( "ZHistoPerPhi",       m_zHistoPerPhi     = false );
  declareProperty( "VrtxDistCut",        m_vrtxDistCut      = 0.    );
  declareProperty( "nVrtxSeparation",    m_nvrtxSeparation  = 0     );
  declareProperty( "VrtxMixing",         m_vrtxMixing       = 0.    );
  declareProperty( "PreferCentralZ",     m_preferCentralZ   = true  );
  declareProperty( "TrustSPProvider",    m_trustSPprovider  = true  );
  declareProperty( "FullScanMode",       m_fullScanMode     = false );
  declareProperty( "TripletMode",        m_tripletMode      = 0     ); 
  declareProperty( "TripletDZ",          m_tripletDZ        = 25.   );
  declareProperty( "TripletDK",          m_tripletDK        = 0.005 );
  declareProperty( "TripletDP",          m_tripletDP        = 0.05  );
  declareProperty( "WeightThreshold",    m_weightThreshold  = 0     );
  declareProperty( "MaxLayer",           m_maxLayer        = 32    );
  declareProperty( "MinVtxSignificance", m_minVtxSignificance  = 0  );
  declareProperty( "Percentile",         m_percentile          = 1  );
 
 
  declareProperty( "LayerNumberTool", m_numberingTool);
 
  //  std::cout << "ZFinder::ZFinder() " << name << " " << type << "\tm_nFirstLayers  " << m_nFirstLayers  << std::endl;
 
}

~TrigZFinder()

virtual TrigZFinder::~TrigZFinder ( )

inlinevirtual

Definition at line 45 of file TrigZFinder.h.

{};

Member Function Documentation

computeZV() [1/2]

double TrigZFinderInternal::computeZV ( double r1, double p1, double z1, double r2, double p2, double z2 ) const

protectedinherited

Definition at line 170 of file TrigZFinderInternal.cxx.

                                           {
 
  double x1, y1, x2, y2;
  //sincos( p1, &y1, &x1 );  x1 *= r1;  y1 *= r1;
  //sincos( p2, &y2, &x2 );  x2 *= r2;  y2 *= r2;
  x1 = r1 * cos(p1);
  x2 = r2 * cos(p2);
  y1 = r1 * sin(p1);
  y2 = r2 * sin(p2);
 
#define _COMPUTEX0_
 
#ifdef _COMPUTEX0_
  double slope = (y2-y1)/(x2-x1);
  double invslope = 1./slope;
  double x0 = (slope*x1-y1)/(slope+invslope);
  //double y0 = -1*x0*invslope;
  double d0sqr = x0*x0*(1+invslope*invslope);
  // s1 and s2 are the track lengths from the point of closest approach
  double s1 = sqrt(r1*r1-d0sqr);
  double s2 = sqrt(r2*r2-d0sqr); // or s1*(x1-x0)/(x2-x0)
#else
  double inv_dels = 1./sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );
  double dotrr = x1*x2 + y1*y2;
  double s1 = ( dotrr - r1*r1 ) * inv_dels;
  double s2 = ( r2*r2 - dotrr ) * inv_dels;
#endif
 
  return (z2*s1-z1*s2)/(s1-s2);
}

computeZV() [2/2]

double TrigZFinderInternal::computeZV ( double r1, double z1, double r2, double z2 ) const

protectedinherited

Definition at line 166 of file TrigZFinderInternal.cxx.

                                                                                      {
  return (z2*r1-z1*r2)/(r1-r2);
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

fillVectors()

long TrigZFinderInternal::fillVectors ( const std::vector< TrigSiSpacePointBase > & spVec, const IRoiDescriptor & roi, std::vector< double > & phi, std::vector< double > & rho, std::vector< double > & zed, std::vector< long > & lyr, std::vector< long > & filledLayers, long & numPhiSlices ) const

protectedinherited

get from roi now

DOES NOT span the phi=pi boundary

DOES span the phi=pi boundary

resize excluding points outside the RoI

Definition at line 203 of file TrigZFinderInternal.cxx.

{
 
  std::vector<bool> lcount( m_IdScan_MaxNumLayers, false );
 
  // full scan check
  std::vector<TrigSiSpacePointBase>::const_iterator SpItr = spVec.begin();
 
  long nSPs = spVec.size();
 
  // to shift the phi of space points as if the RoI starts at phi~0
  // assumes that RoI->phi0() and the SPs are in range [-pi,+pi]
  //
  double roiPhiMin, roiPhiMax;
 
  if ( m_fullScanMode || roi.isFullscan() ) { 
    roiPhiMin = -M_PI;
    roiPhiMax =  M_PI;
  }
  else { 
    // If we trust that all the SPs are properly input, we determine the RoI phi width
    //  using the SPs themselves.
    //  If the RoI phi range is wider than pi, we keep everything as usual.
    if ( m_trustSPprovider  &&  m_ROIphiWidth < M_PI )
    {
      double roiPhiPosMin( 9.9), roiPhiPosMax(0);
      double roiPhiNegMin(-9.9), roiPhiNegMax(0);  // least negative and most negative
      for(long i=0; i<nSPs; ++i, ++SpItr)
      {
        double spphi = SpItr->phi();
        if ( spphi>0  &&  spphi>roiPhiPosMax )  roiPhiPosMax = spphi;
        if ( spphi>0  &&  spphi<roiPhiPosMin )  roiPhiPosMin = spphi;
 
        if ( spphi<0  &&  spphi<roiPhiNegMax )  roiPhiNegMax = spphi;
        if ( spphi<0  &&  spphi>roiPhiNegMin )  roiPhiNegMin = spphi;
      }
 
      if ( roiPhiNegMax > roiPhiNegMin )  { 
        // if all SPs are in (0, pi):
        roiPhiMin = roiPhiPosMin; 
        roiPhiMax = roiPhiPosMax;
      }
      else if ( roiPhiPosMax < roiPhiPosMin )  { 
        // if all SPs are in (-pi, 0):
        roiPhiMin = roiPhiNegMax; 
        roiPhiMax = roiPhiNegMin; 
      }
      else if ( roiPhiPosMin - roiPhiNegMin < M_PI )  { 
        // if we have an RoI that covers phi=0 axis
        roiPhiMin = roiPhiNegMax; 
        roiPhiMax = roiPhiPosMax;
      }
      else  { 
        // if we have an RoI that covers phi=pi axis
        roiPhiMin = roiPhiPosMin; 
        roiPhiMax = roiPhiNegMin; 
      }
 
      roiPhiMin -= 1e-10;
      roiPhiMax += 1e-10;
 
      SpItr = spVec.begin();  // rewind the iterator 
    }
    else  {

      if ( roi.phiMinus()==roi.phiPlus() ) { 
        roiPhiMin = roi.phi()-0.5*m_ROIphiWidth;
        roiPhiMax = roi.phi()+0.5*m_ROIphiWidth;
        if(roiPhiMin<-M_PI) roiPhiMin+=2*M_PI;
        if(roiPhiMax>M_PI)  roiPhiMax-=2*M_PI;
      }
      else {
        // already wrapped by RoiDescriptor
        roiPhiMin = roi.phiMinus();
        roiPhiMax = roi.phiPlus();
      }
 
    }
 
  }
 
 
  double dphi = roiPhiMax-roiPhiMin;
 
  if ( dphi<0 ) dphi+=2*M_PI;
 
  numPhiSlices = long (ceil( dphi*m_invPhiSliceSize ));
 
 
  bool piBound=(roiPhiMin>roiPhiMax);
 
  int icount = 0;
 
  if(!piBound)
  {
    for(long i=0; i<nSPs; ++i, ++SpItr) 
    {
      if ( SpItr->layer()>m_maxLayer || (m_pixOnly && !SpItr->isPixel()) ) continue;
      double phi2 = SpItr->phi() - roiPhiMin;
 
      if ( phi2>=0 && phi2<dphi ) { // ensures space point is in ROI
        phi[icount] = phi2;
        rho[icount] = SpItr->r();
        zed[icount] = SpItr->z();
        lyr[icount] = m_new2old[SpItr->layer()];
        lcount[lyr[icount]]=true;
        ++icount;
      }
    }
  }
  else
  {
    for(long i=0; i<nSPs; ++i, ++SpItr) 
    {
      if ( SpItr->layer()>m_maxLayer || (m_pixOnly && !SpItr->isPixel()) ) continue;
      double phi2 = SpItr->phi() - roiPhiMin;
      if( phi2<0.0) phi2+=2*M_PI;
      if ( phi2>=0 && phi2<dphi ) { // ensures space point is in ROI
        phi[icount] = phi2;
        rho[icount] = SpItr->r();
        zed[icount] = SpItr->z();
        lyr[icount] = m_new2old[SpItr->layer()];
        lcount[lyr[icount]]=true;
        ++icount;
      }
    }
  }
 
  if ( icount<nSPs ) { 
 
    //    std::cout << "TrigZFinderInternal::fillVectors() filtered some spacepoints " << nSPs 
    //        << " -> " << icount << std::endl; 
    phi.resize(icount);
    rho.resize(icount);
    zed.resize(icount);
    lyr.resize(icount);
  }
 
 
  //   Store in filledLayers the layerNumber of those layers that contain hits.
  //   So, if there are hits in layers 1,3,8 filledLayers[0]=1, filledLayers[1]=3
  //   and filledLayers[2]=8 
  //
  long filled = 0;
 
  for ( long i=0; i<m_IdScan_MaxNumLayers; ++i ) {
    if ( lcount[i] ) {
      filledLayers[filled] = i;
      ++filled;
    }
  }
 
  //  std::cout << "SUTT NSP : " << phi.size() << " " << spVec.size() << std::endl;
  //  for ( unsigned i=0 ; i<phi.size() ; i++ ) { 
  //    std::cout << "SUTT SP : " << i << "\tphi " << phi[i] << "\tz " << zed[i] << "\tr " << rho[i] << std::endl; 
  //  }
 
  return filled;
}

findZ()

TrigVertexCollection * TrigZFinder::findZ ( const std::vector< TrigSiSpacePointBase > & spVec, const IRoiDescriptor & roi ) const

overridevirtual

Implements ITrigZFinder.

Definition at line 161 of file TrigZFinder.cxx.

{
 
  TrigVertexCollection* output = new TrigVertexCollection;
 
  std::vector<vertex>* vertices = findZInternal( spVec, roi );
 
  ATH_MSG_DEBUG( "findZ() roi: " << roi );
 
  for ( unsigned int i=0 ; i<vertices->size() ; i++ ) { 
    auto vtx = new TrigVertex((*vertices)[i]._z, (*vertices)[i]._weight, TrigVertex::NULLID);
    output->push_back(vtx);
  }
 
  delete vertices;
 
  return output;
}

findZInternal()

std::vector< typename TrigZFinderInternal::vertex > * TrigZFinderInternal::findZInternal ( const std::vector< TrigSiSpacePointBase > & spVec, const IRoiDescriptor & roi ) const

inherited

First calculate the pedestal to be subtracted (only used in the HI case at the moment)

skip bins used for the vertex candidates

calculate the vertex significance: First sort the n entries in each bin in to order, then calculate the mean bg excluding the largest (1-m_percentile), then the significance for each peak will be sig = (ypeak - bg)/sqrt(bg) and we can keep only those where sig > m_minVtxSignificance

if ( ztest >= maxh && ( ( m_applyWeightThreshold && ztest>m_weightThreshold ) || !m_applyWeightThreshold ) ) { apply threshold later - should we wish it

if we are in triplet mode, even a single pair means 3 consistent hits also bomb out if no maximum (above threshold) is found

if found a vertex flag the bins so we don't use them again

here we reject those vertex candidates where significance < m_minVtxSignificance

at this point we have the histogram with the highest N vertices removed so we can find the "non vertex" pedestal from these, although it will be somewhat lower than perhaps it should be, in case some of the "vertices" we are removing are just random upwards fluctuations

NB: have moved pedestal calculation to before the extraction of the vertices if we calculate it after, then we have too low a pedestal if some vertices are really random fluctuations. If we calculate it before then we overestimate the pedestal, really we should try to decide how many real vertices we have, and then only exclude them, but that level of detail is probably not justified by the correlation with the offline track multiplicity on the vertex

copy vertices to output vector - this is so we can first impose cuts on the vertices we have found should we wish to

NB: if m_weightThreshold==0 then pedestal == 0 also
This is ridiculous, passing parameters about differently because we don't have a proper interface defined

Definition at line 378 of file TrigZFinderInternal.cxx.

                                                     {
 
  std::vector<vertex>* output = new std::vector<vertex>();
 
  long nsp = spVec.size();
  if ( !nsp ) return output; //No points - return nothing
 
  //   Creating vectors of doubles/longs for storing phi,rho,z and layer of space points.
  //   filledLayers is used to know which of all layers contain space points
  //   and fill with relevant info...
  //
  std::vector<double> phi(nsp), rho(nsp), zed(nsp);
  std::vector<long>   lyr(nsp), filledLayers(m_IdScan_MaxNumLayers);
 
  long numPhiSlices = 0;
 
  long filled = this->fillVectors( spVec, roi, phi, rho, zed, lyr, filledLayers, numPhiSlices );
 
  nsp = phi.size();
 
  //  std::cout << "SUTT roi " << roi << "nsp: " << nsp << std::endl;
 
 
  double zMin = roi.zedMinus(); 
  double zMax = roi.zedPlus(); 
 
 
  //   The bin size of the z-histo -and hence the number of bins- 
  //   depends on the RoI's |eta| (to account for worsening z-resolution)
  //
  const double ZBinSize = m_minZBinSize + m_zBinSizeEtaCoeff*fabs(roi.eta());
  const double invZBinSize = 1./ZBinSize;
 
 
  const long HalfZhistoBins = long ( ceil( 0.5*(zMax-zMin)*invZBinSize ) );
  const long NumZhistoBins = 2*HalfZhistoBins;
 
  // number of phi bins to look at will get fewer as eta increases
  const long extraPhiNeg = static_cast<long> ( floor( (0.9 - fabs(roi.eta()))*m_dphideta*m_invPhiSliceSize*m_neighborMultiplier ) );
 
 
 
  //   These are the z-Histograms
  //   Two sets are defined: {n/z}Histo[0][phi][z] will be for positively bending tracks
  //                         {n/z}Histo[1][phi][z] will be for negatively bending tracks
  //
 
  long numZhistos = m_zHistoPerPhi ? numPhiSlices : 1 ;
 
  //  std::vector < std::vector < std::vector<long>   > >  nHisto( 2, std::vector < std::vector<long>   > (numZhistos, std::vector<long>  () ) );
  //  std::vector < std::vector < std::vector<double> > >  zHisto( 2, std::vector < std::vector<double> > (numZhistos, std::vector<double>() ) );
 
  std::vector < std::vector<long>   >  nHisto[2]; // the actual z histogram count of pairs
  std::vector < std::vector<double> >  zHisto[2]; // summed z position histograms
 
  for ( int i=2 ; i-- ;  ) { nHisto[i].clear();   nHisto[i].resize(numZhistos); } 
  for ( int i=2 ; i-- ;  ) { zHisto[i].clear();   zHisto[i].resize(numZhistos); } 
 
  //  std::vector< std::vector<long> >*   nHisto = m_nHisto;
  //  std::vector< std::vector<double> >* zHisto = m_zHisto;
 
  //  nMax = 0;
 
  //Make a vector of all the PhiSlice instances we need
  std::vector< PhiSlice* > allSlices( numPhiSlices );
  for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ )
  {
    allSlices[ sliceIndex ] = new PhiSlice( sliceIndex, ZBinSize, m_invPhiSliceSize,
                        m_tripletDZ, m_halfTripletDK, m_tripletDP, zMin, zMax,
                        m_IdScan_MaxNumLayers, m_IdScan_LastBrlLayer );
  }
 
  int allSlicesSize = allSlices.size();
 
  //Populate the slices
  for ( long pointIndex = 0; pointIndex < nsp; pointIndex++ )
  {
    int phiIndex = floor( phi[ pointIndex ] * m_invPhiSliceSize );
    if (phiIndex > allSlicesSize) {
      continue;
    }
    allSlices[ phiIndex ]->AddPoint( rho[ pointIndex ], zed[ pointIndex ], phi[ pointIndex ], lyr[ pointIndex ] );
  }
 
  //Read out the slices into flat structures for the whole layers
  std::vector< std::vector< double > > allLayerRhos, allLayerZs, allLayerPhis;
  allLayerRhos.resize( m_IdScan_MaxNumLayers );
  allLayerZs.resize( m_IdScan_MaxNumLayers );
  allLayerPhis.resize( m_IdScan_MaxNumLayers );
 
  std::vector< std::vector< int > > allSliceWidths( m_IdScan_MaxNumLayers, std::vector< int >( numPhiSlices + 1, 0 ) );
  for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ )
  {
    allSlices[ sliceIndex ]->MakeWideLayers( &allLayerRhos, &allLayerZs, &allLayerPhis, &allSliceWidths, filled, &filledLayers );
  }
 
  //One histogram per phi slice?
  if ( m_zHistoPerPhi )
  {
    //Allocate all the histograms
    for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ )
    {
      nHisto[0][sliceIndex].resize( NumZhistoBins + 1 );
      zHisto[0][sliceIndex].resize( NumZhistoBins + 1 );
    }
    if ( m_chargeAware ) {
      for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ ) {
      nHisto[1][sliceIndex].resize( NumZhistoBins + 1 );
      zHisto[1][sliceIndex].resize( NumZhistoBins + 1 );
      }
    }
    
    //Populate the histograms
    for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ )  {
      allSlices[ sliceIndex ]->GetHistogram( &( nHisto[0][sliceIndex] ), &( zHisto[0][sliceIndex] ),
                         &( nHisto[1][sliceIndex] ), &( zHisto[1][sliceIndex] ),
                         m_extraPhi, extraPhiNeg, m_nFirstLayers, m_tripletMode, m_chargeAware, nHisto, zHisto );
      
      //Note the extra arguments here - pointers to the whole histogram collection
      //This allows the filling of neighbouring slice histograms as required, but breaks thread safety
      
      delete allSlices[ sliceIndex ];
    }
  }
  else {
    //Allocate the z-axis histograms
    nHisto[0][0].resize( NumZhistoBins + 1 );
    zHisto[0][0].resize( NumZhistoBins + 1 );
    if ( m_chargeAware )  {
      nHisto[1][0].resize( NumZhistoBins + 1 );
      zHisto[1][0].resize( NumZhistoBins + 1 );
    }
    
    //Populate the histogram - fast and memory-efficient, but not thread safe (use MakeHistogram for thread safety)
    for ( unsigned int sliceIndex = 0; sliceIndex < numPhiSlices; sliceIndex++ ) {
      allSlices[ sliceIndex ]->GetHistogram( &( nHisto[0][0] ), &( zHisto[0][0] ),
          &( nHisto[1][0] ), &( zHisto[1][0] ),
          m_extraPhi, extraPhiNeg, m_nFirstLayers, m_tripletMode, m_chargeAware );
 
      delete allSlices[ sliceIndex ];
    }
  }
  
 

 
  double pedestal = 0;
 
  if ( m_weightThreshold>0 ) { 
 
    int count = 0; 
 
    for ( long zpm=0; zpm<1 || ( m_chargeAware && zpm<2 ) ; ++zpm ) {
 
      for(std::vector< std::vector<long> >::iterator nfiter = nHisto[zpm].begin(); nfiter!=nHisto[zpm].end(); ++nfiter) {
 
        if((*nfiter).empty()) continue; // only check the filled zHistos
        if((*nfiter).size() <= 2 ) continue;// this is only a protection : with proper inputs to zfinder, it is always satisfied
 
        for(std::vector<long>::iterator niter=nfiter->begin()+2; niter!=nfiter->end(); ++niter ) {
          if ( *niter>=0 ) { 
            count++;
            pedestal += *(niter) + *(niter-1) + *(niter-2);
          }
        }
      }
    }
 
    if ( count>0 ) pedestal /= count;
    
  }
 

 
  double bg = 0; 
      
  if ( m_minVtxSignificance > 0 ) { 
 
    if ( !m_chargeAware ) {  
 
      std::vector<long>& n = nHisto[0][0];
      
      std::vector<long>  n3( nHisto[0][0].size()-2, 0);
      
      for( unsigned i=n.size()-2 ; i-- ;  ) n3[i] = ( n[i+2] + n[i+1] + n[i] );
      std::sort( n3.begin(), n3.end() );
      
      unsigned nmax = unsigned(n3.size()*m_percentile);
 
      for( unsigned i=nmax ; i-- ;  ) bg += n3[i];
      
      if ( nmax>0 ) bg /= nmax;
      
    }
  }
 
 
 
  //   Now the nHisto's are filled; find the 3 consecutive bins with the highest number of entries...
  //
 
  std::vector<double>  zoutput;
  std::vector<double>  woutput;
 
 
 
  while((int)zoutput.size() < m_numberOfPeaks) {
 
    long maxh=0;  // was 1 before triplets were introduced
    long binMax=0;
    long bending=0, bestPhi=0;
    long ztest;
 
    for ( long zpm=0; zpm<1 || ( m_chargeAware && zpm<2 ) ; ++zpm ) {
 
      std::vector< std::vector<long> >::iterator nfiter = nHisto[zpm].begin(); 
      for( ; nfiter!=nHisto[zpm].end() ; ++nfiter) {
 
        if((*nfiter).empty()) continue; // only check the filled zHistos
        if((*nfiter).size() <= 2 ) continue;// this is only a protection : with proper inputs to zfinder, it is always satisfied
    
        for(std::vector<long>::iterator niter=(*nfiter).begin()+2; niter!=(*nfiter).end(); ++niter ) {
      
          ztest = *(niter-2) + *(niter-1) + *(niter);
          if ( ztest <= 0 || ztest < maxh ) continue;
          if ( ztest >= maxh ) { // && ztest>m_weightThreshold ) {
            long bintest = niter-(*nfiter).begin()-1;
            if ( ztest > maxh ||
         // for two candidates at same "height", prefer the more central one
         (m_preferCentralZ && std::abs( bintest - HalfZhistoBins ) < std::abs( binMax - HalfZhistoBins ) ) ) {
              maxh = ztest;
              binMax = bintest;
              bestPhi = nfiter-nHisto[zpm].begin();
              bending = zpm;
            }
          }
    }// end of niter loop
      }
    }
 
    // nMax = maxh;
    if ( maxh==0 || ( m_tripletMode==0 && maxh<2 ) ) {
      break;
    }
    
    //   ...and compute the "entries-weighted" average bin position
    
    double weightedMax = ( zHisto[bending][bestPhi][binMax] +
               zHisto[bending][bestPhi][binMax+1] +
               zHisto[bending][bestPhi][binMax-1] ) /maxh;
    
    if ( m_numberOfPeaks>0 ) { 
      nHisto[bending][bestPhi][binMax]   = -1;
      nHisto[bending][bestPhi][binMax-1] = -1;
      nHisto[bending][bestPhi][binMax+1] = -1;
      zHisto[bending][bestPhi][binMax]   = 0;
      zHisto[bending][bestPhi][binMax-1] = 0;
      zHisto[bending][bestPhi][binMax+1] = 0;
    }
    
    int closestVtx = -1; // find the closest vertex already put into the output list
    float dist2closestVtx = 1000; // should be larger than m_ZFinder_MaxZ*2
    for ( size_t iv = 0; iv < zoutput.size(); ++iv ) {
      if ( fabs(weightedMax-zoutput[iv]) < dist2closestVtx ) {
    closestVtx = iv;
    dist2closestVtx = fabs(weightedMax-zoutput[iv]); 
      }
    }
    
    if ( dist2closestVtx < m_nvrtxSeparation*ZBinSize || dist2closestVtx < fabs(weightedMax)*m_vrtxDistCut ) {
      zoutput[closestVtx] = m_vrtxMixing * weightedMax + (1.0 - m_vrtxMixing) * zoutput[closestVtx] ;
      woutput[closestVtx] = m_vrtxMixing * maxh        + (1.0 - m_vrtxMixing) * woutput[closestVtx] ;
    }  
    else  {
      
      bool addvtx = true;
      double significance = 0;
      if ( bg>0 ) { 
    significance = (maxh-bg)/std::sqrt(bg);
    if ( significance < m_minVtxSignificance ) break; // if this vertex is not significant then no subsequent vertex could be either  
      }
      
      if ( addvtx ) { 
    zoutput.push_back( weightedMax );
    woutput.push_back( maxh );
      }
    }
    
  }
  
  
  
  
  
  
  if ( m_weightThreshold>0 ) { 
    for ( unsigned i=0 ; i<zoutput.size() ; i++ ) { 
      output->push_back( vertex( woutput[i] - pedestal, zoutput[i] ) ); 
    }
  }
  else {
    for ( unsigned i=0 ; i<zoutput.size() ; i++ ) { 
      output->push_back( vertex( zoutput[i], woutput[i] - pedestal ) ); 
    }
  }
  
  //  std::cout << "SUTT zoutput size " << zoutput.size() << "\t" << roi << std::endl;
  //  for ( unsigned i=0 ; i<zoutput.size() ; i++ ) std::cout << "SUTT zoutput        " << i << "\t" << zoutput[i] << std::endl;
  
  return output;
 
}

getName()

const std::string & TrigZFinderInternal::getName ( ) const

inlineprotectedinherited

Definition at line 62 of file TrigZFinderInternal.h.

{ return m_name; }

getType()

const std::string & TrigZFinderInternal::getType ( ) const

inlineprotectedinherited

Definition at line 61 of file TrigZFinderInternal.h.

{ return m_type; }

initialize()

StatusCode TrigZFinder::initialize ( )

overridevirtual

NB: These only have to go here, because they need to write to the msgsvc, and because is rubbish, we can't pass in a pointer to a (non-athena) sub algorithm.

get first endcap layer, so we know how many barrel layers there are

pass in the total number of layers, and the last barrel layer NB: decrement the endcap pixels, as we want the layer number of the last barrel layer, not the number of the first endcap pixel layer

Definition at line 69 of file TrigZFinder.cxx.

{
  //   NB: This should go into the InitializeInternal !!!!!!!!!
  //       NO internal settings should be changed in here, this should just 
  //       be an athena wrapper !!!
 
  //   phiBinSize is expected in degrees (~0.2); make sure it is > ZFinder_MinPhiSliceSize
  //

  if ( m_phiBinSize < ZFinder_MinPhiSliceSize and ! m_forcePhiBinSize ){
    ATH_MSG_WARNING("Requested PhiBinSize of "  << m_phiBinSize
                    << " degrees is smaller than the minimum allowed (" << ZFinder_MinPhiSliceSize
                    << " degrees). Set to the minimum value.");
    //  m_phiBinSize = ZFinder_MinPhiSliceSize;
  }
 
  // NB: This should go into the InitializeInternal !!!!
  if ( m_dphideta > 0 ){
    ATH_MSG_WARNING("Requested DPhiDEta of "  << m_dphideta
                    << " is positive.  Setting to its negative!");
    // m_dphideta *= -1.;
  }
 
  ATH_CHECK(m_numberingTool.retrieve());

  int offsetEndcapPixels = m_numberingTool->offsetEndcapPixels();
  int maxSiliconLayerNum = m_numberingTool->maxSiliconLayerNum(); 
  //  int offsetBarrelSCT    = m_numberingTool->offsetBarrelSCT(); 
 
 
  // std::cout << "ZFinder::initialise() offset pixels " << offsetEndcapPixels 
  //        << "\toffsetBarrelSCT " << offsetBarrelSCT 
  //        << "\tmaxlayers " << maxSiliconLayerNum << std::endl;

 
  initializeInternal(maxSiliconLayerNum,offsetEndcapPixels-1);
 
  ATH_MSG_INFO("TrigZFinder constructed:     name()  "    << name()            );
  ATH_MSG_INFO("TrigZFinder::PixOnly        set to   "    << m_pixOnly         );
  ATH_MSG_INFO("TrigZFinder::FullScanMode            "    << m_fullScanMode    );
  ATH_MSG_INFO("TrigZFinder::PhiBinSize     set to   "    << m_phiBinSize      );
  ATH_MSG_INFO("TrigZFinder::# of peaks to consider: "    << m_numberOfPeaks   );
  ATH_MSG_INFO("TrigZFinder::z bin size              "    << m_minZBinSize     );
  ATH_MSG_INFO("TrigZFinder::eta coeff               "    << m_zBinSizeEtaCoeff);
  
  ATH_MSG_INFO("TrigZFinder::m_nFirstLayers     = " << m_nFirstLayers    );
  ATH_MSG_INFO("TrigZFinder::m_invPhiSliceSize  = " << m_invPhiSliceSize );
  ATH_MSG_INFO("TrigZFinder::m_phiBinSize       = " << m_phiBinSize      );
  ATH_MSG_INFO("TrigZFinder::m_dphideta         = " << m_dphideta        );
  ATH_MSG_INFO("TrigZFinder::m_neighborMultiplier = " << m_neighborMultiplier);
  ATH_MSG_INFO("TrigZFinder::m_minZBinSize      = " << m_minZBinSize     );
  ATH_MSG_INFO("TrigZFinder::m_zBinSizeEtaCoeff = " << m_zBinSizeEtaCoeff);
  ATH_MSG_INFO("TrigZFinder::m_chargeAware      = " << m_chargeAware     );
  ATH_MSG_INFO("TrigZFinder::m_zHistoPerPhi     = " << m_zHistoPerPhi    );
 
  ATH_MSG_INFO("TrigZFinder::m_nvrtxSeparation  = " << m_nvrtxSeparation );
  ATH_MSG_INFO("TrigZFinder::m_vrtxDistCut      = " << m_vrtxDistCut     );
  ATH_MSG_INFO("TrigZFinder::m_vrtxMixing       = " << m_vrtxMixing      );
  ATH_MSG_INFO("TrigZFinder::m_preferCentralZ   = " << m_preferCentralZ  );
 
  ATH_MSG_INFO("TrigZFinder::m_trustSPprovider  = " << m_trustSPprovider );
 
  ATH_MSG_INFO("TrigZFinder::m_tripletMode      = " << m_tripletMode     );
 
  ATH_MSG_INFO("TrigZFinder::m_maxLayer         = " << m_maxLayer       );
 
  ATH_MSG_INFO("TrigZFinder::m_minVtxSignificance = " << m_minVtxSignificance );
 
  if ( m_minVtxSignificance>0 ) { 
    ATH_MSG_INFO("TrigZFinder::m_percentile     = " << m_percentile );
  }
 
  ATH_MSG_INFO("TrigZFinder::m_weigthThreshold  = " << m_weightThreshold );
 
  ATH_MSG_INFO("TrigZFinder::m_tripletDZ  = " << m_tripletDZ );
  ATH_MSG_INFO("TrigZFinder::m_tripletDK  = " << m_tripletDK );
  ATH_MSG_INFO("TrigZFinder::m_tripletDP  = " << m_tripletDP );
 
  return StatusCode::SUCCESS;
}

initializeInternal()

void TrigZFinderInternal::initializeInternal ( long maxLayers, long lastBarrel )

inherited

the number of phi slices (numPhiSlices) has to be computed event by event !!!

barrel

standard Endcap

increment all the layer ids by one because of the IBL IF and ONLY IF the IBL is included

Definition at line 58 of file TrigZFinderInternal.cxx.

{
  m_halfTripletDK = 0.5*m_tripletDK;
 
  m_IdScan_MaxNumLayers = maxLayers; 
  m_IdScan_LastBrlLayer = lastBarrel; 
 
  //initialize new/old layer number transform table
 
  if(maxLayers > 20) {
    int offsetEndcapPixels = lastBarrel + 1;
    int M = (maxLayers-offsetEndcapPixels)/2;
    for(int l=0;l<maxLayers;l++) {
      int oldL = l;
      if(l>lastBarrel) {
    oldL = l-offsetEndcapPixels;
    oldL = oldL < M ? oldL : oldL - M;
    oldL += offsetEndcapPixels;
      }
      m_new2old.push_back(oldL);
    }
    m_IdScan_MaxNumLayers = lastBarrel + M + 1;
  } else {
    for(int l=0;l<maxLayers;l++) m_new2old.push_back(l);
  }
 
 
  // std::cout << "m_IdScan_MaxNumLayers "    <<  m_IdScan_MaxNumLayers
  //        << "\tm_IdScan_LastBrlLayer "  <<  m_IdScan_LastBrlLayer << std::endl;
 
  // number of phi neighbours to look at
  //  if ( extraPhi.size()==0 ) 
 
  m_extraPhi = std::vector< std::vector<long> >( m_IdScan_MaxNumLayers, std::vector<long>(m_IdScan_MaxNumLayers) ); 
 
  // from TrigZFinder::initialize
  m_usedphiBinSize = m_phiBinSize;
  if ( m_usedphiBinSize < ZFinder_MinPhiSliceSize and ! m_forcePhiBinSize) m_usedphiBinSize = ZFinder_MinPhiSliceSize;
  if ( m_dphideta > 0 )                             m_dphideta *= -m_dphideta;
 
  m_invPhiSliceSize = 180./(M_PI*m_usedphiBinSize);
 
  for (long l1=0; l1<m_IdScan_MaxNumLayers-1; ++l1) {
    for (long l2=l1+1; l2<m_IdScan_MaxNumLayers; ++l2) {
      m_extraPhi[l1][l2]=1; // look at a single phi neighbour
    }
  }

 
  long first_layer  = 0;
  long offset_layer = 1;
  if ( m_IdScan_MaxNumLayers<20 ) { 
    first_layer  = 1; 
    offset_layer = 0; 
  }
 
  long lyrcnt = 0;
  for (long l1=0; l1<m_IdScan_LastBrlLayer; ++l1) {
    for (long l2=l1+1; l2<=m_IdScan_LastBrlLayer; ++l2) {
      double dphi = ZF_dphiBrl[lyrcnt + 7*first_layer];
      dphi *= m_neighborMultiplier;
      m_extraPhi[l1][l2]=static_cast<long>( ceil(  sqrt(dphi*dphi+ZF_phiRes*ZF_phiRes*2) * m_invPhiSliceSize ) );
 
      //      std::cout << "test 1 " << l1 << " " << l2 << "\tmax : " <<  m_IdScan_MaxNumLayers << std::endl;
 
      if (m_extraPhi[l1][l2]<1) m_extraPhi[l1][l2]=1;
      //      std::cout << "Delta Phi between layers " << l1 << " and " << l2
      //        << " = "<< ZF_dphiBrl[lyrcnt] 
      //        << " rads ( " << m_extraPhi[l1][l2] << " bins including phi resln.)\n";
      lyrcnt++;
    }
  }
 

 
 
 
  for ( long lyrpair=12*first_layer ;  lyrpair<117; ++lyrpair ) {
 
    double dphi = ZF_dphiEC[lyrpair*4+2];
    long     l1 = (long)ZF_dphiEC[lyrpair*4] + offset_layer; 
    long     l2 = (long)ZF_dphiEC[lyrpair*4+1] + offset_layer; 
    double  eta = ZF_dphiEC[lyrpair*4+3];
    //   std::cout << "Delta Phi between layers " << l1 << " and " << l2 
    //        << " = " << dphi << " rads @ eta=" << eta
    //        << ". Extrapolate it to eta=0.9 to get ";
    dphi = dphi + m_dphideta * ( 0.9 - eta );
    dphi *= m_neighborMultiplier;
    m_extraPhi[l1][l2]=static_cast<long>(ceil(sqrt(dphi*dphi+ZF_phiRes*ZF_phiRes*2)*m_invPhiSliceSize));
 
    if (m_extraPhi[l1][l2]<1) m_extraPhi[l1][l2]=1;
 
    //    std::cout << "test 2 " << l1 << " " << l2 << "\tmax : " <<  m_IdScan_MaxNumLayers << std::endl;
 
    // std::cout << dphi << " rads ( " << m_extraPhi[l1][l2] << " bins including phi resln.)\n";
  }
 
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & ITrigZFinder::interfaceID ( )

inlinestaticinherited

Definition at line 21 of file ITrigZFinder.h.

                                          {
    return IID_ITrigZFinder;
  }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setLayers()

void TrigZFinderInternal::setLayers ( long maxLayers, long lastBarrelLayer )

inlineinherited

Definition at line 54 of file TrigZFinderInternal.h.

                                                         {
      m_IdScan_MaxNumLayers = maxLayers;        // dphiEC depends on this value
      m_IdScan_LastBrlLayer = lastBarrelLayer;  // dphiBrl depends on this value
    } 

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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_chargeAware

bool TrigZFinderInternal::m_chargeAware

protectedinherited

Definition at line 108 of file TrigZFinderInternal.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dphideta

double TrigZFinderInternal::m_dphideta

protectedinherited

Definition at line 111 of file TrigZFinderInternal.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extraPhi

std::vector< std::vector<long> > TrigZFinderInternal::m_extraPhi

protectedinherited

Definition at line 114 of file TrigZFinderInternal.h.

m_forcePhiBinSize

bool TrigZFinderInternal::m_forcePhiBinSize = false

protectedinherited

Definition at line 94 of file TrigZFinderInternal.h.

m_fullScanMode

bool TrigZFinderInternal::m_fullScanMode

protectedinherited

Definition at line 128 of file TrigZFinderInternal.h.

m_halfTripletDK

double TrigZFinderInternal::m_halfTripletDK

protectedinherited

Definition at line 133 of file TrigZFinderInternal.h.

m_IdScan_LastBrlLayer

long TrigZFinderInternal::m_IdScan_LastBrlLayer

protectedinherited

Definition at line 85 of file TrigZFinderInternal.h.

m_IdScan_MaxNumLayers

long TrigZFinderInternal::m_IdScan_MaxNumLayers

protectedinherited

maximum number of layers and last barrel layer

Definition at line 84 of file TrigZFinderInternal.h.

m_invPhiSliceSize

double TrigZFinderInternal::m_invPhiSliceSize = 0.0

protectedinherited

Definition at line 90 of file TrigZFinderInternal.h.

m_maxLayer

int TrigZFinderInternal::m_maxLayer

protectedinherited

Definition at line 136 of file TrigZFinderInternal.h.

m_minVtxSignificance

double TrigZFinderInternal::m_minVtxSignificance

protectedinherited

Definition at line 138 of file TrigZFinderInternal.h.

m_minZBinSize

double TrigZFinderInternal::m_minZBinSize

protectedinherited

Definition at line 97 of file TrigZFinderInternal.h.

m_name

std::string TrigZFinderInternal::m_name

protectedinherited

Definition at line 105 of file TrigZFinderInternal.h.

m_neighborMultiplier

double TrigZFinderInternal::m_neighborMultiplier

protectedinherited

Definition at line 112 of file TrigZFinderInternal.h.

m_new2old

std::vector<int> TrigZFinderInternal::m_new2old

protectedinherited

Definition at line 146 of file TrigZFinderInternal.h.

m_nFirstLayers

int TrigZFinderInternal::m_nFirstLayers

protectedinherited

Definition at line 117 of file TrigZFinderInternal.h.

m_numberingTool

ToolHandle<ITrigL2LayerNumberTool> TrigZFinder::m_numberingTool

no private data members - all inherited from the TrigZFinderInternal class NB: BE CAREFUL !

!! Nothing set with a job option should EVER be changed inside the ZFinderInternal code actually, need the TrigL2LayerNumberTool so we can configure with the correct number of layers when including the IBL etc

Definition at line 58 of file TrigZFinder.h.

m_numberOfPeaks

long TrigZFinderInternal::m_numberOfPeaks

protectedinherited

Definition at line 100 of file TrigZFinderInternal.h.

m_NumPhiSlices

long TrigZFinderInternal::m_NumPhiSlices = 0L

protectedinherited

Definition at line 91 of file TrigZFinderInternal.h.

m_nvrtxSeparation

int TrigZFinderInternal::m_nvrtxSeparation

protectedinherited

Definition at line 121 of file TrigZFinderInternal.h.

m_percentile

double TrigZFinderInternal::m_percentile

protectedinherited

Definition at line 139 of file TrigZFinderInternal.h.

m_phiBinSize

double TrigZFinderInternal::m_phiBinSize

protectedinherited

Definition at line 93 of file TrigZFinderInternal.h.

m_pixOnly

bool TrigZFinderInternal::m_pixOnly

protectedinherited

Definition at line 102 of file TrigZFinderInternal.h.

m_preferCentralZ

bool TrigZFinderInternal::m_preferCentralZ

protectedinherited

Definition at line 122 of file TrigZFinderInternal.h.

m_returnval

double TrigZFinderInternal::m_returnval = 0.0

protectedinherited

Definition at line 126 of file TrigZFinderInternal.h.

m_ROIphiWidth

double TrigZFinderInternal::m_ROIphiWidth

protectedinherited

Definition at line 96 of file TrigZFinderInternal.h.

m_tripletDK

double TrigZFinderInternal::m_tripletDK

protectedinherited

Definition at line 132 of file TrigZFinderInternal.h.

m_tripletDP

double TrigZFinderInternal::m_tripletDP

protectedinherited

Definition at line 134 of file TrigZFinderInternal.h.

m_tripletDZ

double TrigZFinderInternal::m_tripletDZ

protectedinherited

Definition at line 131 of file TrigZFinderInternal.h.

m_tripletMode

int TrigZFinderInternal::m_tripletMode

protectedinherited

Definition at line 130 of file TrigZFinderInternal.h.

m_trustSPprovider

bool TrigZFinderInternal::m_trustSPprovider

protectedinherited

Definition at line 124 of file TrigZFinderInternal.h.

m_type

std::string TrigZFinderInternal::m_type

protectedinherited

Definition at line 104 of file TrigZFinderInternal.h.

m_usedphiBinSize

double TrigZFinderInternal::m_usedphiBinSize

protectedinherited

Definition at line 95 of file TrigZFinderInternal.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vrtxDistCut

double TrigZFinderInternal::m_vrtxDistCut

protectedinherited

Definition at line 119 of file TrigZFinderInternal.h.

m_vrtxMixing

double TrigZFinderInternal::m_vrtxMixing

protectedinherited

Definition at line 120 of file TrigZFinderInternal.h.

m_weightThreshold

double TrigZFinderInternal::m_weightThreshold

protectedinherited

to apply a threshold to the found vertex candidates

Definition at line 144 of file TrigZFinderInternal.h.

m_zBinSizeEtaCoeff

double TrigZFinderInternal::m_zBinSizeEtaCoeff

protectedinherited

Definition at line 98 of file TrigZFinderInternal.h.

m_zHistoPerPhi

bool TrigZFinderInternal::m_zHistoPerPhi

protectedinherited

Definition at line 109 of file TrigZFinderInternal.h.

---

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

• TrigZFinder.h
• TrigZFinder.cxx