CSCALCTHeader.cc

Go to the documentation of this file.

#include "EventFilter/CSCRawToDigi/interface/CSCALCTHeader.h"
#include "EventFilter/CSCRawToDigi/interface/CSCDMBHeader.h"
#include "DataFormats/MuonDetId/interface/CSCDetId.h"
#include "EventFilter/CSCRawToDigi/src/bitset_append.h"
#include "EventFilter/CSCRawToDigi/src/cscPackerCompare.h"
#include <iomanip>

#ifdef LOCAL_UNPACK

bool CSCALCTHeader::debug=false;
short unsigned int CSCALCTHeader::firmwareVersion=2007;

#else

#include <atomic>

std::atomic<bool> CSCALCTHeader::debug{false};
std::atomic<short unsigned int> CSCALCTHeader::firmwareVersion{2007}; 

#endif

CSCALCTHeader::CSCALCTHeader(int chamberType)
: header2006(chamberType),
  header2007(chamberType)
{ //constructor for digi->raw packing based on header2006 
  if (firmwareVersion==2006)
  {
    memcpy(theOriginalBuffer, &header2006, header2006.sizeInWords()*2);
  }
  else if(firmwareVersion==2007)
  {
    memcpy(theOriginalBuffer, &header2007, header2007.sizeInWords()*2);
    // assume no virtex or masks or registers
    sizeInWords2007_ = header2007.sizeInWords() + header2007.lctBins*CSCALCT::sizeInWords()*2;
    theALCTs.resize(header2007.lctBins*2);
  }
  else
  {
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
      <<"Cannot construct ALCT header: ALCT firmware version is bad/not defined!" << firmwareVersion;
  }

}

CSCALCTHeader::CSCALCTHeader(const unsigned short * buf) {
  constexpr unsigned short int collisionMaskWordcount[7]    = { 8, 8,12,16,16,24,28};
  constexpr unsigned short int hotChannelMaskWordcount[7]   = {18,18,24,36,36,48,60};

  if (buf[0]==0xDB0A) {
    firmwareVersion=2007;
  }
  else if ( (buf[0]&0xF800)==0x6000 ) {
    firmwareVersion=2006;
  }
  else {
    edm::LogError("CSCALCTHeader|CSCRawToDigi") << "failed to determine ALCT firmware version!!";
  }

  LogTrace("CSCALCTHeader|CSCRawToDigi") << "firmware version - " << firmwareVersion;

#ifdef LOCAL_UNPACK
  switch (firmwareVersion) {
#else
  switch (firmwareVersion.load()) {
#endif 
  case 2006:
    header2006.setFromBuffer(buf);
    buf +=header2006.sizeInWords();
    alcts2006.setFromBuffer(buf);
    buf +=alcts2006.sizeInWords();
    break;

  case 2007:
    header2007.setFromBuffer(buf); 
    buf +=header2007.sizeInWords();
    sizeInWords2007_ = header2007.sizeInWords();
    if (header2007.configPresent==1) {
      virtexID.setFromBuffer(buf);
      buf +=virtexID.sizeInWords();
      sizeInWords2007_ = virtexID.sizeInWords();
      configRegister.setFromBuffer(buf);
      buf +=configRegister.sizeInWords();
      sizeInWords2007_ += configRegister.sizeInWords();

      collisionMasks.resize(collisionMaskWordcount[header2007.boardType]);
      for (unsigned int i=0; i<collisionMaskWordcount[header2007.boardType]; ++i){
    collisionMasks[i].setFromBuffer(buf);
    buf += collisionMasks[i].sizeInWords();
    sizeInWords2007_ += collisionMasks[i].sizeInWords();
      }

      hotChannelMasks.resize(hotChannelMaskWordcount[header2007.boardType]);
      for (unsigned int i=0; i<hotChannelMaskWordcount[header2007.boardType]; ++i) {
    hotChannelMasks[i].setFromBuffer(buf);
    buf += hotChannelMasks[i].sizeInWords();
    sizeInWords2007_ += hotChannelMasks[i].sizeInWords();
      }
    }

    theALCTs.resize(header2007.lctBins*2); 
    for (int i=0; i<header2007.lctBins*2; ++i) {
      theALCTs[i].setFromBuffer(buf);
      buf += theALCTs[i].sizeInWords(); 
      sizeInWords2007_ += theALCTs[i].sizeInWords();
    }

    ALCTDigis();
    break;

  default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
      <<"couldn't construct: ALCT firmware version is bad/not defined!";
    break;
  }

  if ((firmwareVersion==2006)||(firmwareVersion==2007))
    memcpy(theOriginalBuffer, buf-sizeInWords(), sizeInWords()*2);
  
}


CSCALCTHeader::CSCALCTHeader(const CSCALCTStatusDigi & digi){
  CSCALCTHeader(digi.header());
}

void CSCALCTHeader::setEventInformation(const CSCDMBHeader & dmb) {
#ifdef LOCAL_UNPACK
 switch (firmwareVersion) {
#else
 switch (firmwareVersion.load()) {
#endif
 case 2006:
    {
    header2006.setEventInformation(dmb);
    break;
    }
  case 2007:
    {
    header2007.setEventInformation(dmb);
        break;
    }
  default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
      <<"setEventInformation: ALCT firmware version is bad/not defined!" << firmwareVersion;
    break;
  }
}


unsigned short CSCALCTHeader::nLCTChipRead() const {
  if(firmwareVersion == 2006) {
    return header2006.nLCTChipRead();
  }
  else {
    // nLCTChip obsolete in ALCT2007 format (email Andrey K. & Victor B., 20.10.2008)
    // and we don't think anyone makes uses of this call.
    //    edm::LogError("CSCALCTHeader|CSCRawToDigi")
    //      <<"How is nLCTChipRead() supposed to work for ALCTHeader2007?";
  }
  return 0;
}


std::vector<CSCALCTDigi> CSCALCTHeader::ALCTDigis() const 
{ 
  std::vector<CSCALCTDigi> result;

#ifdef LOCAL_UNPACK
  switch (firmwareVersion) {
#else
  switch (firmwareVersion.load()) {
#endif
  case 2006:
    {
      result = alcts2006.ALCTDigis();
      break;
    }
  case 2007:
    {
      result.reserve(theALCTs.size());
      for (unsigned int i=0; i<theALCTs.size(); ++i) {
    CSCALCTDigi digi(theALCTs[i].valid, theALCTs[i].quality, theALCTs[i].accel, theALCTs[i].pattern,
             theALCTs[i].keyWire, (int)i/2, i%2+1);
    result.push_back(digi);
      }
      break;
    }
  default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
      <<"Empty Digis: ALCT firmware version is bad/not defined!" << firmwareVersion; 
    break;
  }
  for(unsigned i = 0; i < result.size(); ++i) {result[i].setFullBX(BXNCount());}
  return result;

}


void CSCALCTHeader::add(const std::vector<CSCALCTDigi> & digis)
{
  if(firmwareVersion == 2006) {
      alcts2006.add(digis);
  }
  else if(firmwareVersion == 2007) {
    if(theALCTs.empty())
    {
      theALCTs.resize(header2007.lctBins*2);
    }
    for(std::vector<CSCALCTDigi>::const_iterator digi = digis.begin();
        digi != digis.end(); ++digi)
    {
      int bx = digi->getBX();
      if(bx < (int)header2007.lctBins) 
      {
        // 2 ALCTs per bx
        int i = bx*2;
        int q1 = theALCTs[i].quality;
        int q2 = theALCTs[i+1].quality;
        // see if it's non=blank
        if(!theALCTs[i].valid)
        {
          theALCTs[i] = CSCALCT(*digi);
        }
        // new best LCT
        else if(digi->getQuality() > q1)
        {
          theALCTs[i+1] = theALCTs[i];
          theALCTs[i] = CSCALCT(*digi);
        }
        // new second best
        else if(!theALCTs[i+1].valid || (digi->getQuality() > q2))
        {
          theALCTs[i+1] = CSCALCT(*digi);
        }
      }
    }
  }
}


boost::dynamic_bitset<> CSCALCTHeader::pack()
{
  boost::dynamic_bitset<> result;
  if(firmwareVersion == 2006)
  {
     boost::dynamic_bitset<> header
       = bitset_utilities::ushortToBitset(header2006.sizeInWords()*16,
                                          (unsigned short *) &header2006);
     boost::dynamic_bitset<> alcts 
       = bitset_utilities::ushortToBitset(alcts2006.sizeInWords()*16,
                                          (unsigned short *) &alcts2006);
     result = bitset_utilities::append(header, alcts);

     bitset_utilities::bitsetToChar(result, (unsigned char *) data());
  }

  else if(firmwareVersion == 2007)
  {
    result = bitset_utilities::ushortToBitset(header2007.sizeInWords()*16,
                                          (unsigned short *) &header2007);

    for (unsigned i = 0; i < theALCTs.size(); ++i)
    {
       boost::dynamic_bitset<> alct
         = bitset_utilities::ushortToBitset(theALCTs[i].sizeInWords()*16,
                                          (unsigned short *) &theALCTs[i]);
       result = bitset_utilities::append(result, alct);
    }

    bitset_utilities::bitsetToChar(result, (unsigned char *) data());

  }
  return result;
}
    


void CSCALCTHeader::selfTest(int firmware)
{
  firmwareVersion = firmware;
  CSCALCTDigi alct0(true, 1, 1, 1, 10, 6, 1);
  CSCALCTDigi alct1(true, 1, 1, 0, 11, 6, 2);

    // tests packing and unpacking
    for(int station = 1; station <= 4; ++station)
    {
      CSCDetId detId(1, station, 1, 1, 0);

      std::vector<CSCALCTDigi> oldAlcts;
      oldAlcts.push_back(alct0);
      oldAlcts.push_back(alct1);
      CSCALCTHeader alctHeader(detId.iChamberType());

      alctHeader.add(oldAlcts);

      std::vector<CSCALCTDigi> alcts = alctHeader.ALCTDigis();
      // pick out the valid ones
      std::vector<CSCALCTDigi> validALCTs;
      for(std::vector<CSCALCTDigi>::const_iterator alctItr = alcts.begin();
          alctItr != alcts.end(); ++ alctItr)
      {
        if(alctItr->isValid())
        {
          validALCTs.push_back(*alctItr);
        }
      }
      assert(validALCTs[0] == alct0);
      assert(validALCTs[1] == alct1);
      //cscClassPackerCompare(alctHeader);
    }
}

std::ostream & operator<<(std::ostream & os, const CSCALCTHeader & header) 
{
  os << "ALCT HEADER CSCID " << header.CSCID()
     << "  L1ACC " << header.L1Acc() << std::endl;
  os << " time samples " << header.NTBins() << std::endl;
  return os;
}