#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_

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.

     : MotherGrouping(pset, iC), currentBaseChannel_(-1) {
   // Obtention of parameters
   debug_ = pset.getUntrackedParameter<bool>("debug");
   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();
     }
   }
 }

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

◆ ~InitialGrouping()

InitialGrouping::~InitialGrouping ( )

override

Definition at line 31 of file InitialGrouping.cc.

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

References debug_, and LogDebug.

Member Function Documentation

◆ finish()

void InitialGrouping::finish ( )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 78 of file InitialGrouping.cc.

78 { return; };

Referenced by progressbar.ProgressBar::__next__().

◆ initialise()

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

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 39 of file InitialGrouping.cc.

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

References debug_, and LogDebug.

◆ isEqualComb2Previous()

bool InitialGrouping::isEqualComb2Previous ( DTPrimitives & ptr )

private

Definition at line 201 of file InitialGrouping.cc.

                                                                 {
   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;
 }

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

Referenced by mixChannels().

◆ mixChannels()

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

private

Definition at line 216 of file InitialGrouping.cc.

                                                                                      {
   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();
   }
 }

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

Referenced by run().

◆ notEnoughDataInChannels()

bool InitialGrouping::notEnoughDataInChannels ( void )

private

Definition at line 174 of file InitialGrouping.cc.

                                                   {
   // 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;
   }
 }

References muxInChannels_, and or.

Referenced by run().

◆ resetPrvTDCTStamp()

void InitialGrouping::resetPrvTDCTStamp ( void )

private

Definition at line 196 of file InitialGrouping.cc.

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

References mps_fire::i, NUM_LAYERS, and prevTDCTimeStamps_.

Referenced by run().

◆ run()

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

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 44 of file InitialGrouping.cc.

                                                 {
   //   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";
 }

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

◆ selectInChannels()

void InitialGrouping::selectInChannels ( int baseCh )

private

Definition at line 118 of file InitialGrouping.cc.

                                                       {
   // 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_;
 }

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

Referenced by run().

◆ setInChannels()

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

private

Definition at line 83 of file InitialGrouping.cc.

                                                                          {
   //   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);
     }
   }
 }