MeasurementDet/plugins/doubleMatch.icc

0001
0002
0003 namespace {
0004
0005   template <typename Collector>
0006   struct CollectorHelper {
0007     Collector& m_collector;
0008     GlobalVector const& glbDir;
0009
0010     CollectorHelper(Collector& i_collector, GlobalVector const& i_glbDir)
0011         : m_collector(i_collector), glbDir(i_glbDir) {}
0012
0013     inline static SiStripRecHit2D const& monoHit(TkGluedMeasurementDet::RecHitContainer::const_iterator monoHit) {
0014       return *reinterpret_cast<const SiStripRecHit2D*>((**monoHit).hit());
0015     }
0016
0017     inline static SiStripRecHit2D const& monoHit(std::vector<SiStripRecHit2D>::const_iterator iter) { return *iter; }
0018
0019     inline static SiStripRecHit2D const& stereoHit(std::vector<SiStripRecHit2D>::const_iterator iter) { return *iter; }
0020
0021     inline static SiStripRecHit2D const& stereoHit(TkGluedMeasurementDet::RecHitContainer::const_iterator hit) {
0022       return *reinterpret_cast<const SiStripRecHit2D*>((**hit).hit());
0023     }
0024
0025     typename Collector::Collector& collector() { return m_collector.collector(); }
0026
0027     inline void closure(TkGluedMeasurementDet::RecHitContainer::const_iterator monoHit) {
0028       if (m_collector.hasNewMatchedHits()) {
0029         m_collector.clearNewMatchedHitsFlag();
0030       } else {
0031         m_collector.addProjected(**monoHit, glbDir);
0032       }
0033     }
0034
0035     inline void closure(std::vector<SiStripRecHit2D>::const_iterator monoHit) {
0036       if (m_collector.hasNewMatchedHits()) {
0037         m_collector.clearNewMatchedHitsFlag();
0038       } else {
0039         m_collector.addProjected(*monoHit, glbDir);
0040       }
0041     }
0042   };
0043
0044 }  // namespace
0045
0046 #include "RecHitPropagator.h"
0047 #include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
0048 #include "DataFormats/GeometrySurface/interface/LocalError.h"
0049
0050 namespace {
0051   inline void print(const char* where, const TrajectoryStateOnSurface& t1, const TrajectoryStateOnSurface& t2) {
0052     std::cout << where << std::endl;
0053     std::cout << t1.localParameters().vector() << std::endl;
0054     std::cout << t1.localError().positionError() << std::endl;
0055     std::cout << t2.localParameters().vector() << std::endl;
0056     std::cout << t2.localError().positionError() << std::endl;
0057   }
0058 }  // namespace
0059
0060 template <typename Collector>
0061 void TkGluedMeasurementDet::doubleMatch(const TrajectoryStateOnSurface& ts,
0062                                         const MeasurementTrackerEvent& data,
0063                                         Collector& collector) const {
0064   GlobalVector glbDir = (ts.isValid() ? ts.globalMomentum() : position() - GlobalPoint(0, 0, 0));
0065
0066   //  static SiStripRecHitMatcher::SimpleHitCollection vsStereoHits;
0067   // vsStereoHits.resize(simpleSteroHitsByValue.size());
0068   //std::transform(simpleSteroHitsByValue.begin(), simpleSteroHitsByValue.end(), vsStereoHits.begin(), take_address());
0069
0070   std::vector<SiStripRecHit2D> monoHits;
0071   std::vector<SiStripRecHit2D> stereoHits;
0072
0073   auto mf = monoHits.size();
0074   auto sf = stereoHits.size();
0075
0076   bool emptyMono = false;
0077   bool emptyStereo = false;
0078
0079   // FIXME  clean this and optimize the rest of the code once understood and validated
0080   if (true) {  // collector.filter()) {
0081     emptyMono = theMonoDet->empty(data);
0082     if LIKELY (!emptyMono) {
0083       // mono does require "projection" for precise estimate
0084       TrajectoryStateOnSurface mts = fastProp(ts, geomDet().surface(), theMonoDet->geomDet().surface());
0085       theMonoDet->simpleRecHits(mts, collector.estimator(), data, monoHits);
0086     }
0087     // print("mono", mts,ts);
0088     mf = monoHits.size();
0089   } else {
0090     theMonoDet->simpleRecHits(ts, data, monoHits);
0091     emptyMono = monoHits.empty();
0092   }
0093
0094   // stereo requires "projection" for precision and change in coordinates
0095   if (collector.filter()) {
0096     emptyStereo = theStereoDet->empty(data);
0097     if LIKELY (!emptyStereo) {
0098       TrajectoryStateOnSurface pts = fastProp(ts, geomDet().surface(), theStereoDet->geomDet().surface());
0099       theStereoDet->simpleRecHits(pts, collector.estimator(), data, stereoHits);
0100       // print("stereo", pts,ts);
0101     }
0102     sf = stereoHits.size();
0103   } else {
0104     theStereoDet->simpleRecHits(ts, data, stereoHits);
0105     emptyStereo = stereoHits.empty();
0106   }
0107
0108   if (collector.filter()) {
0109     auto mh = monoHits.size();
0110     auto sh = stereoHits.size();
0111     stat(mh, sh, mf, sf);
0112   }
0113
0114   if UNLIKELY (emptyMono & emptyStereo)
0115     return;
0116
0117   if UNLIKELY (emptyStereo) {
0118     // make mono TTRHs and project them
0119     projectOnGluedDet(collector, monoHits, glbDir);
0120     return;
0121   }
0122
0123   if UNLIKELY (emptyMono) {
0124     // make stereo TTRHs and project them
0125     projectOnGluedDet(collector, stereoHits, glbDir);
0126     return;
0127   }
0128
0129   if ((!monoHits.empty()) && (!stereoHits.empty())) {
0130     const GluedGeomDet* gluedDet = &specificGeomDet();
0131     LocalVector trdir = (ts.isValid() ? ts.localDirection() : surface().toLocal(position() - GlobalPoint(0, 0, 0)));
0132
0133     CollectorHelper<Collector> chelper(collector, glbDir);
0134     theMatcher->doubleMatch(
0135         monoHits.begin(), monoHits.end(), stereoHits.begin(), stereoHits.end(), gluedDet, trdir, chelper);
0136   }
0137
0138   if (ts.globalMomentum().perp2() > collector.estimator().minPt2ForHitRecoveryInGluedDet()) {
0139     // if no match found try add mon than try to add stereo...
0140     if (0 == collector.size())
0141       projectOnGluedDet(collector, monoHits, glbDir);
0142     if (0 == collector.size())
0143       projectOnGluedDet(collector, stereoHits, glbDir);
0144   }
0145   /*
0146   // recover hits outside
0147   if ( collector.filter() && 0==collector.size())  {
0148     auto inoutM = reinterpret_cast<RectangularPlaneBounds const&>(theMonoDet->surface().bounds()).inout(ts.localPosition(),
0149                                                     ts.localError().positionError() ,3.f);
0150     auto inoutS = reinterpret_cast<RectangularPlaneBounds const&>(theStereoDet->surface().bounds()).inout(pts.localPosition(),
0151                                                       pts.localError().positionError() ,3.f);
0152     if (inoutM.first&&inoutS.second)
0153       projectOnGluedDet( collector, monoHits, glbDir);
0154     if (inoutM.second&&inoutS.first)
0155       projectOnGluedDet( collector, stereoHits, glbDir);
0156   }
0157   */
0158
0159   if (collector.filter()) {
0160     stat.match(collector.size());
0161   }
0162 }