SiStripRecHitMatcher Class Reference

#include <SiStripRecHitMatcher.h>

Public Types
typedef boost::function< void(SiStripMatchedRecHit2D const &)>	Collector
typedef SiStripMatchedRecHit2DCollectionNew::FastFiller	CollectorMatched
typedef SiStripRecHit2DCollectionNew::DetSet::const_iterator	RecHitIterator
typedef std::vector< const SiStripRecHit2D * >	SimpleHitCollection
typedef SimpleHitCollection::const_iterator	SimpleHitIterator
typedef std::pair< LocalPoint, LocalPoint >	StripPosition

Public Member Functions
template<typename MonoIterator , typename StereoIterator , typename CollectorHelper >
void	doubleMatch (MonoIterator monoRHiter, MonoIterator monoRHend, StereoIterator seconditer, StereoIterator seconditerend, const GluedGeomDet *gluedDet, LocalVector trdir, CollectorHelper &collectorHelper) const
std::unique_ptr < SiStripMatchedRecHit2D >	match (const SiStripRecHit2D *monoRH, const SiStripRecHit2D *stereoRH, const GluedGeomDet *gluedDet, LocalVector trackdirection, bool force=false) const
void	match (const SiStripRecHit2D *monoRH, RecHitIterator begin, RecHitIterator end, CollectorMatched &collector, const GluedGeomDet *gluedDet, LocalVector trackdirection) const
void	match (const SiStripRecHit2D *monoRH, SimpleHitIterator begin, SimpleHitIterator end, CollectorMatched &collector, const GluedGeomDet *gluedDet, LocalVector trackdirection) const
void	match (const SiStripRecHit2D *monoRH, SimpleHitIterator begin, SimpleHitIterator end, edm::OwnVector< SiStripMatchedRecHit2D > &collector, const GluedGeomDet *gluedDet, LocalVector trackdirection) const
void	match (const SiStripRecHit2D *monoRH, SimpleHitIterator begin, SimpleHitIterator end, std::vector< SiStripMatchedRecHit2D * > &collector, const GluedGeomDet *gluedDet, LocalVector trackdirection) const
void	match (const SiStripRecHit2D *monoRH, SimpleHitIterator begin, SimpleHitIterator end, Collector &collector, const GluedGeomDet *gluedDet, LocalVector trackdirection) const
	the actual implementation More...
bool	preFilter () const
StripPosition	project (const GeomDetUnit *det, const GluedGeomDet *glueddet, StripPosition strip, LocalVector trackdirection) const
	SiStripRecHitMatcher (const edm::ParameterSet &conf)
	SiStripRecHitMatcher (const double theScale)

Static Public Member Functions
static float	sigmaPitch (LocalPoint const &pos, LocalError const &err, const StripTopology &topol)

Public Attributes
bool	preFilter_ =false
float	scale_

Detailed Description

Definition at line 26 of file SiStripRecHitMatcher.h.

Member Typedef Documentation

typedef boost::function<void(SiStripMatchedRecHit2D const&)> SiStripRecHitMatcher::Collector

Definition at line 36 of file SiStripRecHitMatcher.h.

typedef SiStripMatchedRecHit2DCollectionNew::FastFiller SiStripRecHitMatcher::CollectorMatched

Definition at line 30 of file SiStripRecHitMatcher.h.

typedef SiStripRecHit2DCollectionNew::DetSet::const_iterator SiStripRecHitMatcher::RecHitIterator

Definition at line 32 of file SiStripRecHitMatcher.h.

typedef std::vector<const SiStripRecHit2D *> SiStripRecHitMatcher::SimpleHitCollection

Definition at line 33 of file SiStripRecHitMatcher.h.

typedef SimpleHitCollection::const_iterator SiStripRecHitMatcher::SimpleHitIterator

Definition at line 34 of file SiStripRecHitMatcher.h.

typedef std::pair<LocalPoint,LocalPoint> SiStripRecHitMatcher::StripPosition

Definition at line 39 of file SiStripRecHitMatcher.h.

Constructor & Destructor Documentation

SiStripRecHitMatcher::SiStripRecHitMatcher

(

const edm::ParameterSet &

conf

)

Definition at line 18 of file SiStripRecHitMatcher.cc.

                                                                     :
  scale_(conf.getParameter<double>("NSigmaInside")),
  preFilter_(conf.existsAs<bool>("PreFilter") ? conf.getParameter<bool>("PreFilter") : false)  
  {}

SiStripRecHitMatcher::SiStripRecHitMatcher

(

const double

theScale

)

Definition at line 23 of file SiStripRecHitMatcher.cc.

                                                               :
  scale_(theScale){}  

Member Function Documentation

template<typename MonoIterator , typename StereoIterator , typename CollectorHelper >

void SiStripRecHitMatcher::doubleMatch	(	MonoIterator	monoRHiter,
		MonoIterator	monoRHend,
		StereoIterator	seconditer,
		StereoIterator	seconditerend,
		const GluedGeomDet *	gluedDet,
		LocalVector	trdir,
		CollectorHelper &	collectorHelper
	)		const

Definition at line 16 of file SSEMatcher.h.

References mathSSE::Vec2< T >::arr, PV3DBase< T, PVType, FrameType >::basicVector(), alignmentValidation::c1, diffTreeTool::diff, relativeConstraints::error, f, mathSSE::Vec4< T >::get1(), i, info(), StripTopology::localPosition(), BaseTrackerRecHit::localPositionFast(), PV3DBase< T, PVType, FrameType >::mag2(), Topology::measurementPosition(), GluedGeomDet::monoDet(), VarParsing::mult, evf::evtn::offset(), position, query::result, indexGen::s2, scale_, GluedGeomDet::stereoDet(), GeomDet::surface(), GeomDetUnit::topology(), Basic3DVector< T >::v, and x.

                                                               {
  
  using  matcherDetails::StereoInfo;  
  using  mathSSE::Vec3F;
  using  mathSSE::Vec2D;
  using  mathSSE::Vec3D;
  using  mathSSE::Rot3F;
  typedef  GloballyPositioned<float> ToGlobal;
  typedef  typename GloballyPositioned<float>::ToLocal ToLocal;
  
  // hits in both mono and stero
  // match
  bool notk = trdir.mag2()<FLT_MIN;
  // FIXME we shall find a faster approximation for trdir: not useful to compute it each time for each strip
  
  // stripdet = mono
  // partnerstripdet = stereo
  const GeomDetUnit* stripdet = gluedDet->monoDet();
  const GeomDetUnit* partnerstripdet = gluedDet->stereoDet();
  const StripTopology& topol=(const StripTopology&)stripdet->topology();
  const StripTopology& partnertopol=(const StripTopology&)partnerstripdet->topology();
  
  // toGlobal is fast,  toLocal is slow
  ToGlobal const & stripDetTrans =  stripdet->surface();
  ToGlobal const & partnerStripDetTrans = partnerstripdet->surface();
  ToLocal          gluedDetInvTrans(gluedDet->surface());
  
  
  
  StereoInfo cache[std::distance(seconditer,seconditerend)];
  //iterate on stereo rechits
  // fill cache with relevant info
  int  cacheSize=0;
  for (;seconditer!=seconditerend; ++seconditer){
    
    const SiStripRecHit2D & secondHit = CollectorHelper::stereoHit(seconditer);
    
    double sigmap22 =secondHit.sigmaPitch();

    
    
    double STEREOpointX=partnertopol.measurementPosition( secondHit.localPositionFast()).x();
    MeasurementPoint STEREOpointini(STEREOpointX,-0.5);
    MeasurementPoint STEREOpointend(STEREOpointX,0.5);
    
    LocalPoint locp1 = partnertopol.localPosition(STEREOpointini);
    LocalPoint locp2 = partnertopol.localPosition(STEREOpointend);
    
    GlobalPoint globalpointini=partnerStripDetTrans.toGlobal(locp1);
    GlobalPoint globalpointend=partnerStripDetTrans.toGlobal(locp2);
    
    // position of the initial and final point of the strip in glued local coordinates
    LocalPoint positiononGluedini=gluedDetInvTrans.toLocal(globalpointini);
    LocalPoint positiononGluedend=gluedDetInvTrans.toLocal(globalpointend); 
    
   // in case of no track hypothesis assume a track from the origin through the center of the strip
    if(notk){
      LocalPoint lcenterofstrip=secondHit.localPositionFast();
      GlobalPoint gcenterofstrip= partnerStripDetTrans.toGlobal(lcenterofstrip);
      GlobalVector gtrackdirection=gcenterofstrip-GlobalPoint(0,0,0);
      trdir=gluedDetInvTrans.toLocal(gtrackdirection);
    }
  

    Vec3F offset = trdir.basicVector().v * positiononGluedini.basicVector().v.get1<2>()/trdir.basicVector().v.get1<2>();
    
    
    Vec3F ret1 = positiononGluedini.basicVector().v - offset;
    Vec3F ret2 = positiononGluedend.basicVector().v - offset;
    
    double m10=-(ret2.arr[1] - ret1.arr[1]); 
    double m11=  ret2.arr[0] - ret1.arr[0];
    
    Vec2D c1vec; c1vec.set1(m11*ret1.arr[1] + m10 * ret1.arr[0]);
    
    // store
    StereoInfo info = {c1vec,&secondHit,sigmap22,m10,m11};
    cache[cacheSize++] = info;
  }
  
  
  
  for (;monoRHiter != monoRHend; ++monoRHiter) {
    
    SiStripRecHit2D const & monoRH = CollectorHelper::monoHit(monoRHiter);
    
    // position of the initial and final point of the strip (RPHI cluster) in local strip coordinates
    double RPHIpointX = topol.measurementPosition(monoRH.localPositionFast()).x();
    MeasurementPoint RPHIpointini(RPHIpointX,-0.5);
    MeasurementPoint RPHIpointend(RPHIpointX,0.5);
    
    // position of the initial and final point of the strip in local coordinates (mono det)
    //StripPosition stripmono=StripPosition(topol.localPosition(RPHIpointini),topol.localPosition(RPHIpointend));
    LocalPoint locp1o = topol.localPosition(RPHIpointini);
    LocalPoint locp2o = topol.localPosition(RPHIpointend);
    
    
    // in case of no track hypothesis assume a track from the origin through the center of the strip
    if(notk){
      LocalPoint lcenterofstrip=monoRH.localPositionFast();
      GlobalPoint gcenterofstrip= stripDetTrans.toGlobal(lcenterofstrip);
      GlobalVector gtrackdirection=gcenterofstrip-GlobalPoint(0,0,0);
      trdir=gluedDetInvTrans.toLocal(gtrackdirection);
    }
    
    
    //project mono hit on glued det
    //StripPosition projectedstripmono=project(stripdet,gluedDet,stripmono,trackdirection);
    
    
    GlobalPoint globalpointini=stripDetTrans.toGlobal(locp1o);
    GlobalPoint globalpointend=stripDetTrans.toGlobal(locp2o);
    
    // position of the initial and final point of the strip in glued local coordinates
    LocalPoint positiononGluedini=gluedDetInvTrans.toLocal(globalpointini);
    LocalPoint positiononGluedend=gluedDetInvTrans.toLocal(globalpointend); 
    
    Vec3F offset = trdir.basicVector().v * positiononGluedini.basicVector().v.get1<2>()/trdir.basicVector().v.get1<2>();
    
    
    Vec3F projini= positiononGluedini.basicVector().v - offset;
    Vec3F projend = positiononGluedend.basicVector().v -offset;
    
    // ret1o = ret1o + (trdir * (ret1o.getSimd(2) / trdirz));
    // ret2o = ret2o + (trdir * (ret2o.getSimd(2) / trdirz));
    
    double m00 = -(projend.arr[1] - projini.arr[1]);//-(projectedstripmono.second.y()-projectedstripmono.first.y()); 
    double m01 =  (projend.arr[0] - projini.arr[0]); // (projectedstripmono.second.x()-projectedstripmono.first.x());
    double c0  =  m01*projini.arr[1] + m00*projini.arr[0];//m01*projectedstripmono.first.y()   + m00*projectedstripmono.first.x();
    
    Vec2D c0vec(c0,c0);
    Vec2D minv00(-m01, m00);
    
    //error calculation (the part that depends on mono RH only)
    double c1 = -m00;
    double s1 = -m01;
    double l1 = 1./(c1*c1+s1*s1);
    
    // FIXME: here for test...
    double sigmap12 = monoRH.sigmaPitch();


    //float code
    float fc1(c1), fs1(s1);
    Vec3F scc1(fs1, fc1, fc1, 0.f);
    Vec3F ssc1(fs1, fs1, fc1, 0.f);
    Vec3F l1vec; l1vec.set1(l1);
    const Vec3F cslsimd = scc1 * ssc1 * l1vec;
    Vec3F sigmap12simd; sigmap12simd.set1(sigmap12);
    
    for (int i=0; i!=cacheSize; ++i) {
      StereoInfo const si = cache[i];
      
      // match 
      Vec2D minv10(si.m11, -si.m10);
      Vec2D mult; mult.set1(1./(m00*si.m11 - m01*si.m10));
      Vec2D resultmatmul = mult * (minv10 * c0vec + minv00 * si.c1vec);
      
      Local2DPoint position(resultmatmul.arr[0], resultmatmul.arr[1]);
      
      // LocalError tempError (100,0,100);
      if (!((gluedDet->surface()).bounds().inside(position,10.f*scale_))) continue;                                                       
      
      double c2 = -si.m10;
      double s2 = -si.m11;
      double l2 = 1./(c2*c2+s2*s2);
      
      double diff=(c1*s2-c2*s1);
      double invdet2 = 1./(diff*diff*l1*l2);
      
      float fc2(c2), fs2(s2), fid2(invdet2);    
      Vec3F invdet2simd(fid2, -fid2, fid2, 0.f);
      Vec3F ccssimd(fs2, fc2, fc2, 0.f);
      Vec3F csssimd(fs2, fs2, fc2, 0.f);
      Vec3F l2simd; l2simd.set1(l2);
      Vec3F sigmap22simd; sigmap22simd.set1(si.sigmap22);
      Vec3F result = invdet2simd * (sigmap22simd * cslsimd + sigmap12simd * ccssimd * csssimd * l2simd);
      
      
      LocalError error(result.arr[0], result.arr[1], result.arr[2]);
      
      
      if((gluedDet->surface()).bounds().inside(position,error,scale_)){ //if it is inside the gluedet bonds
    
    //Change NSigmaInside in the configuration file to accept more hits
    //...and add it to the Rechit collection 
    
    collectorHelper.collector()(SiStripMatchedRecHit2D(LocalPoint(position), error,
                               *gluedDet,&monoRH,si.secondHit));
      }
      
    } // loop on cache info
    
    collectorHelper.closure(monoRHiter);
  } // loop on mono hit
  
}

std::unique_ptr< SiStripMatchedRecHit2D > SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		const SiStripRecHit2D *	stereoRH,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection,
		bool	force = false
	)		const

Definition at line 269 of file SiStripRecHitMatcher.cc.

References trackerHits::c, alignmentValidation::c1, diffTreeTool::diff, relativeConstraints::error, f, StripTopology::localPosition(), BaseTrackerRecHit::localPosition(), BaseTrackerRecHit::localPositionError(), BaseTrackerRecHit::localPositionFast(), m, PV3DBase< T, PVType, FrameType >::mag2(), Topology::measurementPosition(), GluedGeomDet::monoDet(), position, project(), indexGen::s2, scale_, sigmaPitch(), GluedGeomDet::stereoDet(), GeomDet::surface(), toLocal(), GeomDetUnit::topology(), x, and create_public_lumi_plots::xy.

Referenced by TkGluedMeasurementDet::collectRecHits(), match(), and TkClonerImpl::operator()().

                                                              {
  // stripdet = mono
  // partnerstripdet = stereo
  const GeomDetUnit* stripdet = gluedDet->monoDet();
  const GeomDetUnit* partnerstripdet = gluedDet->stereoDet();
  const StripTopology& topol=(const StripTopology&)stripdet->topology();

  // position of the initial and final point of the strip (RPHI cluster) in local strip coordinates
  auto RPHIpointX = topol.measurementPosition(monoRH->localPositionFast()).x();
  MeasurementPoint RPHIpointini(RPHIpointX,-0.5f);
  MeasurementPoint RPHIpointend(RPHIpointX,0.5f);

  // position of the initial and final point of the strip in local coordinates (mono det)
  StripPosition stripmono=StripPosition(topol.localPosition(RPHIpointini),topol.localPosition(RPHIpointend));

  if(trackdirection.mag2()<float(FLT_MIN)){// in case of no track hypothesis assume a track from the origin through the center of the strip
    LocalPoint lcenterofstrip=monoRH->localPositionFast();
    GlobalPoint gcenterofstrip=(stripdet->surface()).toGlobal(lcenterofstrip);
    GlobalVector gtrackdirection=gcenterofstrip-GlobalPoint(0,0,0);
    trackdirection=(gluedDet->surface()).toLocal(gtrackdirection);
  }

  //project mono hit on glued det
  StripPosition projectedstripmono=project(stripdet,gluedDet,stripmono,trackdirection);
  const StripTopology& partnertopol=(const StripTopology&)partnerstripdet->topology();

  double m00 = -(projectedstripmono.second.y()-projectedstripmono.first.y()); 
  double m01 =  (projectedstripmono.second.x()-projectedstripmono.first.x());
  double c0  =  m01*projectedstripmono.first.y()   + m00*projectedstripmono.first.x();
 
  //error calculation (the part that depends on mono RH only)
  //  LocalVector  RPHIpositiononGluedendvector=projectedstripmono.second-projectedstripmono.first;
  /*
  double l1 = 1./RPHIpositiononGluedendvector.perp2();
  double c1 = RPHIpositiononGluedendvector.y();
  double s1 =-RPHIpositiononGluedendvector.x();
  */
  double c1 = -m00;
  double s1 = -m01;
  double l1 = 1./(c1*c1+s1*s1);


  float sigmap12 = sigmaPitch(monoRH->localPosition(), monoRH->localPositionError(),topol);
  // auto sigmap12 = monoRH->sigmaPitch();
  // assert(sigmap12>=0);




    // position of the initial and final point of the strip (STEREO cluster)
  auto STEREOpointX=partnertopol.measurementPosition(stereoRH->localPositionFast()).x();
  MeasurementPoint STEREOpointini(STEREOpointX,-0.5f);
  MeasurementPoint STEREOpointend(STEREOpointX,0.5f);
  
  // position of the initial and final point of the strip in local coordinates (stereo det)
  StripPosition stripstereo(partnertopol.localPosition(STEREOpointini),partnertopol.localPosition(STEREOpointend));
  
  //project stereo hit on glued det
  StripPosition projectedstripstereo=project(partnerstripdet,gluedDet,stripstereo,trackdirection);
  
  
  double m10=-(projectedstripstereo.second.y()-projectedstripstereo.first.y()); 
  double m11=(projectedstripstereo.second.x()-projectedstripstereo.first.x());
  
  //perform the matching
  //(x2-x1)(y-y1)=(y2-y1)(x-x1)
  AlgebraicMatrix22 m; AlgebraicVector2 c;
  m(0,0)=m00; 
  m(0,1)=m01;
  m(1,0)=m10;
  m(1,1)=m11;
  c(0)=c0;
  c(1)=m11*projectedstripstereo.first.y()+m10*projectedstripstereo.first.x();
  m.Invert(); 
  AlgebraicVector2 solution = m * c;
  Local2DPoint position(solution(0),solution(1));
  

  if ((!force) &&  (!((gluedDet->surface()).bounds().inside(position,10.f*scale_))) ) return std::unique_ptr<SiStripMatchedRecHit2D>(nullptr);

  double c2 = -m10;
  double s2 = -m11;
  double l2 = 1./(c2*c2+s2*s2);
  
  
  float sigmap22 = sigmaPitch(stereoRH->localPosition(),stereoRH->localPositionError(),partnertopol);
  // auto sigmap22 = stereoRH->sigmaPitch();
  // assert (sigmap22>0);

  double diff=(c1*s2-c2*s1);
  double invdet2=1/(diff*diff*l1*l2);
  float xx= invdet2*(sigmap12*s2*s2*l2+sigmap22*s1*s1*l1);
  float xy=-invdet2*(sigmap12*c2*s2*l2+sigmap22*c1*s1*l1);
  float yy= invdet2*(sigmap12*c2*c2*l2+sigmap22*c1*c1*l1);
  LocalError error(xx,xy,yy);
 

  //if it is inside the gluedet bonds
  //Change NSigmaInside in the configuration file to accept more hits
  if(force || (gluedDet->surface()).bounds().inside(position,error,scale_)) 
    return std::unique_ptr<SiStripMatchedRecHit2D> (new SiStripMatchedRecHit2D(LocalPoint(position), error, *gluedDet, monoRH,stereoRH));
  return std::unique_ptr<SiStripMatchedRecHit2D>(nullptr);
}

void SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		RecHitIterator	begin,
		RecHitIterator	end,
		CollectorMatched &	collector,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection
	)		const

Definition at line 83 of file SiStripRecHitMatcher.cc.

References end, i, and match().

                                                   {
  
  // is this really needed now????
  SimpleHitCollection stereoHits;
  stereoHits.reserve(end-begin);
  for (RecHitIterator i=begin; i != end; ++i) 
    stereoHits.push_back( &(*i)); // convert to simple pointer
  
  return match( monoRH,
        stereoHits.begin(), stereoHits.end(),
        collector,
        gluedDet,trackdirection);
}

void SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		SimpleHitIterator	begin,
		SimpleHitIterator	end,
		CollectorMatched &	collector,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection
	)		const

Definition at line 68 of file SiStripRecHitMatcher.cc.

References match(), and query::result.

                                                   {

  Collector result(boost::bind(pb2,boost::ref(collector),_1));
  match(monoRH,begin,end,result,gluedDet,trackdirection);
  
}

void SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		SimpleHitIterator	begin,
		SimpleHitIterator	end,
		edm::OwnVector< SiStripMatchedRecHit2D > &	collector,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection
	)		const

Definition at line 42 of file SiStripRecHitMatcher.cc.

References match(), AlCaHLTBitMon_ParallelJobs::p, edm::OwnVector< T, P >::push_back(), and query::result.

                                                   {

  std::vector<SiStripMatchedRecHit2D*> result;
  result.reserve(end-begin);
  match(monoRH,begin,end,result,gluedDet,trackdirection);
  for (std::vector<SiStripMatchedRecHit2D*>::iterator p=result.begin(); p!=result.end();
       p++) collector.push_back(*p);
}

void SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		SimpleHitIterator	begin,
		SimpleHitIterator	end,
		std::vector< SiStripMatchedRecHit2D * > &	collector,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection
	)		const

Definition at line 57 of file SiStripRecHitMatcher.cc.

References SiStripMatchedRecHit2D::clone(), match(), and query::result.

                                                   {
  Collector result(boost::bind(&pb1,boost::ref(collector),
                 boost::bind(&SiStripMatchedRecHit2D::clone,_1)));
  match(monoRH,begin,end,result,gluedDet,trackdirection);
}

void SiStripRecHitMatcher::match	(	const SiStripRecHit2D *	monoRH,
		SimpleHitIterator	begin,
		SimpleHitIterator	end,
		Collector &	collector,
		const GluedGeomDet *	gluedDet,
		LocalVector	trackdirection
	)		const

the actual implementation

Definition at line 105 of file SiStripRecHitMatcher.cc.

References trackerHits::c, alignmentValidation::c1, diffTreeTool::diff, end, relativeConstraints::error, StripTopology::localPosition(), BaseTrackerRecHit::localPosition(), BaseTrackerRecHit::localPositionError(), BaseTrackerRecHit::localPositionFast(), m, PV3DBase< T, PVType, FrameType >::mag2(), Topology::measurementPosition(), GluedGeomDet::monoDet(), position, project(), indexGen::s2, scale_, sigmaPitch(), GluedGeomDet::stereoDet(), GeomDet::surface(), toLocal(), GeomDetUnit::topology(), x, and create_public_lumi_plots::xy.

                                                   {
  // stripdet = mono
  // partnerstripdet = stereo
  const GeomDetUnit* stripdet = gluedDet->monoDet();
  const GeomDetUnit* partnerstripdet = gluedDet->stereoDet();
  const StripTopology& topol=(const StripTopology&)stripdet->topology();

  // position of the initial and final point of the strip (RPHI cluster) in local strip coordinates
  double RPHIpointX = topol.measurementPosition(monoRH->localPositionFast()).x();
  MeasurementPoint RPHIpointini(RPHIpointX,-0.5);
  MeasurementPoint RPHIpointend(RPHIpointX,0.5);

  // position of the initial and final point of the strip in local coordinates (mono det)
  StripPosition stripmono=StripPosition(topol.localPosition(RPHIpointini),topol.localPosition(RPHIpointend));

  if(trackdirection.mag2()<FLT_MIN){// in case of no track hypothesis assume a track from the origin through the center of the strip
    LocalPoint lcenterofstrip=monoRH->localPositionFast();
    GlobalPoint gcenterofstrip=(stripdet->surface()).toGlobal(lcenterofstrip);
    GlobalVector gtrackdirection=gcenterofstrip-GlobalPoint(0,0,0);
    trackdirection=(gluedDet->surface()).toLocal(gtrackdirection);
  }

  //project mono hit on glued det
  StripPosition projectedstripmono=project(stripdet,gluedDet,stripmono,trackdirection);
  const StripTopology& partnertopol=(const StripTopology&)partnerstripdet->topology();

  double m00 = -(projectedstripmono.second.y()-projectedstripmono.first.y()); 
  double m01 =  (projectedstripmono.second.x()-projectedstripmono.first.x());
  double c0  =  m01*projectedstripmono.first.y()   + m00*projectedstripmono.first.x();
 
  //error calculation (the part that depends on mono RH only)
  //  LocalVector  RPHIpositiononGluedendvector=projectedstripmono.second-projectedstripmono.first;
  /*
  double l1 = 1./RPHIpositiononGluedendvector.perp2();
  double c1 = RPHIpositiononGluedendvector.y();
  double s1 =-RPHIpositiononGluedendvector.x();
  */
  double c1 = -m00;
  double s1 = -m01;
  double l1 = 1./(c1*c1+s1*s1);

 
  float sigmap12 = sigmaPitch(monoRH->localPosition(), monoRH->localPositionError(),topol);
  // auto sigmap12 = monoRH->sigmaPitch();
  // assert(sigmap12>=0);


  SimpleHitIterator seconditer;  

  for(seconditer=begin;seconditer!=end;++seconditer){//iterate on stereo rechits

    // position of the initial and final point of the strip (STEREO cluster)
    double STEREOpointX=partnertopol.measurementPosition((*seconditer)->localPositionFast()).x();
    MeasurementPoint STEREOpointini(STEREOpointX,-0.5);
    MeasurementPoint STEREOpointend(STEREOpointX,0.5);

    // position of the initial and final point of the strip in local coordinates (stereo det)
    StripPosition stripstereo(partnertopol.localPosition(STEREOpointini),partnertopol.localPosition(STEREOpointend));
 
    //project stereo hit on glued det
    StripPosition projectedstripstereo=project(partnerstripdet,gluedDet,stripstereo,trackdirection);

 
    double m10=-(projectedstripstereo.second.y()-projectedstripstereo.first.y()); 
    double m11=(projectedstripstereo.second.x()-projectedstripstereo.first.x());

   //perform the matching
   //(x2-x1)(y-y1)=(y2-y1)(x-x1)
    AlgebraicMatrix22 m; AlgebraicVector2 c; // FIXME understand why moving this initializer out of the loop changes the output!
    m(0,0)=m00; 
    m(0,1)=m01;
    m(1,0)=m10;
    m(1,1)=m11;
    c(0)=c0;
    c(1)=m11*projectedstripstereo.first.y()+m10*projectedstripstereo.first.x();
    m.Invert(); 
    AlgebraicVector2 solution = m * c;
    LocalPoint position(solution(0),solution(1));

    /*
    {
      double m00 = -(projectedstripmono.second.y()-projectedstripmono.first.y()); 
      double m01 =  (projectedstripmono.second.x()-projectedstripmono.first.x());
      double m10 = -(projectedstripstereo.second.y()-projectedstripstereo.first.y()); 
      double m11 =  (projectedstripstereo.second.x()-projectedstripstereo.first.x());
      double c0  =  m01*projectedstripmono.first.y()   + m00*projectedstripmono.first.x();
      double c1  =  m11*projectedstripstereo.first.y() + m10*projectedstripstereo.first.x();
      
      double invDet = 1./(m00*m11-m10*m01);
    }
    */

    //
    // temporary fix by tommaso
    //


    LocalError tempError (100,0,100);
    if (!((gluedDet->surface()).bounds().inside(position,tempError,scale_))) continue;                                                       

    // then calculate the error
    /*
    LocalVector  stereopositiononGluedendvector=projectedstripstereo.second-projectedstripstereo.first;
    double l2 = 1./stereopositiononGluedendvector.perp2();
    double c2 = stereopositiononGluedendvector.y(); 
    double s2 =-stereopositiononGluedendvector.x();
    */

    double c2 = -m10;
    double s2 = -m11;
    double l2 = 1./(c2*c2+s2*s2);

   float sigmap22 = sigmaPitch((*seconditer)->localPosition(),(*seconditer)->localPositionError(),partnertopol);
   // auto sigmap22 = (*seconditer)->sigmaPitch();
    // assert(sigmap22>=0);

    double diff=(c1*s2-c2*s1);
    double invdet2=1/(diff*diff*l1*l2);
    float xx= invdet2*(sigmap12*s2*s2*l2+sigmap22*s1*s1*l1);
    float xy=-invdet2*(sigmap12*c2*s2*l2+sigmap22*c1*s1*l1);
    float yy= invdet2*(sigmap12*c2*c2*l2+sigmap22*c1*c1*l1);
    LocalError error(xx,xy,yy);

    if((gluedDet->surface()).bounds().inside(position,error,scale_)){ //if it is inside the gluedet bonds
      //Change NSigmaInside in the configuration file to accept more hits
      //...and add it to the Rechit collection 

      const SiStripRecHit2D* secondHit = *seconditer;
      collector(SiStripMatchedRecHit2D(position, error,*gluedDet,
                       monoRH,secondHit));
    }
  }
}

bool SiStripRecHitMatcher::preFilter ( ) const

inline

Definition at line 44 of file SiStripRecHitMatcher.h.

References preFilter_.

{ return preFilter_;}  

SiStripRecHitMatcher::StripPosition SiStripRecHitMatcher::project	(	const GeomDetUnit *	det,
		const GluedGeomDet *	glueddet,
		StripPosition	strip,
		LocalVector	trackdirection
	)		const

Definition at line 245 of file SiStripRecHitMatcher.cc.

References pileupReCalc_HLTpaths::scale, GeomDet::surface(), toLocal(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by match().

                                                                        {

  GlobalPoint globalpointini=(det->surface()).toGlobal(strip.first);
  GlobalPoint globalpointend=(det->surface()).toGlobal(strip.second);

  // position of the initial and final point of the strip in glued local coordinates
  LocalPoint positiononGluedini=(glueddet->surface()).toLocal(globalpointini);
  LocalPoint positiononGluedend=(glueddet->surface()).toLocal(globalpointend);

  //correct the position with the track direction

  float scale=-positiononGluedini.z()/trackdirection.z();

  LocalPoint projpositiononGluedini= positiononGluedini + scale*trackdirection;
  LocalPoint projpositiononGluedend= positiononGluedend + scale*trackdirection;

  return StripPosition(projpositiononGluedini,projpositiononGluedend);
}

static float SiStripRecHitMatcher::sigmaPitch ( LocalPoint const &  pos, LocalError const &  err, const StripTopology &  topol  )

inlinestatic

Definition at line 48 of file SiStripRecHitMatcher.h.

References relativeConstraints::error, StripTopology::localPitch(), Topology::measurementError(), and MeasurementError::uu().

Referenced by match().

                                       {
    MeasurementError error = topol.measurementError(pos,err);
    auto pitch=topol.localPitch(pos);
    return error.uu()*pitch*pitch;
  }

Member Data Documentation

bool SiStripRecHitMatcher::preFilter_ =false

Definition at line 124 of file SiStripRecHitMatcher.h.

Referenced by preFilter().

float SiStripRecHitMatcher::scale_

Definition at line 123 of file SiStripRecHitMatcher.h.

Referenced by doubleMatch(), and match().