CSCUpgradeAnodeLCTProcessor.cc

Go to the documentation of this file.

#include "L1Trigger/CSCTriggerPrimitives/interface/CSCUpgradeAnodeLCTProcessor.h"

CSCUpgradeAnodeLCTProcessor::CSCUpgradeAnodeLCTProcessor(unsigned endcap, unsigned station,
                                                         unsigned sector, unsigned subsector,
                                                         unsigned chamber,
                                                         const edm::ParameterSet& conf) :
  CSCAnodeLCTProcessor(endcap, station, sector, subsector, chamber, conf)
{
  if (!isSLHC_) edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
    << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while isSLHC_ is not set! +++\n";

  if (!enableAlctSLHC_) edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
    << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while enableAlctSLHC_ is not set! +++\n";
}

CSCUpgradeAnodeLCTProcessor::CSCUpgradeAnodeLCTProcessor() :
  CSCAnodeLCTProcessor()
{
  if (!isSLHC_) edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
    << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while isSLHC_ is not set! +++\n";

  if (!enableAlctSLHC_) edm::LogError("CSCUpgradeAnodeLCTProcessor|ConfigError")
    << "+++ Upgrade CSCUpgradeAnodeLCTProcessor constructed while enableAlctSLHC_ is not set! +++\n";
}

void CSCUpgradeAnodeLCTProcessor::ghostCancellationLogic()
{
  int ghost_cleared[CSCConstants::MAX_NUM_WIRES][2];

  for (int key_wire = 0; key_wire < numWireGroups; key_wire++) {
    for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
      ghost_cleared[key_wire][i_pattern] = 0;

      // Non-empty wire group.
      int qual_this = quality[key_wire][i_pattern];
      if (qual_this > 0) {

        if (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
          qual_this = (qual_this & 0x03);
        // Previous wire.
        int dt = -1;
        int qual_prev = (key_wire > 0) ? quality[key_wire-1][i_pattern] : 0;
        if (qual_prev > 0) {
          if (use_corrected_bx)
            dt = first_bx_corrected[key_wire] - first_bx_corrected[key_wire-1];
          else
            dt = first_bx[key_wire] - first_bx[key_wire-1];
          // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
          if (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
            qual_prev = (qual_prev & 0x03);

          // Cancel this wire
          //   1) If the candidate at the previous wire is at the same bx
          //      clock and has better quality (or equal? quality - this has
          //      been implemented only in 2004).
          //   2) If the candidate at the previous wire is up to 4 clocks
          //      earlier, regardless of quality.
          if (dt == 0) {
            if (qual_prev > qual_this) ghost_cleared[key_wire][i_pattern] = 1;
          }
          else if (dt > 0 && dt <= ghost_cancellation_bx_depth ) {
            if ((!ghost_cancellation_side_quality) ||
                (qual_prev > qual_this) )
              ghost_cleared[key_wire][i_pattern] = 1;
          }
        }

        // Next wire.
        // Skip this step if this wire is already declared "ghost".
        if (ghost_cleared[key_wire][i_pattern] == 1) {
          if (infoV > 1) LogTrace("CSCUpgradeAnodeLCTProcessor")
            << ((i_pattern == 0) ? "Accelerator" : "Collision")
            << " pattern ghost cancelled on key_wire " << key_wire <<" q="<<qual_this
            << "  by wire " << key_wire-1<<" q="<<qual_prev<<"  dt="<<dt;
          continue;
        }

        dt = -1;
        int qual_next =
          (key_wire < numWireGroups-1) ? quality[key_wire+1][i_pattern] : 0;
        if (qual_next > 0) {
          if (use_corrected_bx)
            dt = first_bx_corrected[key_wire] - first_bx_corrected[key_wire+1];
          else
            dt = first_bx[key_wire] - first_bx[key_wire+1];
          // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
          if (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
            qual_next = (qual_next & 0x03);
          // Same cancellation logic as for the previous wire.
          if (dt == 0) {
            if (qual_next >= qual_this) ghost_cleared[key_wire][i_pattern] = 1;
          }
          else if (dt > 0 && dt <= ghost_cancellation_bx_depth ) {
            if ((!ghost_cancellation_side_quality) ||
                (qual_next >= qual_this) )
              ghost_cleared[key_wire][i_pattern] = 1;
          }
        }
        if (ghost_cleared[key_wire][i_pattern] == 1) {
          if (infoV > 1) LogTrace("CSCUpgradeAnodeLCTProcessor")
            << ((i_pattern == 0) ? "Accelerator" : "Collision")
            << " pattern ghost cancelled on key_wire " << key_wire <<" q="<<qual_this
            << "  by wire " << key_wire+1<<" q="<<qual_next<<"  dt="<<dt;
          continue;
        }
      }
    }
  }

  // All cancellation is done in parallel, so wiregroups do not know what
  // their neighbors are cancelling.
  for (int key_wire = 0; key_wire < numWireGroups; key_wire++) {
    for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
      if (ghost_cleared[key_wire][i_pattern] > 0) {
        clear(key_wire, i_pattern);
      }
    }
  }
}



void CSCUpgradeAnodeLCTProcessor::ghostCancellationLogicOneWire(const int key_wire, int *ghost_cleared)
{

    for (int i_pattern = 0; i_pattern < 2; i_pattern++) {
      ghost_cleared[i_pattern] = 0;
      if (key_wire == 0) continue;

      // Non-empty wire group.
      int qual_this = quality[key_wire][i_pattern];
      if (qual_this > 0) {

        if (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
          qual_this = (qual_this & 0x03);
        // Previous wire.
        int dt = -1;
        for (auto& p : lct_list){
          if (not (p.isValid() and p.getKeyWG() == key_wire -1 and 1-p.getAccelerator() == i_pattern)) continue;
            
          bool ghost_cleared_prev = false;
          int qual_prev = p.getQuality();
          int first_bx_prev = p.getBX();
          if (infoV > 1) LogTrace("CSCAnodeLCTProcessor")
            << "ghost concellation logic " << ((i_pattern == 0) ? "Accelerator" : "Collision")
            << " key_wire "<< key_wire <<" quality "<< qual_this <<" bx " <<  first_bx[key_wire]
            << " previous key_wire "<< key_wire -1 <<" quality "<< qual_prev <<" bx " <<  first_bx[key_wire-1];

          //int dt = first_bx[key_wire] - first_bx[key_wire-1];
          if (use_corrected_bx)
            dt = first_bx_corrected[key_wire] - first_bx_prev;
          else
            dt = first_bx[key_wire] - first_bx_prev;
          // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
          if (isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_))
            qual_prev = (qual_prev & 0x03);

          // Cancel this wire
          //   1) If the candidate at the previous wire is at the same bx
          //      clock and has better quality (or equal? quality - this has
          //      been implemented only in 2004).
          //   2) If the candidate at the previous wire is up to 4 clocks
          //      earlier, regardless of quality.
          if (dt == 0) {
            if (qual_prev > qual_this) ghost_cleared[i_pattern] = 1;
          }
          else if (dt > 0 && dt <= ghost_cancellation_bx_depth ) {
            if ((!ghost_cancellation_side_quality) ||
                (qual_prev > qual_this) )
              ghost_cleared[i_pattern] = 1;
          }
          else if (dt < 0 && dt*(-1) <= ghost_cancellation_bx_depth){
            if ((!ghost_cancellation_side_quality) ||
                (qual_prev < qual_this) )
              ghost_cleared_prev = true;
          }

        if (ghost_cleared[i_pattern] == 1) {
          if (infoV > 1) LogTrace("CSCUpgradeAnodeLCTProcessor")
            << ((i_pattern == 0) ? "Accelerator" : "Collision")
            << " pattern ghost cancelled on key_wire " << key_wire <<" q="<<qual_this
            << "  by wire " << key_wire-1<<" q="<<qual_prev<<"  dt="<<dt;
          //cancellation for key_wire is done when ALCT is created and pushed to lct_list
        }
        if (ghost_cleared_prev) {
          if (infoV > 1) LogTrace("CSCAnodeLCTProcessor")
            << ((i_pattern == 0) ? "Accelerator" : "Collision")
            << " pattern ghost cancelled on key_wire " << key_wire - 1 <<" q="<<qual_prev
            << "  by wire " << key_wire <<" q="<<qual_this;
            p.setValid(0);//clean prev ALCT
        }

        }

    }
  }

  
}


int CSCUpgradeAnodeLCTProcessor::getTempALCTQuality(int temp_quality) const
{
  // Quality definition changed on 22 June 2007: it no longer depends
  // on pattern_thresh.
  int Q;
  // hack to run the Phase-II ME2/1, ME3/1 and ME4/1 ILT
  if (temp_quality == 3 and isSLHC_ and (runME21ILT_ or runME31Up_ or runME41Up_)) Q = 4;
  else if (temp_quality > 3) Q = temp_quality - 3;
  else                  Q = 0; // quality code 0 is valid!

  return Q;
}