/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/EventFilter/CSCRawToDigi/src/CSCCLCTData.cc

Go to the documentation of this file.

#include "EventFilter/CSCRawToDigi/interface/CSCCLCTData.h"
#include "EventFilter/CSCRawToDigi/interface/CSCTMBHeader.h"
#include "DataFormats/MuonDetId/interface/CSCDetId.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include <cstdio>
#include <cstring>

bool CSCCLCTData::debug = false;


CSCCLCTData::CSCCLCTData(const CSCTMBHeader * tmbHeader)
: ncfebs_(tmbHeader->NCFEBs()), ntbins_(tmbHeader->NTBins())
{
  size_ = nlines();
  zero();
}


CSCCLCTData::CSCCLCTData(int ncfebs, int ntbins)
: ncfebs_(ncfebs), ntbins_(ntbins) 
{
  size_ = nlines();
  zero();
}
     



CSCCLCTData::CSCCLCTData(int ncfebs, int ntbins, const unsigned short * buf)
: ncfebs_(ncfebs), ntbins_(ntbins) 
{
  // add two more for odd ntbins, plus one for the e0c
  // Oct 2004 Rick: e0c line belongs to CSCTMBTrailer
  size_ = (nlines()%2==1)? nlines()+2 : nlines();
  
  memcpy(theData, buf, size_*2);
  
}


void CSCCLCTData::zero()
{
  for(int ifeb = 0; ifeb < ncfebs_; ++ifeb)
    {
      for(int tbin = 0; tbin < ntbins_; ++tbin)
        {
          for(int layer = 1; layer <= 6; ++layer)
            {
              dataWord(ifeb, tbin, layer) = CSCCLCTDataWord(ifeb, tbin, 0);
            }
        }
    }

}


std::vector<CSCComparatorDigi>  CSCCLCTData::comparatorDigis(uint32_t idlayer, unsigned cfeb) 
{
  static const bool doStripSwapping = true;
  bool me1a = (CSCDetId::station(idlayer)==1) && (CSCDetId::ring(idlayer)==4);
  bool zplus = (CSCDetId::endcap(idlayer) == 1); 
  bool me1b = (CSCDetId::station(idlayer)==1) && (CSCDetId::ring(idlayer)==1);
  unsigned layer = CSCDetId::layer(idlayer);

  //looking for comp output on layer
  std::vector<CSCComparatorDigi> result;
  assert(layer>0 && layer<= 6);
  // this is pretty sparse data, so I wish we could check the
  // data word by word, not bit by bit, but I don't see how to
  // do the time sequencing that way.
  for(int distrip = 0; distrip < 8; ++distrip) 
    {
      uint16_t tbinbitsS0HS0=0;
      uint16_t tbinbitsS0HS1=0;
      uint16_t tbinbitsS1HS0=0;
      uint16_t tbinbitsS1HS1=0;
      for(int tbin = 0; tbin < ntbins_-2; ++tbin) 
        {
          if(bitValue(cfeb, tbin, layer, distrip))
            {
              CSCCLCTDataWord word = dataWord(cfeb, tbin, layer);
              assert(word.tbin_ == tbin);
              assert(word.cfeb_ == cfeb);
              // we have a hit.  The next two time samples
              // are the other two bits in the triad
              int bit2 = bitValue(cfeb, tbin+1, layer, distrip);
              int bit3 = bitValue(cfeb, tbin+2, layer, distrip);
              // should count from zero
              int chamberDistrip = distrip + cfeb*8;
              int HalfStrip = 4*chamberDistrip + bit2*2 + bit3;
              int output = 4 + bit2*2 + bit3;
              /*
               * Handles distrip logic; comparator output is for pairs of strips:
               * hit  bin  dec
               * x--- 100   4
               * -x-- 101   5
               * --x- 110   6
               * ---x 111   7
               *
               */

        if (debug)
          LogTrace ("CSCCLCTData|CSCRawToDigi")
                  << "fillComparatorOutputs: layer = "
                  << layer << " timebin = " << tbin
                  << " cfeb = " << cfeb << " distrip = " << chamberDistrip
                  << " HalfStrip = " << HalfStrip
                  << " Output " << output << std::endl;

              if (output==4) tbinbitsS0HS0=tbinbitsS0HS0+(1<<tbin);      
              if (output==5) tbinbitsS0HS1=tbinbitsS0HS1+(1<<tbin);
              if (output==6) tbinbitsS1HS0=tbinbitsS1HS0+(1<<tbin);
              if (output==7) tbinbitsS1HS1=tbinbitsS1HS1+(1<<tbin);
              
              tbin += 2;
            }
        }//end of loop over time bins
      //we do not have to check over the last couple of time bins if there are no hits since
      //comparators take 3 time bins

      // Store digis each of possible four halfstrips for given distrip:
      if (tbinbitsS0HS0 || tbinbitsS0HS1 || tbinbitsS1HS0 || tbinbitsS1HS1) {
        unsigned int cfeb_corr    = cfeb;
        unsigned int distrip_corr = distrip;

        if (doStripSwapping) {
          // Fix ordering of strips and CFEBs in ME1/1.
          // SV, 27/05/08: keep CFEB=4 for ME1/a until CLCT trigger logic
          // stops combining it with the info from the other 4 CFEBs (ME1/b).
          // if ( me1a )           { cfeb_corr = 0; } // reset 4 to 0
          if ( me1a &&  zplus ) {distrip_corr = 7-distrip;} // 0-7 -> 7-0
          if ( me1b && !zplus ) {distrip_corr = 7-distrip; cfeb_corr = 3-cfeb;}
        }

        int strip = 16*cfeb_corr + 2*distrip_corr + 1;

        if (debug)
          LogTrace ("CSCCLCTData|CSCRawToDigi")
            << "fillComparatorOutputs: cfeb_corr = " << cfeb_corr
            << " distrip_corr = " << distrip_corr << " strip = " << strip;

        if (doStripSwapping && (( me1a && zplus ) || ( me1b && !zplus ))) {
          // Half-strips need to be flipped too.
          if (tbinbitsS1HS1) result.push_back(CSCComparatorDigi(strip, 0, tbinbitsS1HS1));
          if (tbinbitsS1HS0) result.push_back(CSCComparatorDigi(strip, 1, tbinbitsS1HS0));
          if (tbinbitsS0HS1) result.push_back(CSCComparatorDigi(strip+1, 0, tbinbitsS0HS1));
          if (tbinbitsS0HS0) result.push_back(CSCComparatorDigi(strip+1, 1, tbinbitsS0HS0));
        }
        else {
          if (tbinbitsS0HS0) result.push_back(CSCComparatorDigi(strip, 0, tbinbitsS0HS0));
          if (tbinbitsS0HS1) result.push_back(CSCComparatorDigi(strip, 1, tbinbitsS0HS1));
          if (tbinbitsS1HS0) result.push_back(CSCComparatorDigi(strip+1, 0, tbinbitsS1HS0));
          if (tbinbitsS1HS1) result.push_back(CSCComparatorDigi(strip+1, 1, tbinbitsS1HS1));
        }
        //uh oh ugly ugly ugly!
      }
    }//end of loop over distrips
  return result;
}



std::vector<CSCComparatorDigi>  CSCCLCTData::comparatorDigis(int layer) 
{
  //returns comparators for one layer for all cfebs
  std::vector<CSCComparatorDigi> result;
  assert(layer>0 && layer<= 6);

  for(int cfeb = 0; cfeb < ncfebs_; ++cfeb) 
    {
      std::vector<CSCComparatorDigi> oneCfebDigi = comparatorDigis(layer,cfeb);
      result.insert(result.end(), oneCfebDigi.begin(), oneCfebDigi.end());      
    }

  return result;
}


void CSCCLCTData::add(const CSCComparatorDigi & digi, int layer)
{
  //FIXME do flipping
  int strip = digi.getStrip();
  int halfStrip = (strip-1)*2 + digi.getComparator();
  int cfeb = (strip-1)/16;
  int distrip = ((strip-1)%16) / 2;
  assert(distrip < 8 && cfeb < 6 && halfStrip < 161);

  std::vector<int> timeBinsOn = digi.getTimeBinsOn();
  for(std::vector<int>::const_iterator tbinItr = timeBinsOn.begin();
      tbinItr != timeBinsOn.end(); ++tbinItr)
  {
    int tbin = *tbinItr;
    if(tbin >= 0 && tbin < ntbins_-2) {
      // First triad bit indicates the presence of the hit
      dataWord(cfeb, tbin, layer).set(distrip, true);
      // Second bit indicates which of the two strips contains the hit
      if (strip%2 == 0)
        dataWord(cfeb, tbin+1, layer).set(distrip, true);
      // Third bit indicates whether the hit is located on the left or on the
      // right side of the strip.
      if (digi.getComparator())
        dataWord(cfeb, tbin+2, layer).set(distrip, true);
    }
  }
}


bool CSCCLCTData::check() const 
{
  bool result = true;
  for(int cfeb = 0; cfeb < ncfebs_; ++cfeb) 
    {
      for(int tbin = 0; tbin < ntbins_; ++tbin)
        {
          for(int layer = 1; layer <= 6; ++layer) 
            {
              const CSCCLCTDataWord & word = dataWord(cfeb, tbin, layer);
              bool wordIsGood = (word.tbin_ == tbin) && (word.cfeb_ == cfeb);
              result = result && wordIsGood;
              if(!wordIsGood && debug)
                {
                  LogTrace("CSCCLCTData|CSCRawToDigi") << "Bad CLCT data  in layer " << layer 
                                               << " expect CFEB " << cfeb << " tbin " << tbin;
                  LogTrace("CSCCLCTData|CSCRawToDigi") << " See " << word.cfeb_ << " " 
                                               << word.tbin_;
                }
            }
        }
    }
  if(!result) LogTrace("CSCCLCTData|CSCRawToDigi") << "++ Bad CLCT Data ++ ";
  return result;
}


void CSCCLCTData::dump() const {
   for (int i=0;i<size_;i++) {
      printf("%04x %04x %04x %04x\n", theData[i+3], theData[i+2], theData[i+1], theData[i]);
      i+=3;
   }
}


void CSCCLCTData::selfTest()
{
  CSCCLCTData clctData(5, 16);
  // aim for output 4 in 5th time bin, = 0000000000010000
  CSCComparatorDigi comparatorDigi1(1, 0, 0x10);
  // aim for output 5 in 6th time bin, = 0000 0000 0010 0000
  CSCComparatorDigi comparatorDigi2(39, 1, 0x20);
  // aim for output 7 in 7th time bin, = 000 0000 0100 0000
  CSCComparatorDigi comparatorDigi3(80, 1, 0x40);

  clctData.add(comparatorDigi1,1);
  clctData.add(comparatorDigi2,4);
  clctData.add(comparatorDigi3,6);

  CSCDetId layer1(1,4,1,2,1);  
  CSCDetId layer4(1,4,1,2,4);
  CSCDetId layer6(1,4,1,2,6);

  std::vector<CSCComparatorDigi> digis1 = clctData.comparatorDigis(1);
  std::vector<CSCComparatorDigi> digis2 = clctData.comparatorDigis(4);
  std::vector<CSCComparatorDigi> digis3 = clctData.comparatorDigis(6);

  assert(digis1.size() == 1);
  assert(digis2.size() == 1);
  assert(digis3.size() == 1);

  assert(digis1[0].getStrip() == 1);
  assert(digis1[0].getComparator() == 0);
  assert(digis1[0].getTimeBin() == 4);

  assert(digis2[0].getStrip() == 39);
  assert(digis2[0].getComparator() == 1);
  assert(digis2[0].getTimeBin() == 5);

  assert(digis3[0].getStrip() == 80);
  assert(digis3[0].getComparator() == 1);
  assert(digis3[0].getTimeBin() == 6);
}