TrackerDigiSimLink/interface/PixelSimHitExtraInfoLite.h

0001 #ifndef PixelSimHitExtraInfoLite_h
0002 #define PixelSimHitExtraInfoLite_h
0003
0004 #include "DataFormats/GeometryVector/interface/LocalPoint.h"
0005 #include "DataFormats/Math/interface/libminifloat.h"
0006 #include <vector>
0007 #include <cstdint>
0008
0009 class PixelSimHitExtraInfoLite {
0010 public:
0011   PixelSimHitExtraInfoLite(size_t Hindex, const Local3DPoint& entryP, const Local3DPoint& exitP, unsigned int ch) {
0012     index_ = Hindex;
0013     //    theEntryPoint_ = entryP;
0014     //    theExitPoint_ = exitP;
0015     theEntryPointX_ = MiniFloatConverter::float32to16(entryP.x());
0016     theEntryPointY_ = MiniFloatConverter::float32to16(entryP.y());
0017     theEntryPointZ_ = MiniFloatConverter::float32to16(entryP.z());
0018     theExitPointX_ = MiniFloatConverter::float32to16(exitP.x());
0019     theExitPointY_ = MiniFloatConverter::float32to16(exitP.y());
0020     theExitPointZ_ = MiniFloatConverter::float32to16(exitP.z());
0021     chan_.push_back(ch);
0022   };
0023   PixelSimHitExtraInfoLite() = default;
0024   ~PixelSimHitExtraInfoLite() = default;
0025   size_t hitIndex() const { return index_; };
0026   const uint16_t& entryPointX() const { return theEntryPointX_; }
0027   const uint16_t& entryPointY() const { return theEntryPointY_; }
0028   const uint16_t& entryPointZ() const { return theEntryPointZ_; }
0029   const uint16_t& exitPointX() const { return theExitPointX_; }
0030   const uint16_t& exitPointY() const { return theExitPointY_; }
0031   const uint16_t& exitPointZ() const { return theExitPointZ_; }
0032
0033   Local3DPoint& entryPoint() {
0034     UncompressedEntryPoint_ = Local3DPoint(MiniFloatConverter::float16to32(theEntryPointX_),
0035                                            MiniFloatConverter::float16to32(theEntryPointY_),
0036                                            MiniFloatConverter::float16to32(theEntryPointZ_));
0037     return UncompressedEntryPoint_;
0038   }
0039   Local3DPoint& exitPoint() {
0040     UncompressedExitPoint_ = Local3DPoint(MiniFloatConverter::float16to32(theExitPointX_),
0041                                           MiniFloatConverter::float16to32(theExitPointY_),
0042                                           MiniFloatConverter::float16to32(theExitPointZ_));
0043     return UncompressedExitPoint_;
0044   }
0045
0046   const std::vector<unsigned int>& channel() const { return chan_; };
0047
0048   inline bool operator<(const PixelSimHitExtraInfoLite& other) const { return hitIndex() < other.hitIndex(); }
0049
0050   void addDigiInfo(unsigned int theDigiChannel) { chan_.push_back(theDigiChannel); }
0051   bool isInTheList(unsigned int channelToCheck) {
0052     bool result_in_the_list = false;
0053     for (unsigned int icheck = 0; icheck < chan_.size(); icheck++) {
0054       if (channelToCheck == chan_[icheck]) {
0055         result_in_the_list = true;
0056         break;
0057       }
0058     }
0059     return result_in_the_list;
0060   }
0061
0062 private:
0063   size_t index_;
0064   uint16_t theEntryPointX_;
0065   uint16_t theEntryPointY_;
0066   uint16_t theEntryPointZ_;
0067   uint16_t theExitPointX_;
0068   uint16_t theExitPointY_;
0069   uint16_t theExitPointZ_;
0070   Local3DPoint UncompressedEntryPoint_;
0071   Local3DPoint UncompressedExitPoint_;
0072   std::vector<unsigned int> chan_;
0073 };
0074 #endif