#include <IDScanZFinderInternal.h>

Collaboration diagram for Run1::IDScanZFinderInternal< SpacePoint >:

Classes
struct	vertex

Public Member Functions
	IDScanZFinderInternal (const std::string &, const std::string &)

virtual	~IDScanZFinderInternal ()

void	initializeInternal (long maxLayers, long lastBarrel)

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

const std::vector< std::vector< long > > *	GetnHisto ()

const std::vector< std::vector< double > > *	GetzHisto ()

long	GetNMax ()

void	setLayers (long maxLayers, long lastBarrelLayer)

Protected Member Functions
long	fillVectors (const std::vector< const SpacePoint * > &spVec, const IRoiDescriptor &roi, std::vector< double > &phi, std::vector< double > &rho, std::vector< double > &zed, std::vector< long > &lyr, std::vector< long > &filledLayers)

const std::string &	getType () const

const std::string &	getName () const

const std::string &	getVersion () const

int	GetInternalStatus () const

int	SetInternalStatus (int s)

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	SetReturnValue (double d)

double	GetReturnValue () const

Protected Attributes
long	m_IdScan_MaxNumLayers
	maximum number of layers and last barrel layer More...

long	m_IdScan_LastBrlLayer

double	m_invPhiSliceSize

long	m_NumPhiSlices

double	m_phiBinSize

bool	m_forcePhiBinSize

double	m_usedphiBinSize

double	m_ROIphiWidth

double	m_usedROIphiWidth

double	m_minZBinSize

double	m_zBinSizeEtaCoeff

long	m_numberOfPeaks

bool	m_pixOnly

std::string	m_Type

std::string	m_Name

int	m_Status

bool	m_chargeAware

bool	m_zHistoPerPhi

double	m_dphideta

double	m_neighborMultiplier

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

std::vector< std::vector< long > >	m_nHisto [2]

std::vector< std::vector< double > >	m_zHisto [2]

long	m_NMax

int	m_nFirstLayers

double	m_vrtxDistCut

double	m_vrtxMixing

int	m_nvrtxSeparation

bool	m_preferCentralZ

bool	m_trustSPprovider

double	m_returnval

bool	m_fullScanMode

int	m_tripletMode

double	m_tripletDZ

double	m_tripletDK

double	m_halfTripletDK

double	m_tripletDP

double	m_weightThreshold
	to apply a hreshold to the found vertex candidates More...

Detailed Description

template<class SpacePoint>
class Run1::IDScanZFinderInternal< SpacePoint >

Definition at line 39 of file IDScanZFinderInternal.h.

Constructor & Destructor Documentation

◆ IDScanZFinderInternal()

template<class SpacePoint >

Run1::IDScanZFinderInternal< SpacePoint >::IDScanZFinderInternal	(	const std::string &	type,
		const std::string &	name
	)

to allow variable size layers

why is this called from the constructor ???? it is called again during initialise? do not call that here initializeInternal( m_IdScan_MaxNumLayers, m_IdScan_LastBrlLayer );

Definition at line 172 of file IDScanZFinderInternal.h.

   : m_Type (type),
     m_Name (name)
 {
   m_phiBinSize       = 0.2   ;
   m_forcePhiBinSize  = false ;
   m_usedphiBinSize   = m_phiBinSize   ;
   m_pixOnly          = false ;
   m_ROIphiWidth      = 0.2   ;
   m_usedROIphiWidth  = m_ROIphiWidth ;
   m_minZBinSize      = 0.2   ;
   m_zBinSizeEtaCoeff = 0.1   ;
   m_dphideta         = -0.02 ;
   m_neighborMultiplier = 1.  ;
   m_numberOfPeaks    = 1     ;
   m_chargeAware      = true  ;
   m_zHistoPerPhi     = true  ;
   m_NMax             = 0     ;
   m_nFirstLayers     = 3     ;
   m_vrtxDistCut      = 0.    ;
   m_vrtxMixing       = 0.    ;
   m_nvrtxSeparation  = 0     ;
   m_preferCentralZ   = false ;
   m_trustSPprovider  = true  ;
   m_returnval        = 0     ;
   m_fullScanMode     = false ;
   m_tripletMode      = 0     ;
   m_tripletDZ        = 25.   ;
   m_tripletDK        = 0.005 ;  
   m_halfTripletDK    = 0.5*m_tripletDK;
   m_tripletDP        = 0.05  ;
   
   //  m_applyWeightThreshold = false;
   m_weightThreshold      = 0;
   
   
   m_IdScan_MaxNumLayers     = 20; // dphiEC depends on this value !!! 19 without IBL, 20 with IBL!!
   m_IdScan_LastBrlLayer     = 7;  // dphiBrl depends on this value
  
   m_invPhiSliceSize = 0;
   m_NumPhiSlices    = 0;
  
  
   // cppcheck-suppress missingReturn; false positive
   m_Status = 0;
 }

◆ ~IDScanZFinderInternal()

template<class SpacePoint >

virtual Run1::IDScanZFinderInternal< SpacePoint >::~IDScanZFinderInternal ( )

inlinevirtual

Definition at line 52 of file IDScanZFinderInternal.h.

52 {};

Member Function Documentation

◆ computeZV() [1/2]

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::computeZV	(	double	r1,
		double	p1,
		double	z1,
		double	r2,
		double	p2,
		double	z2
	)		const

protected

Definition at line 320 of file IDScanZFinderInternal.h.

                                                                    {
   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]

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::computeZV	(	double	r1,
		double	z1,
		double	r2,
		double	z2
	)		const

protected

Definition at line 315 of file IDScanZFinderInternal.h.

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

◆ fillVectors()

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::fillVectors	(	const std::vector< const SpacePoint * > &	spVec,
		const IRoiDescriptor &	roi,
		std::vector< double > &	phi,
		std::vector< double > &	rho,
		std::vector< double > &	zed,
		std::vector< long > &	lyr,
		std::vector< long > &	filledLayers
	)

protected

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 351 of file IDScanZFinderInternal.h.

 {
   std::vector<bool> lcount( m_IdScan_MaxNumLayers, false );
   
   // full scan check
   typename std::vector<const SpacePoint *>::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_usedROIphiWidth < 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_usedROIphiWidth;
     roiPhiMax = roi.phi()+0.5*m_usedROIphiWidth;
     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;
   
   m_usedROIphiWidth = dphi;
   
   //  std::cout << "m_usedROIphiWidth: " << m_usedROIphiWidth << std::endl;
   m_NumPhiSlices = long (ceil( m_usedROIphiWidth*m_invPhiSliceSize ));
   
   
   bool piBound=(roiPhiMin>roiPhiMax);
     
   int icount = 0;
   
   if(!piBound)
     {
       for(long i=0; i<nSPs; ++i, ++SpItr) 
     {
       if (m_pixOnly && !(*SpItr)->isPixel()) continue;
       double phi2 = (*SpItr)->phi() - roiPhiMin;
   
       if ( phi2>=0 && phi2<dphi ) { 
         phi[i] = phi2;
         rho[i] = (*SpItr)->r();
         zed[i] = (*SpItr)->z();
         lyr[i] = (*SpItr)->layer();
         lcount[lyr[i]]=true;
         ++icount;
       }
     }
     }
   else
     {
       for(long i=0; i<nSPs; ++i, ++SpItr) 
     {
       if (m_pixOnly && !(*SpItr)->isPixel()) continue;
       double phi2 = (*SpItr)->phi() - roiPhiMin;
       if( phi2<0.0) phi2+=2*M_PI;
   
       if ( phi2>=0 && phi2<dphi ) { 
         phi[i] = phi2;
         rho[i] = (*SpItr)->r();
         zed[i] = (*SpItr)->z();
         lyr[i] = (*SpItr)->layer();
         lcount[lyr[i]]=true;
         ++icount;
       }
     }
     }
     
   if ( icount<nSPs ) { 
   
     //    std::cout << "IDScanZFinderInternal::fillVectors() filtered some spacepoints " << nSPs 
     //        << " -> " << icount << std::endl; 
     phi.resize(icount);
     rho.resize(icount);
     zed.resize(icount);
     lyr.resize(icount);
   
     nSPs = 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;
 }

◆ findZInternal()

template<class SpacePoint >

std::vector< typename IDScanZFinderInternal< SpacePoint >::vertex > * Run1::IDScanZFinderInternal< SpacePoint >::findZInternal	(	const std::vector< const SpacePoint * > &	spVec,
		const IRoiDescriptor &	roi
	)

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

skip bins used for the vertex candidates

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

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
AAAAAAAAARRRGHH!!! This is ridiculous, passing parameters about differently because we don't have a proper interface defined

Definition at line 525 of file IDScanZFinderInternal.h.

 {
   std::vector<vertex>* output = new std::vector<vertex>();
   
   long nsp = spVec.size();
   if ( !nsp ) return output; //No points - return nothing
   
   SetInternalStatus(0);
   
   //   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 filled = this->fillVectors( spVec, roi, phi, rho, zed, lyr, filledLayers);
   
   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 ? m_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>() ) );
   
   for ( int i=2 ; i-- ;  ) { m_nHisto[i].clear();   m_nHisto[i].resize(numZhistos); } 
   for ( int i=2 ; i-- ;  ) { m_zHisto[i].clear();   m_zHisto[i].resize(numZhistos); } 
   
   std::vector< std::vector<long> >*   nHisto = m_nHisto;
   std::vector< std::vector<double> >* zHisto = m_zHisto;
   
   m_NMax = 0;
   
   
   
   
   //Make a vector of all the PhiSlice instances we need
   std::vector< PhiSlice* > allSlices( m_NumPhiSlices );
   for ( unsigned int sliceIndex = 0; sliceIndex < m_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 >( m_NumPhiSlices + 1, 0 ) );
   for ( unsigned int sliceIndex = 0; sliceIndex < m_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 < m_NumPhiSlices; sliceIndex++ )
     {
       nHisto[0][sliceIndex].resize( NumZhistoBins + 1 );
       zHisto[0][sliceIndex].resize( NumZhistoBins + 1 );
     }
       if ( m_chargeAware )
     {
       for ( unsigned int sliceIndex = 0; sliceIndex < m_NumPhiSlices; sliceIndex++ )
         {
           nHisto[1][sliceIndex].resize( NumZhistoBins + 1 );
           zHisto[1][sliceIndex].resize( NumZhistoBins + 1 );
         }
     }
   
       //Populate the histograms
       for ( unsigned int sliceIndex = 0; sliceIndex < m_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 < m_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 ];
     }
     }
   
   /*  
       printf("etaRoI: %f\n", etaRoI);  
       printf("ZBinSize: %f\n", ZBinSize);
       printf("m_minZBinSize %f\n", m_minZBinSize);
       printf("NumZhistoBins: %d\n",NumZhistoBins);
   */
   
   
   
     
   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;
         
   }
   
   
   
     
   //   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 ) {
   
       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 ) {
   
       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
       }
     }
     m_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>1 ) { 
       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  {
       zoutput.push_back( weightedMax );
       woutput.push_back( maxh );
     }
   
   }
   
   
     
   
   
   
 #if 0
   if ( m_weightThreshold>0 ) { 
       
       
     for ( unsigned i=0 ; i<zoutput.size() ; i++ ) { 
       output->push_back( woutput[i] - pedestal );
     }
       
   }    
   else { 
     for ( unsigned i=0 ; i<zoutput.size() ; i++ ) output->push_back( zoutput[i] ); 
   }
   
   
 #else
   
   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 ) ); 
     }
   }
   
   
 #endif
   
   //  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;
 }

◆ GetInternalStatus()

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::GetInternalStatus ( ) const

inlineprotected

Definition at line 81 of file IDScanZFinderInternal.h.

81 { return m_Status; }

◆ getName()

template<class SpacePoint >

const std::string& Run1::IDScanZFinderInternal< SpacePoint >::getName ( ) const

inlineprotected

Definition at line 78 of file IDScanZFinderInternal.h.

78 { return m_Name; }

◆ GetnHisto()

template<class SpacePoint >

const std::vector< std::vector<long> >* Run1::IDScanZFinderInternal< SpacePoint >::GetnHisto ( )

inline

Definition at line 58 of file IDScanZFinderInternal.h.

58 { return m_nHisto; }

◆ GetNMax()

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::GetNMax ( )

inline

Definition at line 61 of file IDScanZFinderInternal.h.

61 { return m_NMax; }

◆ GetReturnValue()

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::GetReturnValue ( ) const

inlineprotected

Definition at line 88 of file IDScanZFinderInternal.h.

88 { return m_returnval; }

◆ getType()

template<class SpacePoint >

const std::string& Run1::IDScanZFinderInternal< SpacePoint >::getType ( ) const

inlineprotected

Definition at line 77 of file IDScanZFinderInternal.h.

77 { return m_Type; }

◆ getVersion()

template<class SpacePoint >

const std::string& Run1::IDScanZFinderInternal< SpacePoint >::getVersion ( ) const

inlineprotected

Definition at line 79 of file IDScanZFinderInternal.h.

79 { return mZFIVER; }

◆ GetzHisto()

template<class SpacePoint >

const std::vector< std::vector<double> >* Run1::IDScanZFinderInternal< SpacePoint >::GetzHisto ( )

inline

Definition at line 59 of file IDScanZFinderInternal.h.

59 { return m_zHisto; }

◆ initializeInternal()

template<class SpacePoint >

void Run1::IDScanZFinderInternal< SpacePoint >::initializeInternal	(	long	maxLayers,
		long	lastBarrel
	)

this has to be computed event by event !!! m_NumPhiSlices = long (ceil( m_usedROIphiWidth*m_invPhiSliceSize ));

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 227 of file IDScanZFinderInternal.h.

 {
   m_halfTripletDK = 0.5*m_tripletDK;
   
   m_IdScan_MaxNumLayers = maxLayers; 
   m_IdScan_LastBrlLayer = lastBarrel; 
   
   //  std::cout << "m_IdScan_MaxNumLayers "    <<  m_IdScan_MaxNumLayers
   //        << "\tm_IdScan_LastBrlLayer "  <<  m_IdScan_LastBrlLayer << std::endl;
   
   // number of phi neighbours to look at
   //  if ( m_extraPhi.size()==0 ) 
   m_extraPhi = std::vector< std::vector<long> >( m_IdScan_MaxNumLayers, std::vector<long>(m_IdScan_MaxNumLayers) ); 
   
   if ( m_fullScanMode ) m_usedROIphiWidth = 2*M_PI;
   else                  m_usedROIphiWidth = m_ROIphiWidth;
   
   // from IDScanZFinder::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";
   }
   
 }

◆ SetInternalStatus()

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::SetInternalStatus ( int s )

inlineprotected

Definition at line 82 of file IDScanZFinderInternal.h.

82 { m_Status = s; return m_Status; }

◆ setLayers()

template<class SpacePoint >

void Run1::IDScanZFinderInternal< SpacePoint >::setLayers	(	long	maxLayers,
		long	lastBarrelLayer
	)

inline

Definition at line 64 of file IDScanZFinderInternal.h.

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

◆ SetReturnValue()

template<class SpacePoint >

void Run1::IDScanZFinderInternal< SpacePoint >::SetReturnValue ( double d )

inlineprotected

Definition at line 87 of file IDScanZFinderInternal.h.

87 { m_returnval=d; }

Member Data Documentation

◆ m_chargeAware

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_chargeAware

protected

Definition at line 120 of file IDScanZFinderInternal.h.

◆ m_dphideta

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_dphideta

protected

Definition at line 123 of file IDScanZFinderInternal.h.

◆ m_extraPhi

template<class SpacePoint >

std::vector< std::vector<long> > Run1::IDScanZFinderInternal< SpacePoint >::m_extraPhi

protected

Definition at line 126 of file IDScanZFinderInternal.h.

◆ m_forcePhiBinSize

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_forcePhiBinSize

protected

Definition at line 104 of file IDScanZFinderInternal.h.

◆ m_fullScanMode

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_fullScanMode

protected

Definition at line 146 of file IDScanZFinderInternal.h.

◆ m_halfTripletDK

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_halfTripletDK

protected

Definition at line 151 of file IDScanZFinderInternal.h.

◆ m_IdScan_LastBrlLayer

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::m_IdScan_LastBrlLayer

protected

Definition at line 95 of file IDScanZFinderInternal.h.

◆ m_IdScan_MaxNumLayers

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::m_IdScan_MaxNumLayers

protected

maximum number of layers and last barrel layer

Definition at line 94 of file IDScanZFinderInternal.h.

◆ m_invPhiSliceSize

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_invPhiSliceSize

protected

Definition at line 100 of file IDScanZFinderInternal.h.

◆ m_minZBinSize

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_minZBinSize

protected

Definition at line 108 of file IDScanZFinderInternal.h.

◆ m_Name

template<class SpacePoint >

std::string Run1::IDScanZFinderInternal< SpacePoint >::m_Name

protected

Definition at line 116 of file IDScanZFinderInternal.h.

◆ m_neighborMultiplier

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_neighborMultiplier

protected

Definition at line 124 of file IDScanZFinderInternal.h.

◆ m_nFirstLayers

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::m_nFirstLayers

protected

Definition at line 135 of file IDScanZFinderInternal.h.

◆ m_nHisto

template<class SpacePoint >

std::vector< std::vector<long> > Run1::IDScanZFinderInternal< SpacePoint >::m_nHisto[2]

protected

Definition at line 130 of file IDScanZFinderInternal.h.

◆ m_NMax

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::m_NMax

protected

Definition at line 133 of file IDScanZFinderInternal.h.

◆ m_numberOfPeaks

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::m_numberOfPeaks

protected

Definition at line 111 of file IDScanZFinderInternal.h.

◆ m_NumPhiSlices

template<class SpacePoint >

long Run1::IDScanZFinderInternal< SpacePoint >::m_NumPhiSlices

protected

Definition at line 101 of file IDScanZFinderInternal.h.

◆ m_nvrtxSeparation

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::m_nvrtxSeparation

protected

Definition at line 139 of file IDScanZFinderInternal.h.

◆ m_phiBinSize

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_phiBinSize

protected

Definition at line 103 of file IDScanZFinderInternal.h.

◆ m_pixOnly

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_pixOnly

protected

Definition at line 113 of file IDScanZFinderInternal.h.

◆ m_preferCentralZ

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_preferCentralZ

protected

Definition at line 140 of file IDScanZFinderInternal.h.

◆ m_returnval

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_returnval

protected

Definition at line 144 of file IDScanZFinderInternal.h.

◆ m_ROIphiWidth

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_ROIphiWidth

protected

Definition at line 106 of file IDScanZFinderInternal.h.

◆ m_Status

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::m_Status

protected

Definition at line 118 of file IDScanZFinderInternal.h.

◆ m_tripletDK

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_tripletDK

protected

Definition at line 150 of file IDScanZFinderInternal.h.

◆ m_tripletDP

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_tripletDP

protected

Definition at line 152 of file IDScanZFinderInternal.h.

◆ m_tripletDZ

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_tripletDZ

protected

Definition at line 149 of file IDScanZFinderInternal.h.

◆ m_tripletMode

template<class SpacePoint >

int Run1::IDScanZFinderInternal< SpacePoint >::m_tripletMode

protected

Definition at line 148 of file IDScanZFinderInternal.h.

◆ m_trustSPprovider

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_trustSPprovider

protected

Definition at line 142 of file IDScanZFinderInternal.h.

◆ m_Type

template<class SpacePoint >

std::string Run1::IDScanZFinderInternal< SpacePoint >::m_Type

protected

Definition at line 115 of file IDScanZFinderInternal.h.

◆ m_usedphiBinSize

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_usedphiBinSize

protected

Definition at line 105 of file IDScanZFinderInternal.h.

◆ m_usedROIphiWidth

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_usedROIphiWidth

protected

Definition at line 107 of file IDScanZFinderInternal.h.

◆ m_vrtxDistCut

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_vrtxDistCut

protected

Definition at line 137 of file IDScanZFinderInternal.h.

◆ m_vrtxMixing

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_vrtxMixing

protected

Definition at line 138 of file IDScanZFinderInternal.h.

◆ m_weightThreshold

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_weightThreshold

protected

to apply a hreshold to the found vertex candidates

Definition at line 156 of file IDScanZFinderInternal.h.

◆ m_zBinSizeEtaCoeff

template<class SpacePoint >

double Run1::IDScanZFinderInternal< SpacePoint >::m_zBinSizeEtaCoeff

protected

Definition at line 109 of file IDScanZFinderInternal.h.

◆ m_zHisto

template<class SpacePoint >

std::vector< std::vector<double> > Run1::IDScanZFinderInternal< SpacePoint >::m_zHisto[2]

protected

Definition at line 131 of file IDScanZFinderInternal.h.

◆ m_zHistoPerPhi

template<class SpacePoint >

bool Run1::IDScanZFinderInternal< SpacePoint >::m_zHistoPerPhi

protected

Definition at line 121 of file IDScanZFinderInternal.h.

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

IDScanZFinderInternal.h

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<class SpacePoint> class Run1::IDScanZFinderInternal< SpacePoint >

Constructor & Destructor Documentation

◆ IDScanZFinderInternal()

◆ ~IDScanZFinderInternal()

Member Function Documentation

◆ computeZV() [1/2]

◆ computeZV() [2/2]

◆ fillVectors()

◆ findZInternal()

◆ GetInternalStatus()

◆ getName()

◆ GetnHisto()

◆ GetNMax()

◆ GetReturnValue()

◆ getType()

◆ getVersion()

◆ GetzHisto()

◆ initializeInternal()

◆ SetInternalStatus()

◆ setLayers()

◆ SetReturnValue()

Member Data Documentation

◆ m_chargeAware

◆ m_dphideta

◆ m_extraPhi

◆ m_forcePhiBinSize

◆ m_fullScanMode

◆ m_halfTripletDK

◆ m_IdScan_LastBrlLayer

◆ m_IdScan_MaxNumLayers

◆ m_invPhiSliceSize

◆ m_minZBinSize

◆ m_Name

◆ m_neighborMultiplier

◆ m_nFirstLayers

◆ m_nHisto

◆ m_NMax

◆ m_numberOfPeaks

◆ m_NumPhiSlices

◆ m_nvrtxSeparation

◆ m_phiBinSize

◆ m_pixOnly

◆ m_preferCentralZ

◆ m_returnval

◆ m_ROIphiWidth

◆ m_Status

◆ m_tripletDK

◆ m_tripletDP

◆ m_tripletDZ

◆ m_tripletMode

◆ m_trustSPprovider

◆ m_Type

◆ m_usedphiBinSize

◆ m_usedROIphiWidth

◆ m_vrtxDistCut

◆ m_vrtxMixing

◆ m_weightThreshold

◆ m_zBinSizeEtaCoeff

◆ m_zHisto

◆ m_zHistoPerPhi

template<class SpacePoint>
class Run1::IDScanZFinderInternal< SpacePoint >