InitialGrouping Class Reference

#include <InitialGrouping.h>

Inheritance diagram for InitialGrouping:

Public Member Functions
void	finish () override
	InitialGrouping (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
void	initialise (const edm::EventSetup &iEventSetup) override
void	run (edm::Event &iEvent, const edm::EventSetup &iEventSetup, const DTDigiCollection &digis, MuonPathPtrs &outMpath) override
	~InitialGrouping () override
Public Member Functions inherited from MotherGrouping
	MotherGrouping (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
virtual	~MotherGrouping ()

Private Member Functions
bool	isEqualComb2Previous (DTPrimitives &ptr)
void	mixChannels (int sl, int pathId, MuonPathPtrs &outMpath)
bool	notEnoughDataInChannels (void)
void	resetPrvTDCTStamp (void)
void	selectInChannels (int baseCh)
void	setInChannels (const DTDigiCollection *digi, int sl)

Private Attributes
DTPrimitives	channelIn_ [cmsdt::NUM_LAYERS][cmsdt::NUM_CH_PER_LAYER]
DTPrimitives	chInDummy_
int	currentBaseChannel_
const bool	debug_
DTPrimitives	muxInChannels_ [cmsdt::NUM_CELLS_PER_BLOCK]
int	prevTDCTimeStamps_ [4]

Detailed Description

Definition at line 61 of file InitialGrouping.h.

Constructor & Destructor Documentation

InitialGrouping()

InitialGrouping::InitialGrouping	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &	iC
	)

Definition at line 14 of file InitialGrouping.cc.

References channelIn_, chInDummy_, debug_, LogDebug, cmsdt::NUM_CH_PER_LAYER, and NUM_LAYERS.

    : MotherGrouping(pset, iC), debug_(pset.getUntrackedParameter<bool>("debug")), currentBaseChannel_(-1) {
  // Obtention of parameters
  if (debug_)
    LogDebug("InitialGrouping") << "InitialGrouping: constructor";

  // Initialisation of channelIn array
  chInDummy_.push_back(DTPrimitive());
  for (int lay = 0; lay < NUM_LAYERS; lay++) {
    for (int ch = 0; ch < NUM_CH_PER_LAYER; ch++) {
      channelIn_[lay][ch] = {chInDummy_};
      channelIn_[lay][ch].clear();
    }
  }
}

~InitialGrouping()

InitialGrouping::~InitialGrouping ( )

override

Definition at line 30 of file InitialGrouping.cc.

References debug_, and LogDebug.

                                  {
  if (debug_)
    LogDebug("InitialGrouping") << "InitialGrouping: destructor";
}

Member Function Documentation

finish()

void InitialGrouping::finish ( )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 77 of file InitialGrouping.cc.

Referenced by progressbar.ProgressBar::__next__().

{ return; };

initialise()

void InitialGrouping::initialise ( const edm::EventSetup &  iEventSetup )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 38 of file InitialGrouping.cc.

References debug_, and LogDebug.

                                                                 {
  if (debug_)
    LogDebug("InitialGrouping") << "InitialGrouping::initialiase";
}

isEqualComb2Previous()

bool InitialGrouping::isEqualComb2Previous ( DTPrimitives &  ptr )

private

Definition at line 200 of file InitialGrouping.cc.

References mps_fire::i, dqmiolumiharvest::j, NUM_LAYERS, and prevTDCTimeStamps_.

Referenced by mixChannels().

                                                                {
  bool answer = true;

  for (int i = 0; i < NUM_LAYERS; i++) {
    if (prevTDCTimeStamps_[i] != dtPrims[i].tdcTimeStamp()) {
      answer = false;
      for (int j = 0; j < NUM_LAYERS; j++) {
        prevTDCTimeStamps_[j] = dtPrims[j].tdcTimeStamp();
      }
      break;
    }
  }
  return answer;
}

mixChannels()

void InitialGrouping::mixChannels ( int  sl, int  pathId, MuonPathPtrs &  outMpath  )

private

Definition at line 215 of file InitialGrouping.cc.

References dtamgrouping::CELL_HORIZONTAL_LAYOUTS, dtamgrouping::CHANNELS_PATH_ARRANGEMENTS, currentBaseChannel_, data, debug_, relativeConstraints::empty, mps_fire::i, isEqualComb2Previous(), mps_monitormerge::items, nano_mu_digi_cff::layer, LogDebug, eostools::move(), muxInChannels_, NUM_LAYERS, and push_back().

Referenced by run().

                                                                                     {
  if (debug_)
    LogDebug("InitialGrouping") << "[InitialGrouping::mixChannel] begin";
  DTPrimitives data[4];

  // Real amount of values extracted from each channel.
  int numPrimsPerLayer[4] = {0, 0, 0, 0};
  unsigned int canal;
  int channelEmptyCnt = 0;
  for (int layer = 0; layer <= 3; layer++) {
    canal = CHANNELS_PATH_ARRANGEMENTS[pathId][layer];
    if (muxInChannels_[canal].empty())
      channelEmptyCnt++;
  }

  if (channelEmptyCnt >= 2)
    return;
  //

  // We extract the number of elements necesary from each channel as the combination requires
  for (int layer = 0; layer < NUM_LAYERS; layer++) {
    canal = CHANNELS_PATH_ARRANGEMENTS[pathId][layer];
    unsigned int maxPrimsToBeRetrieved = muxInChannels_[canal].size();
    /*
    If the number of primitives is zero, in order to avoid that only one
    empty channel avoids mixing data from the other three, we, at least,
    consider one dummy element from this channel.
    In other cases, where two or more channels has zero elements, the final
    combination will be not analyzable (the condition for being analyzable is
    that it has at least three good TDC time values, not dummy), so it will
    be discarded and not sent to the analyzer.
  */
    if (maxPrimsToBeRetrieved == 0)
      maxPrimsToBeRetrieved = 1;

    for (unsigned int items = 0; items < maxPrimsToBeRetrieved; items++) {
      auto dtpAux = DTPrimitive();
      if (!muxInChannels_[canal].empty())
        dtpAux = DTPrimitive(&(muxInChannels_[canal].at(items)));

      /*
    I won't allow a whole loop cycle. When a DTPrimitive has an invalid
    time-stamp (TDC value = -1) it means that the buffer is empty or the
    buffer has reached the last element within the configurable time window.
    In this case the loop is broken, but only if there is, at least, one
    DTPrim (even invalid) on the outgoing array. This is mandatory to cope
        with the idea explained in the previous comment block
      */
      if (dtpAux.tdcTimeStamp() < 0 && items > 0)
        break;

      // In this new schema, if the hit corresponds with the SL over which
      // you are doing the mixings, it is sent to the intermediate mixing
      // buffer. In the opposite case, a blank and invalid copy is sent to
      // allow them mixing to be complete, as it was done in the one SL case.

      // This is a kind of quick solution in which there will be no few cases
      // where you will have invalid mixings. Because of that, the verification
      // that is done later, where the segment is analysed to check whether it
      // can be analysed is essential.
      if (dtpAux.superLayerId() == supLayer)
        data[layer].push_back(dtpAux);  // values are 0, 1, 2
      else
        data[layer].push_back(DTPrimitive());
      numPrimsPerLayer[layer]++;
    }
  }

  if (debug_)
    LogDebug("InitialGrouping") << "[InitialGrouping::mixChannels] filled data";

  // Here we do the different combinations and send them to the output FIFO.
  DTPrimitives ptrPrimitive;
  int chIdx[4];
  for (chIdx[0] = 0; chIdx[0] < numPrimsPerLayer[0]; chIdx[0]++) {
    for (chIdx[1] = 0; chIdx[1] < numPrimsPerLayer[1]; chIdx[1]++) {
      for (chIdx[2] = 0; chIdx[2] < numPrimsPerLayer[2]; chIdx[2]++) {
        for (chIdx[3] = 0; chIdx[3] < numPrimsPerLayer[3]; chIdx[3]++) {
          // We build a copy of the object so that we can manipulate each one
          // in each thread of the process independently, allowing us also to
          // delete them whenever it is necessary, without relying upon a
          // unique reference all over the code.

          for (int i = 0; i < NUM_LAYERS; i++) {
            ptrPrimitive.push_back((data[i])[chIdx[i]]);
            if (debug_)
              LogDebug("InitialGrouping")
                  << "[InitialGrouping::mixChannels] reading " << ptrPrimitive[i].tdcTimeStamp();
          }

          auto ptrMuonPath = std::make_shared<MuonPath>(ptrPrimitive);
          ptrMuonPath->setCellHorizontalLayout(CELL_HORIZONTAL_LAYOUTS[pathId]);

          /*
            This new version of this code is redundant with PathAnalyzer code,
            where every MuonPath not analyzable is discarded.
            I insert this discarding mechanism here, as well, to avoid inserting
            not-analyzable MuonPath into the candidate FIFO.
            Equivalent code must be removed in the future from PathAnalyzer, but
            it the mean time, at least during the testing state, I'll preserve
            both.
            Code in the PathAnalyzer should be doing nothing now.
          */
          if (debug_)
            LogDebug("InitialGrouping") << "[InitialGrouping::mixChannels] muonPath is analyzable? " << ptrMuonPath;
          if (ptrMuonPath->isAnalyzable()) {
            if (debug_)
              LogDebug("InitialGrouping") << "[InitialGrouping::mixChannels] YES";
            /*
            This is a very simple filter because, during the tests, it has been
            detected that many consecutive MuonPaths are duplicated mainly due
            to buffers empty (or dummy) that give a TDC time-stamp = -1
            With this filter, I'm removing those consecutive identical
            combinations.
            
            If duplicated combinations are not consecutive, they won't be
            detected here
        */
            if (!isEqualComb2Previous(ptrPrimitive)) {
              if (debug_)
                LogDebug("InitialGrouping") << "[InitialGrouping::mixChannels] isNOT equal to previous";
              ptrMuonPath->setBaseChannelId(currentBaseChannel_);
              outMuonPath.push_back(std::move(ptrMuonPath));
            }
            ptrPrimitive.clear();
          }
        }
      }
    }
  }
  for (int layer = 0; layer < NUM_LAYERS; layer++) {
    data[layer].clear();
  }
}

notEnoughDataInChannels()

bool InitialGrouping::notEnoughDataInChannels ( void  )

private

Definition at line 173 of file InitialGrouping.cc.

References muxInChannels_, and or.

Referenced by run().

                                                  {
  // Empty layer indicators
  bool lEmpty[4];

  lEmpty[0] = muxInChannels_[0].empty();

  lEmpty[1] = muxInChannels_[1].empty() && muxInChannels_[2].empty();

  lEmpty[2] = muxInChannels_[3].empty() && muxInChannels_[4].empty() && muxInChannels_[5].empty();

  lEmpty[3] =
      muxInChannels_[6].empty() && muxInChannels_[7].empty() && muxInChannels_[8].empty() && muxInChannels_[9].empty();

  // If there are at least two empty layers, you cannot link it to a possible trace
  if ((lEmpty[0] && lEmpty[1]) or (lEmpty[0] && lEmpty[2]) or (lEmpty[0] && lEmpty[3]) or (lEmpty[1] && lEmpty[2]) or
      (lEmpty[1] && lEmpty[3]) or (lEmpty[2] && lEmpty[3])) {
    return true;
  } else {
    return false;
  }
}

resetPrvTDCTStamp()

void InitialGrouping::resetPrvTDCTStamp ( void  )

private

Definition at line 195 of file InitialGrouping.cc.

References mps_fire::i, NUM_LAYERS, and prevTDCTimeStamps_.

Referenced by run().

                                            {
  for (int i = 0; i < NUM_LAYERS; i++)
    prevTDCTimeStamps_[i] = -1;
}

run()

void InitialGrouping::run ( edm::Event &  iEvent, const edm::EventSetup &  iEventSetup, const DTDigiCollection &  digis, MuonPathPtrs &  outMpath  )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 43 of file InitialGrouping.cc.

References currentBaseChannel_, debug_, LogDebug, mixChannels(), notEnoughDataInChannels(), cmsdt::NUM_SUPERLAYERS, resetPrvTDCTStamp(), selectInChannels(), setInChannels(), and cmsdt::TOTAL_BTI.

                                                {
  //   This function returns the analyzable mpath collection back to the the main function
  //   so it can be fitted. This is in fact doing the so-called grouping.

  for (int supLayer = 0; supLayer < NUM_SUPERLAYERS; supLayer++) {  // for each SL:
    if (debug_)
      LogDebug("InitialGrouping") << "InitialGrouping::run Reading SL" << supLayer;
    setInChannels(&digis, supLayer);

    for (int baseCh = 0; baseCh < TOTAL_BTI; baseCh++) {
      currentBaseChannel_ = baseCh;
      selectInChannels(currentBaseChannel_);  //map a number of wires for a given base channel
      if (notEnoughDataInChannels())
        continue;

      if (debug_)
        LogDebug("InitialGrouping") << "InitialGrouping::run --> now check pathId";
      for (int pathId = 0; pathId < 8; pathId++) {
        resetPrvTDCTStamp();
        if (debug_)
          LogDebug("InitialGrouping") << "[InitialGrouping::run] mixChannels calling";
        mixChannels(supLayer, pathId, mpaths);
        if (debug_)
          LogDebug("InitialGrouping") << "[InitialGrouping::run] mixChannels end";
      }
    }
  }
  if (debug_)
    LogDebug("InitialGrouping") << "[InitialGrouping::run] end";
}

selectInChannels()

void InitialGrouping::selectInChannels ( int  baseCh )

private

Definition at line 117 of file InitialGrouping.cc.

References channelIn_, chInDummy_, muxInChannels_, and cmsdt::NUM_CH_PER_LAYER.

Referenced by run().

                                                      {
  // Channels are labeled following next schema:
  // Input Muxer Indexes
  // ---------------------------------
  // |   6   |   7   |   8   |   9   |
  // ---------------------------------
  // |   3   |   4   |   5   |
  // -------------------------
  // |   1   |   2   |
  // -----------------
  // |   0   |
  // ---------

  // ****** LAYER 0 ******
  muxInChannels_[0] = channelIn_[0][baseChannel];

  // ****** LAYER 1 ******
  muxInChannels_[1] = channelIn_[1][baseChannel];

  if (baseChannel + 1 < NUM_CH_PER_LAYER)
    muxInChannels_[2] = channelIn_[1][baseChannel + 1];
  else
    muxInChannels_[2] = chInDummy_;

  // ****** LAYER 2 ******
  if (baseChannel - 1 >= 0)
    muxInChannels_[3] = channelIn_[2][baseChannel - 1];
  else
    muxInChannels_[3] = chInDummy_;

  muxInChannels_[4] = channelIn_[2][baseChannel];

  if (baseChannel + 1 < NUM_CH_PER_LAYER)
    muxInChannels_[5] = channelIn_[2][baseChannel + 1];
  else
    muxInChannels_[5] = chInDummy_;

  // ****** LAYER 3 ******
  if (baseChannel - 1 >= 0)
    muxInChannels_[6] = channelIn_[3][baseChannel - 1];
  else
    muxInChannels_[6] = chInDummy_;

  muxInChannels_[7] = channelIn_[3][baseChannel];

  if (baseChannel + 1 < NUM_CH_PER_LAYER)
    muxInChannels_[8] = channelIn_[3][baseChannel + 1];
  else
    muxInChannels_[8] = chInDummy_;

  if (baseChannel + 2 < NUM_CH_PER_LAYER)
    muxInChannels_[9] = channelIn_[3][baseChannel + 2];
  else
    muxInChannels_[9] = chInDummy_;
}

setInChannels()

void InitialGrouping::setInChannels ( const DTDigiCollection *  digi, int  sl  )

private

Definition at line 82 of file InitialGrouping.cc.

References channelIn_, debug_, nano_mu_digi_cff::layer, DTLayerId::layer(), LogDebug, cmsdt::NUM_CH_PER_LAYER, NUM_LAYERS, DetId::rawId(), edm::second(), DTSuperLayerId::superlayer(), and nano_mu_digi_cff::wire.

Referenced by run().

                                                                         {
  //   before setting channels we need to clear
  for (int lay = 0; lay < NUM_LAYERS; lay++) {
    for (int ch = 0; ch < NUM_CH_PER_LAYER; ch++) {
      channelIn_[lay][ch].clear();
    }
  }

  // now fill with those primitives that makes sense:
  for (const auto &dtLayerId_It : *digis) {
    const DTLayerId dtLId = dtLayerId_It.first;
    if (dtLId.superlayer() != sl + 1)
      continue;  //skip digis not in SL...

    for (DTDigiCollection::const_iterator digiIt = (dtLayerId_It.second).first; digiIt != (dtLayerId_It.second).second;
         ++digiIt) {
      int layer = dtLId.layer() - 1;
      int wire = (*digiIt).wire() - 1;
      int digiTIME = (*digiIt).time();
      int digiTIMEPhase2 = digiTIME;

      if (debug_)
        LogDebug("InitialGrouping") << "[InitialGrouping::setInChannels] SL" << sl << " L" << layer << " : " << wire
                                    << " " << digiTIMEPhase2;
      auto dtpAux = DTPrimitive();
      dtpAux.setTDCTimeStamp(digiTIMEPhase2);
      dtpAux.setChannelId(wire);
      dtpAux.setLayerId(layer);    //  L=0,1,2,3
      dtpAux.setSuperLayerId(sl);  // SL=0,1,2
      dtpAux.setCameraId(dtLId.rawId());
      channelIn_[layer][wire].push_back(dtpAux);
    }
  }
}

Member Data Documentation

channelIn_

DTPrimitives InitialGrouping::channelIn_[cmsdt::NUM_LAYERS][cmsdt::NUM_CH_PER_LAYER]

private

Definition at line 92 of file InitialGrouping.h.

Referenced by InitialGrouping(), selectInChannels(), and setInChannels().

chInDummy_

DTPrimitives InitialGrouping::chInDummy_

private

Definition at line 93 of file InitialGrouping.h.

Referenced by InitialGrouping(), and selectInChannels().

currentBaseChannel_

int InitialGrouping::currentBaseChannel_

private

Definition at line 95 of file InitialGrouping.h.

Referenced by mixChannels(), and run().

debug_

const bool InitialGrouping::debug_

private

Definition at line 89 of file InitialGrouping.h.

Referenced by InitialGrouping(), initialise(), mixChannels(), run(), setInChannels(), and ~InitialGrouping().

muxInChannels_

DTPrimitives InitialGrouping::muxInChannels_[cmsdt::NUM_CELLS_PER_BLOCK]

private

Definition at line 91 of file InitialGrouping.h.

Referenced by mixChannels(), notEnoughDataInChannels(), and selectInChannels().

prevTDCTimeStamps_

int InitialGrouping::prevTDCTimeStamps_[4]

private

Definition at line 94 of file InitialGrouping.h.

Referenced by isEqualComb2Previous(), and resetPrvTDCTStamp().