Acts/Seeding/SPForSeed.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2018 CERN for the benefit of the Acts project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
0008
0009 ///////////////////////////////////////////////////////////////////
0010 // SPForSeed.hpp Acts project
0011 ///////////////////////////////////////////////////////////////////
0012
0013 #pragma once
0014 #include <cmath>
0015
0016 // COLLECTION OF MAGIC NUMBERS IN HERE:
0017 //
0018 //
0019 // m_q        = 100000.;
0020 //
0021 // float cov = wid*wid*.08333;
0022 //
0023 // Pixel Case
0024 //    if(de->isBarrel()) {m_covz = 9.*cov; m_covr = .06;}
0025 //    else               {m_covr = 9.*cov; m_covz = .06;}
0026 //
0027 // SCT Case
0028 //    if(de->isBarrel()) {m_covz = 8.*f22; m_covr = .1;}
0029 //    else               {m_covr = 8.*f22; m_covz = .1;}
0030
0031 namespace Acts::Legacy {
0032
0033 template <typename SpacePoint>
0034 class SPForSeed {
0035   /////////////////////////////////////////////////////////////////////////////////
0036   // Public methods:
0037   /////////////////////////////////////////////////////////////////////////////////
0038
0039  public:
0040   SPForSeed();
0041   SPForSeed(SpacePoint* const& /*sp*/, const float* /*r*/);
0042   SPForSeed(SpacePoint* const& /*sp*/, const float* /*r*/, const float* /*sc*/);
0043   SPForSeed(const SPForSeed& /*sp*/);
0044   virtual ~SPForSeed();
0045   SPForSeed& operator=(const SPForSeed& /*sp*/);
0046
0047   void set(SpacePoint* const& /*sp*/, const float* /*r*/);
0048   void set(SpacePoint* const& /*sp*/, const float* /*r*/, const float* /*sc*/);
0049   void setQuality(float /*q*/);
0050   void setParam(const float& /*p*/);
0051
0052   const SpacePoint* spacepoint = nullptr;
0053   const float& x() const { return m_x; }
0054   const float& y() const { return m_y; }
0055   const float& z() const { return m_z; }
0056   const float& radius() const { return m_r; }
0057   float phi() const { return atan2(m_y, m_x); }
0058   const float& covr() const { return m_covr; }
0059   const float& covz() const { return m_covz; }
0060   const float& param() const { return m_param; }
0061   const float& quality() const { return m_q; }
0062
0063   const int& surface() const { return m_surface; }
0064
0065  protected:
0066   float m_x = 0;     // x-coordinate in beam system coordinates
0067   float m_y = 0;     // y-coordinate in beam system coordinates
0068   float m_z = 0;     // z-coordinate in beam system coordinetes
0069   float m_r = 0;     // radius       in beam system coordinates
0070   float m_covr = 0;  //
0071   float m_covz = 0;  //
0072   float m_param = 0;
0073   float m_q = 0;
0074
0075   int m_surface = 0;  // surface identifier
0076 };
0077
0078 /////////////////////////////////////////////////////////////////////////////////
0079 // Inline methods
0080 /////////////////////////////////////////////////////////////////////////////////
0081
0082 template <typename SpacePoint>
0083 inline SPForSeed<SpacePoint>::SPForSeed() {
0084   spacepoint = 0;
0085   m_x = 0.;
0086   m_y = 0.;
0087   m_z = 0.;
0088   m_r = 0.;
0089   m_covr = 0.;
0090   m_covz = 0.;
0091   m_param = 0.;
0092   m_q = 0.;
0093 }
0094
0095 template <typename SpacePoint>
0096 inline SPForSeed<SpacePoint>& SPForSeed<SpacePoint>::operator=(
0097     const SPForSeed<SpacePoint>& sp) {
0098   if (&sp != this) {
0099     spacepoint = sp.spacepoint;
0100     m_x = sp.m_x;
0101     m_y = sp.m_y;
0102     m_z = sp.m_z;
0103     m_r = sp.m_r;
0104     m_covr = sp.m_covr;
0105     m_covz = sp.m_covz;
0106     m_q = sp.m_q;
0107   }
0108   return (*this);
0109 }
0110
0111 template <typename SpacePoint>
0112 inline SPForSeed<SpacePoint>::SPForSeed(SpacePoint* const& sp, const float* r) {
0113   set(sp, r);
0114   m_param = 0.;
0115 }
0116
0117 template <typename SpacePoint>
0118 inline SPForSeed<SpacePoint>::SPForSeed(SpacePoint* const& sp, const float* r,
0119                                         const float* sc) {
0120   set(sp, r, sc);
0121   m_param = 0.;
0122 }
0123
0124 /////////////////////////////////////////////////////////////////////////////////
0125 // Copy constructor
0126 /////////////////////////////////////////////////////////////////////////////////
0127
0128 template <typename SpacePoint>
0129 inline SPForSeed<SpacePoint>::SPForSeed(const SPForSeed& sp) {
0130   *this = sp;
0131 }
0132
0133 /////////////////////////////////////////////////////////////////////////////////
0134 // Destructor
0135 /////////////////////////////////////////////////////////////////////////////////
0136
0137 template <typename SpacePoint>
0138 inline SPForSeed<SpacePoint>::~SPForSeed() = default;
0139
0140 /////////////////////////////////////////////////////////////////////////////////
0141 // Set
0142 /////////////////////////////////////////////////////////////////////////////////
0143
0144 template <typename SpacePoint>
0145 inline void SPForSeed<SpacePoint>::set(SpacePoint* const& sp, const float* r) {
0146   spacepoint = sp;
0147   m_x = r[0];
0148   m_y = r[1];
0149   m_z = r[2];
0150   m_r = std::hypot(m_x, m_y);
0151   m_surface = sp->surface;
0152   m_q = 100000.;
0153
0154   if (!sp->clusterList().second) {
0155     m_covr = sp->covr * 9.;
0156     m_covz = sp->covz * 9.;
0157     if (m_covr < 0.06) {
0158       m_covr = 0.06;
0159     }
0160     if (m_covz < 0.06) {
0161       m_covz = 0.06;
0162     }
0163   } else {
0164     m_covr = sp->covr * 8.;
0165     m_covz = sp->covz * 8.;
0166     if (m_covr < 0.1) {
0167       m_covr = 0.1;
0168     }
0169     if (m_covz < 0.1) {
0170       m_covz = 0.1;
0171     }
0172   }
0173 }
0174
0175 /////////////////////////////////////////////////////////////////////////////////
0176 // Set with error correction
0177 // sc[0] - barrel pixels error correction
0178 // sc[1] - endcap pixels
0179 // sc[2] - barrel sct
0180 // sc[3] - endcap sct
0181 /////////////////////////////////////////////////////////////////////////////////
0182
0183 template <typename SpacePoint>
0184 inline void SPForSeed<SpacePoint>::set(SpacePoint* const& sp, const float* r,
0185                                        const float* sc) {
0186   spacepoint = sp;
0187   m_x = r[0];
0188   m_y = r[1];
0189   m_z = r[2];
0190   m_r = std::hypot(m_x, m_y);
0191   m_q = 100000.;
0192   if (!sp->clusterList().second) {
0193     m_covr = sp->covr * 9. * sc[0];
0194     m_covz = sp->covz * 9. * sc[1];
0195     if (m_covr < 0.06) {
0196       m_covr = 0.06;
0197     }
0198     if (m_covz < 0.06) {
0199       m_covz = 0.06;
0200     }
0201   } else {
0202     m_covr = sp->covr * 8. * sc[2];
0203     m_covz = sp->covz * 8. * sc[3];
0204     if (m_covr < 0.1) {
0205       m_covr = 0.1;
0206     }
0207     if (m_covz < 0.1) {
0208       m_covz = 0.1;
0209     }
0210   }
0211
0212   // old code:
0213   //      const InDet::SiCluster*           c  = static_cast<const
0214   //      InDet::SiCluster*>(sp->clusterList().first);
0215   //      if( de->isPixel() ) {
0216   //
0217   //    const Amg::MatrixX& v =  sp->localCovariance();
0218   //    //ATTENTION: v(1,1) contains error for z in barrel, error for r in
0219   //    endcaps
0220   //    float f22 = float(v(1,1));
0221   //    //ATTENTION: Variable Z contains width of R in the endcaps.
0222   //    float wid = float(c->width().z());
0223   //    float cov = wid*wid*.08333; if(cov < f22) cov = f22;
0224   //    // Set error of low uncertainty dimension (i.e. r for barrel, z for
0225   //    EC)
0226   //    to "small"
0227   //    if(sp->isBarrel()) {m_covz = 9.*cov*sc[0]; m_covr = .06;}
0228   //    else               {m_covr = 9.*cov*sc[1]; m_covz = .06;}
0229   //      }
0230   //      else                {
0231   //
0232   //    const Amg::MatrixX& v = sp->localCovariance();
0233   //    float f22 = float(v(1,1));
0234   //    if(sp->isBarrel()) {m_covz = 8.*f22*sc[2]; m_covr = .1;}
0235   //    else               {m_covr = 8.*f22*sc[3]; m_covz = .1;}
0236   //      }
0237 }
0238 template <typename SpacePoint>
0239 inline void SPForSeed<SpacePoint>::setParam(const float& p) {
0240   m_param = p;
0241 }
0242 template <typename SpacePoint>
0243 inline void SPForSeed<SpacePoint>::setQuality(float q) {
0244   if (q <= m_q) {
0245     m_q = q;
0246   }
0247 }
0248
0249 }  // namespace Acts::Legacy