#include <CSCSegAlgoSK.h>

Inheritance diagram for CSCSegAlgoSK:

Public Types
typedef std::deque< bool >	BoolContainer

typedef std::vector< const CSCRecHit2D * >	ChamberHitContainer

typedef std::vector< const CSCRecHit2D * >::const_iterator	ChamberHitContainerCIt

typedef std::vector< int >	LayerIndex
	Typedefs. More...

Public Member Functions
std::vector< CSCSegment >	buildSegments (const ChamberHitContainer &rechits)

	CSCSegAlgoSK (const edm::ParameterSet &ps)
	Constructor. More...

std::vector< CSCSegment >	run (const CSCChamber *aChamber, const ChamberHitContainer &rechits) override

	~CSCSegAlgoSK () override
	Destructor. More...

Public Member Functions inherited from CSCSegmentAlgorithm
	CSCSegmentAlgorithm (const edm::ParameterSet &)
	Constructor. More...

virtual std::vector< CSCSegment >	run (const CSCChamber chamber, const std::vector< const CSCRecHit2D > &rechits)=0

virtual	~CSCSegmentAlgorithm ()
	Destructor. More...

Private Member Functions
bool	addHit (const CSCRecHit2D *hit, int layer)
	Utility functions. More...

bool	areHitsCloseInGlobalPhi (const CSCRecHit2D h1, const CSCRecHit2D h2) const

bool	areHitsCloseInLocalX (const CSCRecHit2D h1, const CSCRecHit2D h2) const
	Utility functions. More...

void	compareProtoSegment (const CSCRecHit2D *h, int layer)

void	dumpHits (const ChamberHitContainer &rechits) const

void	dumpSegment (const CSCSegment &seg) const

void	flagHitsAsUsed (const ChamberHitContainer &rechitsInChamber, BoolContainer &used) const

bool	hasHitOnLayer (int layer) const

void	increaseProtoSegment (const CSCRecHit2D *h, int layer)

bool	isHitNearSegment (const CSCRecHit2D *h) const

bool	isSegmentGood (const ChamberHitContainer &rechitsInChamber) const

float	phiAtZ (float z) const

bool	replaceHit (const CSCRecHit2D *h, int layer)

void	tryAddingHitsToSegment (const ChamberHitContainer &rechitsInChamber, const BoolContainer &used, const LayerIndex &layerIndex, const ChamberHitContainerCIt i1, const ChamberHitContainerCIt i2)

void	updateParameters (void)

Private Attributes
float	chi2Max

bool	debugInfo

float	dPhiFineMax

float	dPhiMax

float	dRPhiFineMax

float	dRPhiMax

int	minLayersApart

const std::string	myName

ChamberHitContainer	proto_segment

CSCSegFit *	sfit_

const CSCChamber *	theChamber

float	wideSeg

float	windowScale

Detailed Description

This is the original algorithm for building endcap muon track segments out of the rechit's in a CSCChamber. cf. CSCSegmentizerTC.
'SK' = 'Sasha Khanov' = Speed King

A CSCSegment is a RecSegment4D, and is built from CSCRecHit2D objects, each of which is a RecHit2DLocalPos.

This class is used by the CSCSegmentAlgorithm.
Alternative algorithms can be used for the segment building by writing classes like this, and then selecting which one is actually used via the CSCSegmentBuilder.

Original (in FORTRAN): Alexa.nosp@m.ndre.nosp@m..Khan.nosp@m.ov@c.nosp@m.ern.c.nosp@m.h
Ported to C++ and improved: Rick..nosp@m.Wilk.nosp@m.inson.nosp@m.@cer.nosp@m.n.ch
Reimplemented in terms of layer index, and bug fix: Tim.C.nosp@m.ox@c.nosp@m.ern.c.nosp@m.h
Ported to CMSSW 2006-04-03: Matte.nosp@m.o.Sa.nosp@m.ni@ce.nosp@m.rn.c.nosp@m.h
Factored out segment fitter Tim.C.nosp@m.ox@c.nosp@m.ern.c.nosp@m.h Feb-2015

Definition at line 35 of file CSCSegAlgoSK.h.

Member Typedef Documentation

typedef std::deque<bool> CSCSegAlgoSK::BoolContainer

Definition at line 58 of file CSCSegAlgoSK.h.

typedef std::vector<const CSCRecHit2D*> CSCSegAlgoSK::ChamberHitContainer

Definition at line 50 of file CSCSegAlgoSK.h.

typedef std::vector<const CSCRecHit2D*>::const_iterator CSCSegAlgoSK::ChamberHitContainerCIt

Definition at line 51 of file CSCSegAlgoSK.h.

typedef std::vector<int> CSCSegAlgoSK::LayerIndex

Typedefs.

Definition at line 49 of file CSCSegAlgoSK.h.

Constructor & Destructor Documentation

CSCSegAlgoSK::CSCSegAlgoSK ( const edm::ParameterSet & ps )

explicit

Constructor.

Definition at line 19 of file CSCSegAlgoSK.cc.

References chi2Max, debugInfo, dPhiFineMax, dPhiMax, dRPhiFineMax, dRPhiMax, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, minLayersApart, myName, and wideSeg.

   : CSCSegmentAlgorithm(ps), myName("CSCSegAlgoSK"), sfit_(nullptr) {
     
   debugInfo = ps.getUntrackedParameter<bool>("verboseInfo");
     
   dRPhiMax       = ps.getParameter<double>("dRPhiMax");
   dPhiMax        = ps.getParameter<double>("dPhiMax");
   dRPhiFineMax   = ps.getParameter<double>("dRPhiFineMax");
   dPhiFineMax    = ps.getParameter<double>("dPhiFineMax");
   chi2Max        = ps.getParameter<double>("chi2Max");
   wideSeg        = ps.getParameter<double>("wideSeg");
   minLayersApart = ps.getParameter<int>("minLayersApart");
     
   LogDebug("CSC") << myName << " has algorithm cuts set to: \n"
           << "--------------------------------------------------------------------\n"
           << "dRPhiMax     = " << dRPhiMax << '\n'
           << "dPhiMax      = " << dPhiMax << '\n'
           << "dRPhiFineMax = " << dRPhiFineMax << '\n'
           << "dPhiFineMax  = " << dPhiFineMax << '\n'
           << "chi2Max      = " << chi2Max << '\n'
           << "wideSeg      = " << wideSeg << '\n'
           << "minLayersApart = " << minLayersApart << std::endl;
 }

CSCSegAlgoSK::~CSCSegAlgoSK ( )

inlineoverride

Destructor.

Definition at line 63 of file CSCSegAlgoSK.h.

References addHit(), areHitsCloseInGlobalPhi(), areHitsCloseInLocalX(), buildSegments(), compareProtoSegment(), dumpHits(), dumpSegment(), flagHitsAsUsed(), hasHitOnLayer(), increaseProtoSegment(), isHitNearSegment(), isSegmentGood(), phiAtZ(), TrackInfoProducer_cfi::rechits, replaceHit(), run(), tryAddingHitsToSegment(), updateParameters(), and z.

63 {};

Member Function Documentation

bool CSCSegAlgoSK::addHit	(	const CSCRecHit2D *	hit,
		int	layer
	)

private

Utility functions.

Definition at line 375 of file CSCSegAlgoSK.cc.

References proto_segment, and updateParameters().

Referenced by buildSegments(), increaseProtoSegment(), replaceHit(), and ~CSCSegAlgoSK().

                                                             {
   
   // Return true if hit was added successfully 
   // (and then parameters are updated).
   // Return false if there is already a hit on the same layer, or insert failed.
   
   ChamberHitContainer::const_iterator it;
 
   for(it = proto_segment.begin(); it != proto_segment.end(); it++)
     if (((*it)->cscDetId().layer() == layer) && (aHit != (*it)))
        return false; 
   
   proto_segment.push_back(aHit);
 
   // make a fit
   updateParameters();
   return true;
 }

bool CSCSegAlgoSK::areHitsCloseInGlobalPhi	(	const CSCRecHit2D *	h1,
		const CSCRecHit2D *	h2
	)		const

private

Definition at line 251 of file CSCSegAlgoSK.cc.

References CSCRecHit2D::cscDetId(), dPhiMax, CSCChamber::layer(), CSCDetId::layer(), CSCRecHit2D::localPosition(), LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::phi(), theChamber, GeomDet::toGlobal(), and windowScale.

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                                                                              {
   
   const CSCLayer* l1 = theChamber->layer(h1->cscDetId().layer());
   GlobalPoint gp1 = l1->toGlobal(h1->localPosition());  
   const CSCLayer* l2 = theChamber->layer(h2->cscDetId().layer());
   GlobalPoint gp2 = l2->toGlobal(h2->localPosition());  
   
   float h1p = gp1.phi();
   float h2p = gp2.phi();
   float dphi12 = h1p - h2p;
   
   // Into range [-pi, pi) (phi() returns values in this range)
   if (dphi12 < -M_PI) 
     dphi12 += 2.*M_PI;  
   if (dphi12 >  M_PI) 
     dphi12 -= 2.*M_PI;
   LogDebug("CSC") << "    Hits at global phi= " << h1p << ", " 
           << h2p << " have separation= " << dphi12;
   return (fabs(dphi12) < (dPhiMax * windowScale))? true:false;  // +v
 }

bool CSCSegAlgoSK::areHitsCloseInLocalX	(	const CSCRecHit2D *	h1,
		const CSCRecHit2D *	h2
	)		const

private

Utility functions.

Definition at line 244 of file CSCSegAlgoSK.cc.

References dRPhiMax, CSCRecHit2D::localPosition(), LogDebug, windowScale, and x.

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                                                                           {
   float deltaX = ( h1->localPosition() - h2->localPosition() ).x();
   LogDebug("CSC") << "    Hits at local x= " << h1->localPosition().x() << ", " 
           << h2->localPosition().x() << " have separation= " << deltaX;
   return (fabs(deltaX) < (dRPhiMax * windowScale))? true:false;   // +v
 }

std::vector< CSCSegment > CSCSegAlgoSK::buildSegments ( const ChamberHitContainer & rechits )

Build track segments in this chamber (this is where the actual segment-building algorithm hides.)

Definition at line 48 of file CSCSegAlgoSK.cc.

References funct::abs(), addHit(), areHitsCloseInGlobalPhi(), areHitsCloseInLocalX(), CSCChamberSpecs::chamberTypeName(), CSCSegFit::chi2(), CSCSegFit::covarianceMatrix(), debugInfo, dumpSegment(), flagHitsAsUsed(), CSCSegFit::hits(), mps_fire::i, cuy::ib, CSCSegFit::intercept(), isSegmentGood(), CSCChamber::layer(), CSCSegFit::localdir(), CSCRecHit2D::localPosition(), LogDebug, minLayersApart, myName, GeomDet::position(), proto_segment, TrackInfoProducer_cfi::rechits, groupFilesInBlocks::reverse, sfit_, CSCChamber::specs(), groupFilesInBlocks::temp, theChamber, GeomDet::toGlobal(), tryAddingHitsToSegment(), wideSeg, windowScale, and PV3DBase< T, PVType, FrameType >::z().

Referenced by run(), and ~CSCSegAlgoSK().

                                                                                      {
     
   LogDebug("CSC") << "*********************************************";
   LogDebug("CSC") << "Start segment building in the new chamber: " << theChamber->specs()->chamberTypeName();
   LogDebug("CSC") << "*********************************************";
   
   ChamberHitContainer rechits = urechits;
   LayerIndex layerIndex(rechits.size());
   
   for(unsigned int i = 0; i < rechits.size(); i++) {
     
     layerIndex[i] = rechits[i]->cscDetId().layer();
   }
   
   double z1 = theChamber->layer(1)->position().z();
   double z6 = theChamber->layer(6)->position().z();
   
   if ( z1 > 0. ) {
     if ( z1 > z6 ) { 
       reverse(layerIndex.begin(), layerIndex.end());
       reverse(rechits.begin(), rechits.end());
     }    
   }
   else if ( z1 < 0. ) {
     if ( z1 < z6 ) {
       reverse(layerIndex.begin(), layerIndex.end());
       reverse(rechits.begin(), rechits.end());
     }    
   }
   
   //  if (debugInfo) dumpHits(rechits);
 
   if (rechits.size() < 2) {
     LogDebug("CSC") << myName << ": " << rechits.size() << 
       "  hit(s) in chamber is not enough to build a segment.\n";
     return std::vector<CSCSegment>(); 
   }
     
   // We have at least 2 hits. We intend to try all possible pairs of hits to start 
   // segment building. 'All possible' means each hit lies on different layers in the chamber.
   // BUT... once a hit has been assigned to a segment, we don't consider
   // it again.
   
   // Choose first hit (as close to IP as possible) h1 and 
   // second hit (as far from IP as possible) h2
   // To do this we iterate over hits in the chamber by layer - pick two layers.
   // @@ Require the two layers are at least 3 layers apart. May need tuning?
   // Then we iterate over hits within each of these layers and pick h1 and h2 from these.
   // If they are 'close enough' we build an empty segment.
   // Then try adding hits to this segment.
   
   // Initialize flags that a given hit has been allocated to a segment
   BoolContainer used(rechits.size(), false);
   
   // Define buffer for segments we build 
   std::vector<CSCSegment> segments;
 
   // This is going to point to fits to hits, and its content will be used to create a CSCSegment
   sfit_ = nullptr;
   
   ChamberHitContainerCIt ib = rechits.begin();
   ChamberHitContainerCIt ie = rechits.end();
   
   // Possibly allow 2 passes, second widening scale factor for cuts
   windowScale = 1.; // scale factor for cuts
   
   int npass = (wideSeg > 1.)? 2 : 1;
   
   for (int ipass = 0; ipass < npass; ++ipass) {
     for (ChamberHitContainerCIt i1 = ib; i1 != ie; ++i1) {
       bool segok = false;
       if(used[i1-ib]) 
         continue;
       
       int layer1 = layerIndex[i1-ib]; //(*i1)->cscDetId().layer();
       const CSCRecHit2D* h1 = *i1;
       
       for (ChamberHitContainerCIt i2 = ie-1; i2 != i1; --i2) {
         if(used[i2-ib]) 
           continue;
         
         int layer2 = layerIndex[i2-ib]; //(*i2)->cscDetId().layer();
                 
         if (abs(layer2 - layer1) < minLayersApart) 
           break;
         const CSCRecHit2D* h2 = *i2;
         
         if (areHitsCloseInLocalX(h1, h2) && areHitsCloseInGlobalPhi(h1, h2)) {
           
           proto_segment.clear();
           
           const CSCLayer* l1 = theChamber->layer(layer1);
           GlobalPoint gp1 = l1->toGlobal(h1->localPosition());                  
           const CSCLayer* l2 = theChamber->layer(layer2);
           GlobalPoint gp2 = l2->toGlobal(h2->localPosition());                  
           LogDebug("CSC") << "start new segment from hits " << "h1: " 
                           << gp1 << " - h2: " << gp2 << "\n";
 
       //@@ TRY ADDING A HIT - AND FIT           
           if (!addHit(h1, layer1)) { 
             LogDebug("CSC") << "  failed to add hit h1\n";
             continue;
           }
           
           if (!addHit(h2, layer2)) { 
             LogDebug("CSC") << "  failed to add hit h2\n";
             continue;
           }
           
       // Can only add hits if already have a segment
           if ( sfit_ ) tryAddingHitsToSegment(rechits, used, layerIndex, i1, i2); 
           
           // Check no. of hits on segment, and if enough flag them as used
           // and store the segment
           segok = isSegmentGood(rechits);
           if (segok) {
             flagHitsAsUsed(rechits, used);
             // Copy the proto_segment and its properties inside a CSCSegment.
             // Then fill the segment vector..
             
             if (proto_segment.empty()) {
               LogDebug("CSC") << "No segment has been found !!!\n";
             }   
             else {
           // Create an actual CSCSegment - retrieve all info from the fit
               CSCSegment temp(sfit_->hits(), sfit_->intercept(), 
                 sfit_->localdir(), sfit_->covarianceMatrix(), sfit_->chi2() );
               delete sfit_;
               sfit_ = nullptr;              
               LogDebug("CSC") << "Found a segment !!!\n";
               if ( debugInfo ) dumpSegment( temp );
               segments.push_back(temp); 
             }
           }
         }  //   h1 & h2 close
         
         if (segok) 
           break;
       }  //  i2
     }  //  i1
     
     if (segments.size() > 1)  
       break;  // only change window if no segments found
     
     // Increase cut windows by factor of wideSeg
     windowScale = wideSeg;
     
   }  //  ipass
   
   // Give the segments to the CSCChamber
   return segments;
 }

void CSCSegAlgoSK::compareProtoSegment	(	const CSCRecHit2D *	h,
		int	layer
	)

private

Definition at line 428 of file CSCSegAlgoSK.cc.

References CSCSegFit::chi2(), LogDebug, convertSQLiteXML::ok, replaceHit(), and sfit_.

Referenced by tryAddingHitsToSegment(), and ~CSCSegAlgoSK().

                                                                       {
   
   // Copy the input CSCSegFit
   CSCSegFit* oldfit = new CSCSegFit( *sfit_ );
   
   // May create a new fit
   bool ok = replaceHit(h, layer);
   
   if (ok) {
     LogDebug("CSCSegment") << "    hit in same layer as a hit on segment; try replacing old one..." 
             << " chi2 new: " << sfit_->chi2() << " old: " << oldfit->chi2() << "\n";
   }
   
   if ( ( sfit_->chi2() < oldfit->chi2() ) && ok ) {
     LogDebug("CSC")  << "    segment with replaced hit is better.\n";
     delete oldfit;  // new fit is better 
   }
   else {
     // keep original fit
     delete sfit_; // now the new fit
     sfit_ = oldfit;  // reset to the original input fit
   }
 }

void CSCSegAlgoSK::dumpHits ( const ChamberHitContainer & rechits ) const

private

Dump position and phi of each rechit in chamber after sort in z

Definition at line 325 of file CSCSegAlgoSK.cc.

References CSCChamber::layer(), PV3DBase< T, PVType, FrameType >::phi(), theChamber, and GeomDet::toGlobal().

Referenced by ~CSCSegAlgoSK().

                                                                     {
   
   // Dump positions of RecHit's in each CSCChamber
   ChamberHitContainerCIt it;
   edm::LogInfo("CSCSegment") << "CSCChamber rechit dump.\n";    
   for(it=rechits.begin(); it!=rechits.end(); it++) {
     
     const CSCLayer* l1 = theChamber->layer((*it)->cscDetId().layer());
     GlobalPoint gp1 = l1->toGlobal((*it)->localPosition()); 
     
     edm::LogInfo("CSCSegment") << "Global pos.: " << gp1 << ", phi: " << gp1.phi() << ". Local position: "
             << (*it)->localPosition() << ", phi: "
             << (*it)->localPosition().phi() << ". Layer: "
             << (*it)->cscDetId().layer() << "\n";
   } 
 }

void CSCSegAlgoSK::dumpSegment ( const CSCSegment & seg ) const

private

Definition at line 479 of file CSCSegAlgoSK.cc.

References CSCSegment::chi2(), CSCSegment::degreesOfFreedom(), CSCChamber::id(), CSCSegment::localDirection(), CSCSegment::localDirectionError(), CSCSegment::localPosition(), CSCSegment::localPositionError(), CSCSegment::parametersError(), CSCSegment::specificRecHits(), theChamber, and CSCSegment::time().

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                                             {
 
   edm::LogVerbatim("CSCSegment") << "CSCSegment in " << theChamber->id()
                  << "\nlocal position = " << seg.localPosition()
                  << "\nerror = " << seg.localPositionError()
                  << "\nlocal direction = " << seg.localDirection()
                  << "\nerror =" << seg.localDirectionError()
                  << "\ncovariance matrix"
                  << seg.parametersError()
                  << "chi2/ndf = " << seg.chi2() << "/" << seg.degreesOfFreedom()
                  << "\n#rechits = " << seg.specificRecHits().size()
                  << "\ntime = " << seg.time();
 }

void CSCSegAlgoSK::flagHitsAsUsed	(	const ChamberHitContainer &	rechitsInChamber,
		BoolContainer &	used
	)		const

private

Flag hits on segment as used

Definition at line 360 of file CSCSegAlgoSK.cc.

References cuy::ib, and proto_segment.

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                               {
   
   // Flag hits on segment as used
   ChamberHitContainerCIt ib = rechitsInChamber.begin();
   ChamberHitContainerCIt hi, iu;
   
   for(hi = proto_segment.begin(); hi != proto_segment.end(); ++hi) {
     for(iu = ib; iu != rechitsInChamber.end(); ++iu) {
       if(*hi == *iu)
     used[iu-ib] = true;
     }
   }
 }

bool CSCSegAlgoSK::hasHitOnLayer ( int layer ) const

private

Definition at line 402 of file CSCSegAlgoSK.cc.

References proto_segment.

Referenced by tryAddingHitsToSegment(), and ~CSCSegAlgoSK().

                                                 {
   
   // Is there is already a hit on this layer?
   ChamberHitContainerCIt it;
   
   for(it = proto_segment.begin(); it != proto_segment.end(); it++)
     if ((*it)->cscDetId().layer() == layer)
       return true; 
   
   return false;
 }

void CSCSegAlgoSK::increaseProtoSegment	(	const CSCRecHit2D *	h,
		int	layer
	)

private

Definition at line 452 of file CSCSegAlgoSK.cc.

References addHit(), CSCSegFit::chi2(), chi2Max, LogDebug, CSCSegFit::ndof(), convertSQLiteXML::ok, and sfit_.

Referenced by tryAddingHitsToSegment(), and ~CSCSegAlgoSK().

                                                                        {
   
   // Copy input fit
   CSCSegFit* oldfit = new CSCSegFit( *sfit_ );
 
   // Creates a new fit  
   bool ok = addHit(h, layer);
   
   if (ok) {
     LogDebug("CSCSegment") << "    hit in new layer: added to segment, new chi2: " 
             << sfit_->chi2() << "\n";
   }
   
   //  int ndf = 2*proto_segment.size() - 4;
 
   //@@ TEST ON ndof<=0 IS JUST TO ACCEPT nhits=2 CASE??  
   if ( ok && ( (sfit_->ndof() <= 0) || (sfit_->chi2()/sfit_->ndof() < chi2Max)) ) {
     LogDebug("CSCSegment") << "    segment with added hit is good.\n" ; 
     delete oldfit;  // new fit is better 
   } 
   else {
     // reset to original fit
     delete sfit_;
     sfit_ = oldfit;
   }         
 }       

bool CSCSegAlgoSK::isHitNearSegment ( const CSCRecHit2D * h ) const

private

Definition at line 272 of file CSCSegAlgoSK.cc.

References CSCRecHit2D::cscDetId(), dPhiFineMax, dRPhiFineMax, AnalysisDataFormats_SUSYBSMObjects::hp, CSCChamber::layer(), CSCDetId::layer(), CSCRecHit2D::localPosition(), LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), phiAtZ(), theChamber, GeomDet::toGlobal(), windowScale, and PV3DBase< T, PVType, FrameType >::z().

Referenced by tryAddingHitsToSegment(), and ~CSCSegAlgoSK().

                                                               {
   
   // Is hit near segment? 
   // Requires deltaphi and rxy*deltaphi within ranges specified
   // in parameter set, where rxy=sqrt(x**2+y**2) of hit itself.
   // Note that to make intuitive cuts on delta(phi) one must work in
   // phi range (-pi, +pi] not [0, 2pi)
   
   const CSCLayer* l1 = theChamber->layer(h->cscDetId().layer());
   GlobalPoint hp = l1->toGlobal(h->localPosition());    
   
   float hphi = hp.phi();          // in (-pi, +pi]
   if (hphi < 0.) 
     hphi += 2.*M_PI;            // into range [0, 2pi)
   float sphi = phiAtZ(hp.z());    // in [0, 2*pi)
   float phidif = sphi-hphi;
   if (phidif < 0.) 
     phidif += 2.*M_PI;          // into range [0, 2pi)
   if (phidif > M_PI) 
     phidif -= 2.*M_PI;          // into range (-pi, pi]
   
   float dRPhi = fabs(phidif)*hp.perp();
   LogDebug("CSC") << "    is hit at phi_h= " << hphi << " near segment phi_seg= " << sphi 
           << "? is " << dRPhi << "<" << dRPhiFineMax*windowScale << " ? " 
           << " and is |" << phidif << "|<" << dPhiFineMax*windowScale << " ?";
   
   return ((dRPhi < dRPhiFineMax*windowScale) && 
       (fabs(phidif) < dPhiFineMax*windowScale))? true:false;  // +v
 }

bool CSCSegAlgoSK::isSegmentGood ( const ChamberHitContainer & rechitsInChamber ) const

private

Return true if segment is 'good'. In this algorithm, 'good' means has sufficient hits

Definition at line 342 of file CSCSegAlgoSK.cc.

References convertSQLiteXML::ok, proto_segment, and windowScale.

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                                                                   {
   
   // If the chamber has 20 hits or fewer, require at least 3 hits on segment
   // If the chamber has >20 hits require at least 4 hits
 
   bool ok = false;
   
   unsigned int iadd = ( rechitsInChamber.size() > 20 )?  1 : 0;  
   
   if (windowScale > 1.)
     iadd = 1;
   
   if (proto_segment.size() >= 3+iadd)
     ok = true;
   
   return ok;
 }

float CSCSegAlgoSK::phiAtZ ( float z ) const

private

Definition at line 302 of file CSCSegAlgoSK.cc.

References f, runTauDisplay::gp, CSCSegFit::intercept(), CSCChamber::layer(), CSCSegFit::localdir(), LogTrace, M_PI, phi, proto_segment, sfit_, theChamber, GeomDet::toGlobal(), x, PV3DBase< T, PVType, FrameType >::x(), y, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by isHitNearSegment(), and ~CSCSegAlgoSK().

                                         {
   
   if ( !sfit_ ) {
       edm::LogVerbatim("CSCSegment") << "[CSCSegAlgoSK::phiAtZ] Segment fit undefined";
       return 0.;
   }
 
   // Returns a phi in [ 0, 2*pi )
   const CSCLayer* l1 = theChamber->layer((*(proto_segment.begin()))->cscDetId().layer());
   GlobalPoint gp = l1->toGlobal(sfit_->intercept());    
   GlobalVector gv = l1->toGlobal(sfit_->localdir());    
 
   LogTrace("CSCSegment") << "[CSCSegAlgoSK::phiAtZ] Global intercept = " << gp << ", direction = " << gv;  
 
   float x = gp.x() + (gv.x()/gv.z())*(z - gp.z());
   float y = gp.y() + (gv.y()/gv.z())*(z - gp.z());
   float phi = atan2(y, x);
   if (phi < 0.f ) 
     phi += 2. * M_PI;
   
   return phi ;
 }

bool CSCSegAlgoSK::replaceHit	(	const CSCRecHit2D *	h,
		int	layer
	)

private

Definition at line 414 of file CSCSegAlgoSK.cc.

References addHit(), and proto_segment.

Referenced by compareProtoSegment(), and ~CSCSegAlgoSK().

                                                              {
   
   // replace a hit from a layer 
   ChamberHitContainer::iterator it;
   for (it = proto_segment.begin(); it != proto_segment.end();) {
     if ((*it)->cscDetId().layer() == layer)
       it = proto_segment.erase(it);
     else
       ++it;   
   }
   
   return addHit(h, layer);
 }

std::vector< CSCSegment > CSCSegAlgoSK::run	(	const CSCChamber *	aChamber,
		const ChamberHitContainer &	rechits
	)

override

Here we must implement the algorithm

Definition at line 43 of file CSCSegAlgoSK.cc.

References buildSegments(), and theChamber.

Referenced by ~CSCSegAlgoSK().

                                                                                                       {
     theChamber = aChamber; 
     return buildSegments(rechits); 
 }

void CSCSegAlgoSK::tryAddingHitsToSegment	(	const ChamberHitContainer &	rechitsInChamber,
		const BoolContainer &	used,
		const LayerIndex &	layerIndex,
		const ChamberHitContainerCIt	i1,
		const ChamberHitContainerCIt	i2
	)

private

Try adding non-used hits to segment

Definition at line 201 of file CSCSegAlgoSK.cc.

References compareProtoSegment(), hasHitOnLayer(), mps_fire::i, cuy::ib, increaseProtoSegment(), isHitNearSegment(), CSCChamber::layer(), CSCRecHit2D::localPosition(), LogDebug, proto_segment, theChamber, and GeomDet::toGlobal().

Referenced by buildSegments(), and ~CSCSegAlgoSK().

                                                                                         {
 
   // Iterate over the layers with hits in the chamber
   // Skip the layers containing the segment endpoints
   // Test each hit on the other layers to see if it is near the segment
   // If it is, see whether there is already a hit on the segment from the same layer
   //    - if so, and there are more than 2 hits on the segment, copy the segment,
   //      replace the old hit with the new hit. If the new segment chi2 is better
   //      then replace the original segment with the new one (by swap)
   //    - if not, copy the segment, add the hit. If the new chi2/dof is still satisfactory
   //      then replace the original segment with the new one (by swap)
   
   ChamberHitContainerCIt ib = rechits.begin();
   ChamberHitContainerCIt ie = rechits.end();
   
   for (ChamberHitContainerCIt i = ib; i != ie; ++i) {
     if (i == i1 || i == i2 || used[i-ib]) 
       continue; 
     
     int layer = layerIndex[i-ib]; 
     const CSCRecHit2D* h = *i;
     if (isHitNearSegment(h)) {
       
       GlobalPoint gp1 = theChamber->layer(layer)->toGlobal(h->localPosition());     
       LogDebug("CSC") << "    hit at global " << gp1 << " is near segment\n.";
       
       // Don't consider alternate hits on layers holding the two starting points
       if (hasHitOnLayer(layer)) {
     if (proto_segment.size() <= 2) {
       LogDebug("CSC") << "    " << proto_segment.size() 
               << " hits on segment...skip hit on same layer.\n";
       continue;
     }
     compareProtoSegment(h, layer);
       } 
       else                  
     increaseProtoSegment(h, layer);
     }   // h & seg close
   }   // i
 }

void CSCSegAlgoSK::updateParameters ( void )

private

Definition at line 394 of file CSCSegAlgoSK.cc.

References CSCSegFit::fit(), proto_segment, sfit_, and theChamber.

Referenced by addHit(), and ~CSCSegAlgoSK().

                                          {
 
   // Delete input CSCSegFit, create a new one and make the fit
   delete sfit_;
   sfit_ = new CSCSegFit( theChamber, proto_segment );
   sfit_->fit();
 }