DTTSPhi.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: DTTSPhi.cpp
//
//   Description: Implementation of TS Phi trigger algorithm
//
//
//   Author List:
//   C. Grandi
//   Modifications:
//   jan02 - D.Bonacorsi/S.Marcellini
//           improved algorithm for 2nd track handling in case of pile-up in TSM
//           param: tsmgetcarryflag - value: 1 (default)
//   feb04 - Implementation of sector collector related stuff(S. Marcellini)
//   jan07 - C. Battilana local conf update
//   mar07 - S. Vanini : parameters from DTConfigManager
//
//--------------------------------------------------

#include "L1TriggerConfig/DTTPGConfig/interface/BitArray.h"

//-----------------------
// This Class's Header --
//-----------------------
#include "L1Trigger/DTTriggerServerPhi/interface/DTTSPhi.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "L1Trigger/DTTraco/interface/DTTracoCard.h"
#include "L1Trigger/DTTraco/interface/DTTracoTrigData.h"
#include "L1Trigger/DTTriggerServerPhi/interface/DTTSCand.h"
#include "L1Trigger/DTTriggerServerPhi/interface/DTTSM.h"
#include "L1Trigger/DTTriggerServerPhi/interface/DTTSS.h"

//---------------
// C++ Headers --
//---------------
#include <iostream>

//----------------
// Constructors --
//----------------
DTTSPhi::DTTSPhi(DTTrigGeom *geom, DTTracoCard *tracocard)
    : DTGeomSupplier(geom), _tracocard(tracocard) {

  // reserve the appropriate amount of space for vectors
  int i = 0;
  for (i = 0; i < DTConfigTSPhi::NSTEPL - DTConfigTSPhi::NSTEPF + 1;
       i++) { // SM add + 1
    _tss[i].reserve(DTConfigTSPhi::NTSSTSM);
    // DBSM-doubleTSM
    _tsm[i].reserve(DTConfigTSPhi::NTSMD);
  }

  for (int is = 0; is < DTConfigTSPhi::NSTEPL - DTConfigTSPhi::NSTEPF + 1;
       is++) {

    // create DTTSSs
    for (int itss = 1; itss <= DTConfigTSPhi::NTSSTSM; itss++) {
      DTTSS *tss = new DTTSS(itss);
      _tss[is].push_back(tss);
    }

    // create DTTSMs     SM double TSM
    for (int itsmd = 1; itsmd <= DTConfigTSPhi::NTSMD; itsmd++) {
      DTTSM *tsm = new DTTSM(itsmd);
      _tsm[is].push_back(tsm);
    }
  }
}

//--------------
// Destructor --
//--------------
DTTSPhi::~DTTSPhi() {

  std::vector<DTTSS *>::iterator ptss;
  std::vector<DTTSM *>::iterator ptsm;
  for (int is = 0; is < DTConfigTSPhi::NSTEPL - DTConfigTSPhi::NSTEPF + 1;
       is++) {
    // clear TSSs
    for (ptss = _tss[is].begin(); ptss != _tss[is].end(); ptss++) {
      delete (*ptss);
    }
    _tss[is].clear();
    // clear TSMs
    for (ptsm = _tsm[is].begin(); ptsm != _tsm[is].end(); ptsm++) {
      delete (*ptsm);
    }
    _tsm[is].clear();
  }

  localClear();

  // delete _config;
}

//--------------
// Operations --
//--------------

void DTTSPhi::localClear() {
  for (int is = 0; is < DTConfigTSPhi::NSTEPL - DTConfigTSPhi::NSTEPF + 1;
       is++) {
    // clear buffer
    std::vector<DTTSCand *>::iterator p1;
    for (p1 = _tctrig[is].begin(); p1 != _tctrig[is].end(); p1++) {
      delete (*p1);
    }
    _tctrig[is].clear();

    std::vector<DTTSS *>::iterator ptss;
    for (ptss = _tss[is].begin(); ptss != _tss[is].end(); ptss++) {
      (*ptss)->clear();
    }
    // clear all DTTSM
    std::vector<DTTSM *>::iterator ptsm;
    for (ptsm = _tsm[is].begin(); ptsm != _tsm[is].end(); ptsm++) {
      (*ptsm)->clear();
    }
  }
}

void DTTSPhi::setConfig(const DTConfigManager *conf) {

  DTChamberId sid = ChamberId();
  _config = conf->getDTConfigTSPhi(sid);

  for (int is = 0; is < DTConfigTSPhi::NSTEPL - DTConfigTSPhi::NSTEPF + 1;
       is++) {

    // set TSS config
    std::vector<DTTSS *>::iterator ptss;
    for (ptss = _tss[is].begin(); ptss != _tss[is].end(); ptss++) {
      (*ptss)->setConfig(config());
    }
    // set TSM config
    std::vector<DTTSM *>::iterator ptsm;
    for (ptsm = _tsm[is].begin(); ptsm != _tsm[is].end(); ptsm++) {
      (*ptsm)->setConfig(config());
    }
  }
}

void DTTSPhi::loadTSPhi() {

  // clear DTTSSs and DTTSM
  localClear();

  if (config()->debug()) {
    std::cout << "DTTSPhi::loadDTTSPhi called for wheel=" << wheel();
    std::cout << ", station=" << station();
    std::cout << ", sector=" << sector() << std::endl;
  }

  // loop on all TRACO triggers
  std::vector<DTTracoTrigData>::const_iterator p;
  std::vector<DTTracoTrigData>::const_iterator pend = _tracocard->end();
  for (p = _tracocard->begin(); p != pend; p++) {

    if (config()->usedTraco(
            p->tracoNumber()) /*|| config()->usedTraco(p->tracoNumber())==1*/) {
      int step = p->step();
      int fs = (p->isFirst()) ? 1 : 2;

      // if first track is found inhibit second track processing in previous BX
      if (fs == 1 && step > DTConfigTSPhi::NSTEPF)
        ignoreSecondTrack(step - 1, p->tracoNumber());

      // load trigger
      addTracoT(step, &(*p), fs);
    }
  }
}

void DTTSPhi::addTracoT(int step, const DTTracoTrigData *tracotrig, int ifs) {
  if (step < DTConfigTSPhi::NSTEPF || step > DTConfigTSPhi::NSTEPL) {
    std::cout << "DTTSPhi::addTracoT: step out of range: " << step;
    std::cout << " trigger not added!" << std::endl;
    return;
  }
  // Check that a preview is present and code is not zero
  if (!tracotrig->pvCode() || !tracotrig->code()) {
    std::cout << "DTTSPhi::addTracoT: preview not present in TRACO trigger or "
                 "its code=0 ";
    std::cout << " trigger not added!" << std::endl;
    return;
  }

  // Get the appropriate TSS
  int itss = (tracotrig->tracoNumber() - 1) / DTConfigTSPhi::NTCTSS + 1;
  if (itss < 1 || itss > DTConfigTSPhi::NTSSTSM) {
    std::cout << "DTTSPhi::addTracoT: wrong TRACO number: ";
    std::cout << tracotrig->tracoNumber();
    std::cout << " trigger not added!" << std::endl;
    return;
  }

  // TSM status check (if it is the case, reject TRACO triggers related to
  // broken TSMData)
  if (config()->TsmStatus().element(itss) == 0) { // TSMD broken
    return;
  }

  int pos = tracotrig->tracoNumber() - (itss - 1) * DTConfigTSPhi::NTCTSS;
  DTTSS *tss = getDTTSS(step, itss);

  // Create a new Trigger Server candidate
  DTTSCand *cand = new DTTSCand(tss, tracotrig, ifs, pos);

  // Add it to the buffer and to the TSS
  _tctrig[step - DTConfigTSPhi::NSTEPF].push_back(cand);
  tss->addDTTSCand(cand);

  // Debugging...
  if (config()->debug()) {
    std::cout << "DTTSPhi::addTracoT at step " << step;
    if (ifs == 1) {
      std::cout << " (first track)";
    } else {
      std::cout << " (second track)";
    }
    std::cout << " from TRACO " << tracotrig->tracoNumber();
    std::cout << " to TSS " << tss->number() << ", position=" << pos
              << std::endl;
    tracotrig->print();
  }
  // end debugging
}

void DTTSPhi::runTSPhi() {

  DTTSCand *secondPrevBx = nullptr; // new DTTSCand;

  bool existSecondPrevBx = false;
  int itsmd = 1; // initialize it to 1, default value if not in back up mode
  int ntsm[DTConfigTSPhi::NSTEPL + 1 - DTConfigTSPhi::NSTEPF]
          [DTConfigTSPhi::NTSMD];
  int i_tsmd;

  for (int is = DTConfigTSPhi::NSTEPF; is < DTConfigTSPhi::NSTEPL + 1; is++) {
    // loop on DTTSSs
    int ntss = 0;
    i_tsmd = 0;
    ntsm[is - DTConfigTSPhi::NSTEPF][0] =
        0; // counter to make sector collector run if at least a tsm
    ntsm[is - DTConfigTSPhi::NSTEPF][1] = 0;
    std::vector<DTTSS *>::iterator p;
    for (p = _tss[is - DTConfigTSPhi::NSTEPF].begin();
         p < _tss[is - DTConfigTSPhi::NSTEPF].end(); p++) {
      if ((*p)->nTracoT(1) > 0) {
        // run DTTSS algorithm on non-empty DTTSSs
        (*p)->run();
        // load DTTSM with output DTTSS tracks
        if ((*p)->nTracks() > 0) {
          for (int it = 1; it <= (*p)->nTracks(); it++) {
            //--- SM double TSM    get the corresponding tsm data
            int bkmod = config()->TsmStatus().element(0);
            if (bkmod == 0) {               // we are in back-up mode
              int my_itss = (*p)->number(); // metodo di DTTSS che ritorna itss
              int ntsstsmd = config()->TSSinTSMD(station(), sector());
              if (ntsstsmd < 2 || ntsstsmd > DTConfigTSPhi::NTSSTSMD) {
                std::cout << " DTTSPhi::addTracoT - wrong TSMD: " << ntsstsmd
                          << std::endl;
              }

              // Get the appropriate TSMD
              itsmd = (my_itss - 1) / ntsstsmd + 1;
              if (config()->debug()) {
                std::cout << " DTTSPhi::addTracoT: itsmd = (my_itss -1 ) / "
                             "ntsstsmd + 1  ---> my_itss = "
                          << my_itss << "  ntsstsmd = " << ntsstsmd
                          << "  itsmd = " << itsmd << std::endl;
              }
            } else if (bkmod == 1) {
              itsmd =
                  1; // initialize it to 1, default value if not in back up mode
            }
            if (itsmd > 2)
              std::cout << "****** >DTTSPhi::RunTSPhi wrong  itsmd = " << itsmd
                        << std::endl;
            DTTSM *tsm = getDTTSM(is, itsmd);
            tsm->addCand((*p)->getTrack(it));
          }
          ntss++;
        } // end loop on output DTTSS tracks
      }
    } // end loop on DTTSSs

    // at least a DTTSS with signal. Run DTTSM

    std::vector<DTTSM *>::iterator p_tsm;

    for (p_tsm = _tsm[is - DTConfigTSPhi::NSTEPF].begin();
         p_tsm < _tsm[is - DTConfigTSPhi::NSTEPF].end(); p_tsm++) {

      // Run TSM sorting if at least a first track

      i_tsmd = (*p_tsm)->number() -
               1; // returns itsmd (0 in default, 0 or 1 when bkmode )

      if ((*p_tsm)->nCand(1) > 0) {
        int bkmod = config()->TsmStatus().element(0);

        (*p_tsm)->run(bkmod); // bkmod 1 normal, 0 backup
        // Run TSM for current BX in case of 1st Tracks
        // Run TSM for previous BX for second tracks, to check whether there is
        // a pile up Tells whether a second track at previous BX exists

        if ((*p_tsm)->nTracks() > 0) {
          // We have a first track. Store it if code is > 0

          if ((*p_tsm)->getTrack(1)->tracoTr()->code() > 0) {

            DTTSCand *first = (*p_tsm)->getTrack(1);
            if (config()->TsmGetCarryFlag() ==
                0) { //  get 1st tk at current BX and ignore any 2nd tk at
                     //  previous BX

              _cache.push_back(DTChambPhSegm(
                  ChamberId(), is, (*p_tsm)->getTrack(1)->tracoTr(), 1));
              ntsm[is - DTConfigTSPhi::NSTEPF]
                  [i_tsmd]++; // SM increment ntsm at current BX
              if (config()->debug())
                std::cout << "ntsm = "
                          << ntsm[is - DTConfigTSPhi::NSTEPF][i_tsmd]
                          << " is = " << is << " i_tsmd = " << i_tsmd
                          << std::endl;
              if ((*p_tsm)->nTracks() > 1) { // there is a 2nd tk
                if ((*p_tsm)->getTrack(2)->tracoTr()->code() >
                    0) { // check if its code > 0
                  ntsm[is - DTConfigTSPhi::NSTEPF][i_tsmd]++;
                  if (config()->debug())
                    std::cout
                        << "ntsm = " << ntsm[is - DTConfigTSPhi::NSTEPF][i_tsmd]
                        << " is = " << is << " i_tsmd = " << i_tsmd
                        << std::endl;

                  secondPrevBx =
                      (*p_tsm)->getTrack(2); // assign second tk of previous BX
                }
              }
            } else if (config()->TsmGetCarryFlag() ==
                       1) { // compare with 2nd tk in previous BX and get the tk
                            // with better quality
              existSecondPrevBx =
                  ((is - 1 - DTConfigTSPhi::NSTEPF >= 0) &&
                   (ntsm[is - 1 - DTConfigTSPhi::NSTEPF][i_tsmd] > 1) &&
                   (secondPrevBx->tracoTr()->code() > 0));
              if ((!existSecondPrevBx) ||
                  !((secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                     secondPrevBx->isInner()) ||
                    (secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                     !secondPrevBx->isInner()) ||
                    (!secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                     secondPrevBx->isInner())) ||

                  ((secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                    secondPrevBx->isInner()) &&
                   (first->isCorr() && first->isHtrig() && first->isInner())) ||

                  ((secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                    !secondPrevBx->isInner()) &&
                   ((first->isCorr() && first->isHtrig() && first->isInner()) ||
                    (first->isCorr() && first->isHtrig() &&
                     !first->isInner()))) ||

                  ((!secondPrevBx->isCorr() && secondPrevBx->isHtrig() &&
                    secondPrevBx->isInner()) &&
                   !((!first->isCorr() && first->isHtrig() &&
                      !first->isInner()) ||
                     (!first->isCorr() && !first->isHtrig() &&
                      first->isInner()) ||
                     (!first->isCorr() && !first->isHtrig() &&
                      !first->isInner()) ||
                     (first->isCorr() && !first->isHtrig() &&
                      !first->isInner()) ||
                     (first->isCorr() && !first->isHtrig() &&
                      first->isInner())))) {
                // SM sector collector
                ntsm[is - DTConfigTSPhi::NSTEPF]
                    [i_tsmd]++; // SM increment ntsm at current BX. I need to
                                // know if there is at least a first track from
                                // TSM to run Sect Coll

                _cache.push_back(DTChambPhSegm(
                    ChamberId(), is, (*p_tsm)->getTrack(1)->tracoTr(), 1));
                //      (*p_tsm)->getTrack(1)->print();

                if ((*p_tsm)->nTracks() > 1) { // there is a 2nd tk
                  ntsm[is - DTConfigTSPhi::NSTEPF][i_tsmd]++;
                  if ((*p_tsm)->getTrack(2)->tracoTr()->code() >
                      0) { // check if its code > 0
                    secondPrevBx =
                        (*p_tsm)->getTrack(2); // assign second previous BX
                  }
                }
              } else { // if 2nd tk prev BX is better than first present BX skip
                       // the event and get 2nd prev BX
                ntsm[is - 1 - DTConfigTSPhi::NSTEPF]
                    [i_tsmd]++; // SM increment ntsm at previous BX.
                _cache.push_back(DTChambPhSegm(ChamberId(), is - 1,
                                               secondPrevBx->tracoTr(), 2));
                // secondPrevBx->print();
              }
            }

            else if (config()->TsmGetCarryFlag() ==
                     2) { // neglect first tk if it is a low uncorrelated
                          // trigger
              existSecondPrevBx =
                  ((is - 1 - DTConfigTSPhi::NSTEPF >= 0) &&
                   (ntsm[is - 1 - DTConfigTSPhi::NSTEPF][i_tsmd] > 1) &&
                   (secondPrevBx->tracoTr()->code() > 0));
              if ((!existSecondPrevBx) || first->isHtrig() || first->isCorr()) {
                ntsm[is - DTConfigTSPhi::NSTEPF]
                    [i_tsmd]++; // SM increment ntsm at current BX.
                // SM sector collector: Load DTSectColl with output of DTTSM
                _cache.push_back(DTChambPhSegm(
                    ChamberId(), is, (*p_tsm)->getTrack(1)->tracoTr(), 1));
                //      (*p_tsm)->getTrack(1)->print();

                if ((*p_tsm)->nTracks() > 1) { // there is a 2nd tk
                  ntsm[is - DTConfigTSPhi::NSTEPF][i_tsmd]++;
                  if ((*p_tsm)->getTrack(2)->tracoTr()->code() >
                      0) { // check if its code > 0
                    secondPrevBx = (*p_tsm)->getTrack(
                        2); // assign second tk of previous BX
                  }
                }
              } else {
                ntsm[is - 1 - DTConfigTSPhi::NSTEPF]
                    [i_tsmd]++; // SM increment ntsm at previous BX.
                _cache.push_back(DTChambPhSegm(ChamberId(), is - 1,
                                               secondPrevBx->tracoTr(), 2));
                //      secondPrevBx->print();
              }
            }
          }
        }

      } else if (((*p_tsm)->nCand(1) == 0) &&
                 (is - 1 - DTConfigTSPhi::NSTEPF >= 0) &&
                 ntsm[is - 1 - DTConfigTSPhi::NSTEPF][i_tsmd] >
                     0) { // it means that the last BX with sort 2 was not the
                          // previous one
        existSecondPrevBx =
            ((is - 1 - DTConfigTSPhi::NSTEPF >= 0) &&
             (ntsm[is - 1 - DTConfigTSPhi::NSTEPF][i_tsmd] > 1) &&
             (secondPrevBx->tracoTr()->code() > 0));
        if (existSecondPrevBx) {
          _cache.push_back(
              DTChambPhSegm(ChamberId(), is - 1, secondPrevBx->tracoTr(), 2));

          //      secondPrevBx->print();
        }
      }
    }
    //---

  } // end loop on step
  // debugging...
  if (config()->debug()) {
    if (!_cache.empty()) {
      std::cout << "===================================================="
                << std::endl;
      std::cout << "                  Phi segments                     "
                << std::endl;
      std::vector<DTChambPhSegm>::const_iterator p;
      for (p = _cache.begin(); p < _cache.end(); p++) {
        p->print();
      }
      std::cout << "===================================================="
                << std::endl;
    }
  }
  //  end debugging
}

void DTTSPhi::ignoreSecondTrack(int step, int tracon) {

  int itsmd = 1; // initialize it to default

  if (step < DTConfigTSPhi::NSTEPF || step > DTConfigTSPhi::NSTEPL) {
    std::cout << "DTTSPhi::ignoreSecondTrack: step out of range: " << step;
    std::cout << " no flag set!" << std::endl;
    return;
  }
  int itss = (tracon - 1) / DTConfigTSPhi::NTCTSS + 1;
  if (itss < 1 || itss > DTConfigTSPhi::NTSSTSM) {
    std::cout << "DTTSPhi::ignoreSecondTrack: wrong TRACO number: " << tracon;
    std::cout << " no flag set!" << std::endl;
    return;
  }
  DTTSS *tss = getDTTSS(step, itss);
  tss->ignoreSecondTrack();

  int bkmod = config()->TsmStatus().element(0);
  if (bkmod == 0) { // we are in back-up mode

    int ntsstsmd = config()->TSSinTSMD(station(), sector());
    // Get the appropriate TSMD
    itsmd = (itss - 1) / ntsstsmd + 1;
  }

  DTTSM *tsm = getDTTSM(step, itsmd);
  tsm->ignoreSecondTrack();
}

DTTSS *DTTSPhi::getDTTSS(int step, unsigned n) const {
  if (step < DTConfigTSPhi::NSTEPF || step > DTConfigTSPhi::NSTEPL) {
    std::cout << "DTTSPhi::getDTTSS: step out of range: " << step;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }
  if (n < 1 || n > _tss[step - DTConfigTSPhi::NSTEPF].size()) {
    std::cout << "DTTSPhi::getDTTSS: requested DTTSS not present: " << n;
    std::cout << " (at step " << step << ")";
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }

  std::vector<DTTSS *>::const_iterator p =
      _tss[step - DTConfigTSPhi::NSTEPF].begin() + n - 1;
  return *p;
}

DTTSM *DTTSPhi::getDTTSM(int step, unsigned n) const {
  if (step < DTConfigTSPhi::NSTEPF || step > DTConfigTSPhi::NSTEPL) {
    std::cout << "DTTSPhi::getDTTSM: step out of range: " << step;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }
  if (n < 1 || n > _tsm[step - DTConfigTSPhi::NSTEPF].size()) {
    std::cout << "DTTSPhi::getDTTSM: requested DTTSM not present: " << n;
    std::cout << " (at step " << step << ")";
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }
  std::vector<DTTSM *>::const_iterator p_tsm =
      _tsm[step - DTConfigTSPhi::NSTEPF].begin() + n - 1;
  return *p_tsm;
}

int DTTSPhi::nSegm(int step) {
  int n = 0;
  std::vector<DTChambPhSegm>::const_iterator p; // p=0;
  for (p = begin(); p < end(); p++) {
    if (p->step() == step)
      n++;
  }
  return n;
}

const DTChambPhSegm *DTTSPhi::segment(int step, unsigned n) {
  std::vector<DTChambPhSegm>::const_iterator p; // p=0;
  for (p = begin(); p < end(); p++) {
    if (p->step() == step &&
        ((n == 1 && p->isFirst()) || (n == 2 && !p->isFirst())))
      return &(*p); // p;
  }
  return nullptr;
}

LocalPoint DTTSPhi::localPosition(const DTTrigData *tr) const {
  //@@ patch for Sun 4.2 compiler
  // sm DTChambPhSegm* trig =
  // dynamic_cast<DTChambPhSegm*>(const_cast<DTTrigData*>(tr));
  const DTChambPhSegm *trig = dynamic_cast<const DTChambPhSegm *>(tr);
  if (!trig) {
    std::cout << "DTTSPhi::LocalPosition called with wrong argument!"
              << std::endl;
    return LocalPoint(0, 0, 0);
  }
  return _tracocard->localPosition(trig->tracoTrig());
}

LocalVector DTTSPhi::localDirection(const DTTrigData *tr) const {
  DTChambPhSegm *trig =
      dynamic_cast<DTChambPhSegm *>(const_cast<DTTrigData *>(tr));
  //  const DTChambPhSegm* trig = dynamic_cast<const DTChambPhSegm*>(tr);
  if (!trig) {
    std::cout << "DTTSPhi::LocalDirection called with wrong argument!"
              << std::endl;
    return LocalVector(0, 0, 0);
  }
  return _tracocard->localDirection(trig->tracoTrig());
}