TrackerTFP/src/State.cc

0001 #include "L1Trigger/TrackerTFP/interface/State.h"
0002
0003 using namespace std;
0004 using namespace tt;
0005
0006 namespace trackerTFP {
0007
0008   // default constructor
0009   State::State(State* state)
0010       : dataFormats_(state->dataFormats_),
0011         setup_(state->setup_),
0012         track_(state->track_),
0013         trackId_(state->trackId_),
0014         parent_(state->parent_),
0015         stub_(state->stub_),
0016         layerMap_(state->layerMap_),
0017         hitPattern_(state->hitPattern_),
0018         x0_(state->x0_),
0019         x1_(state->x1_),
0020         x2_(state->x2_),
0021         x3_(state->x3_),
0022         C00_(state->C00_),
0023         C01_(state->C01_),
0024         C11_(state->C11_),
0025         C22_(state->C22_),
0026         C23_(state->C23_),
0027         C33_(state->C33_),
0028         numSkippedLayers_(state->numSkippedLayers_),
0029         numConsistentLayers_(state->numConsistentLayers_) {}
0030
0031   // proto state constructor
0032   State::State(const DataFormats* dataFormats, TrackKFin* track, int trackId)
0033       : dataFormats_(dataFormats),
0034         setup_(dataFormats->setup()),
0035         track_(track),
0036         trackId_(trackId),
0037         parent_(nullptr),
0038         stub_(nullptr),
0039         layerMap_(setup_->numLayers()),
0040         hitPattern_(0, setup_->numLayers()),
0041         numSkippedLayers_(0),
0042         numConsistentLayers_(0) {
0043     // initial track parameter residuals w.r.t. found track
0044     x0_ = 0.;
0045     x1_ = 0.;
0046     x2_ = 0.;
0047     x3_ = 0.;
0048     // initial uncertainties
0049     C00_ = pow(dataFormats_->base(Variable::inv2R, Process::kfin), 2);
0050     C11_ = pow(dataFormats_->base(Variable::phiT, Process::kfin), 2);
0051     C22_ = pow(dataFormats_->base(Variable::cot, Process::kfin), 2);
0052     C33_ = pow(dataFormats_->base(Variable::zT, Process::kfin), 2);
0053     C01_ = 0.;
0054     C23_ = 0.;
0055     // first stub from first layer on input track with stubs
0056     stub_ = track->layerStub(track->hitPattern().plEncode());
0057   }
0058
0059   // combinatoric state constructor
0060   State::State(State* state, StubKFin* stub) : State(state) {
0061     parent_ = state->parent();
0062     stub_ = stub;
0063   }
0064
0065   // updated state constructor
0066   State::State(State* state, const std::vector<double>& doubles) : State(state) {
0067     parent_ = state;
0068     // updated track parameter and uncertainties
0069     x0_ = doubles[0];
0070     x1_ = doubles[1];
0071     x2_ = doubles[2];
0072     x3_ = doubles[3];
0073     C00_ = doubles[4];
0074     C11_ = doubles[5];
0075     C22_ = doubles[6];
0076     C33_ = doubles[7];
0077     C01_ = doubles[8];
0078     C23_ = doubles[9];
0079     // update maps
0080     const int layer = stub_->layer();
0081     hitPattern_.set(layer);
0082     const vector<StubKFin*>& stubs = track_->layerStubs(layer);
0083     layerMap_[layer] = distance(stubs.begin(), find(stubs.begin(), stubs.end(), stub_));
0084     // pick next stub (first stub in next layer with stub)
0085     stub_ = nullptr;
0086     if (hitPattern_.count() == setup_->kfMaxLayers())
0087       return;
0088     for (int nextLayer = layer + 1; nextLayer < setup_->numLayers(); nextLayer++) {
0089       if (track_->hitPattern(nextLayer)) {
0090         stub_ = track_->layerStub(nextLayer);
0091         break;
0092       }
0093     }
0094   }
0095
0096   // fills collection of stubs added so far to state
0097   void State::fill(vector<StubKF>& stubs) const {
0098     stubs.reserve(hitPattern_.count());
0099     State* s = parent_;
0100     while (s) {
0101       stubs.emplace_back(*(s->stub()), x0_, x1_, x2_, x3_);
0102       s = s->parent();
0103     }
0104   }
0105
0106   // Determine quality of completed state
0107   void State::finish() {
0108     auto consistent = [this](int sum, const StubKF& stub) {
0109       static const DataFormat& phi = dataFormats_->format(Variable::phi, Process::kf);
0110       static const DataFormat& z = dataFormats_->format(Variable::z, Process::kf);
0111       // Check stub consistent with helix, allowing for stub uncertainty
0112       const bool inRange0 = 2. * abs(stub.phi()) - stub.dPhi() < phi.base();
0113       const bool inRange1 = 2. * abs(stub.z()) - stub.dZ() < z.base();
0114       return sum + (inRange0 && inRange1 ? 1 : 0);
0115     };
0116     vector<StubKF> stubs;
0117     fill(stubs);
0118     numConsistentLayers_ = accumulate(stubs.begin(), stubs.end(), 0, consistent);
0119     TTBV pattern = hitPattern_;
0120     pattern |= maybePattern();
0121     // Skipped layers before final stub on state
0122     numSkippedLayers_ = pattern.count(0, hitPattern_.pmEncode(), false);
0123   }
0124
0125 }  // namespace trackerTFP