CSCALCTHeader Class Reference

#include <CSCALCTHeader.h>

Public Types
enum	FIFO_MODE { NO_DUMP, FULL_DUMP, LOCAL_DUMP }

Public Member Functions
unsigned short int	ActiveFEBs () const
void	add (const std::vector< CSCALCTDigi > &digis)
void	addShower (const std::vector< CSCShowerDigi > &digis)
	Add Run3 ALCT HMT shower bits. More...
std::vector< CSCALCTDigi >	ALCTDigis () const
unsigned short int	alctFirmwareRevision () const
unsigned short int	alctFirmwareVersion () const
CSCALCTHeader2006	alctHeader2006 () const
CSCALCTHeader2007	alctHeader2007 () const
std::vector< unsigned short int >	alctHMTs () const
std::vector< CSCShowerDigi >	alctShowerDigis () const
unsigned short int	BoardID () const
unsigned short int	BXNCount () const
bool	check () const
	CSCALCTHeader (int chamberType)
	CSCALCTHeader (const unsigned short *buf)
	for packing More...
	CSCALCTHeader (const CSCALCTStatusDigi &digi)
unsigned short int	CSCID () const
unsigned short int *	data ()
unsigned short int	ExtTrig () const
unsigned short int	FIFOMode () const
unsigned short int	L1Acc () const
unsigned short int	L1AMatch () const
unsigned short int	LCTChipRead () const
unsigned short int	nLCTChipRead () const
	for packing More...
unsigned short int	NTBins () const
boost::dynamic_bitset	pack ()
unsigned short int	Promote1 () const
unsigned short int	Promote2 () const
void	setBXNCount (unsigned int bxn)
void	setDAVForChannel (int wireGroup)
void	setEventInformation (const CSCDMBHeader &)
void	setL1Acc (unsigned int l1a)
int	sizeInWords ()
	in 16-bit words More...

Static Public Member Functions
static void	selfTest (int firmware)
	tests that we unpack what we packed More...
static void	setDebug (bool value)
	to access data by via status digis More...

Private Attributes
CSCALCTs2006	alcts2006
unsigned short int	bxn0
unsigned short int	bxn1
std::vector< CSCCollisionMask >	collisionMasks
CSCConfigurationRegister	configRegister
CSCALCTHeader2006	header2006
CSCALCTHeader2007	header2007
std::vector< CSCHotChannelMask >	hotChannelMasks
unsigned short int	sizeInWords2007_
	size of the 2007 header in words More...
std::vector< CSCALCT >	theALCTs
unsigned short int	theOriginalBuffer [116]
CSCVirtexID	virtexID

Static Private Attributes
static std::atomic< bool >	debug {false}
static std::atomic< unsigned short int >	firmwareVersion {2007}

Detailed Description

documented in flags http://www.phys.ufl.edu/~madorsky/alctv/alct2000_spec.PDF

Definition at line 22 of file CSCALCTHeader.h.

Member Enumeration Documentation

FIFO_MODE

enum CSCALCTHeader::FIFO_MODE

some accessors here are only applicable to 2006 header some to both 2006 and 2007

Enumerator
NO_DUMP
FULL_DUMP
LOCAL_DUMP

Definition at line 41 of file CSCALCTHeader.h.

{ NO_DUMP, FULL_DUMP, LOCAL_DUMP };

Constructor & Destructor Documentation

CSCALCTHeader() [1/3]

CSCALCTHeader::CSCALCTHeader ( int  chamberType )

explicit

Definition at line 22 of file CSCALCTHeader.cc.

References firmwareVersion, header2006, header2007, CSCALCTHeader2007::lctBins, CSCALCTHeader2006::sizeInWords(), CSCALCT::sizeInWords(), CSCALCTHeader2007::sizeInWords(), sizeInWords2007_, theALCTs, and theOriginalBuffer.

Referenced by CSCALCTHeader().

    : 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() [2/3]

CSCALCTHeader::CSCALCTHeader ( const unsigned short *  buf )

explicit

for packing

collision and hot channel masks are variable sized the sizes vary depending on type of the ALCT board number of words for various alct board types: 1 2 3 5 6







first determine the correct format

Now fill data

the header part

the alct0 and alct1

the fixed sized header part

now come the variable parts

2007 has LCTbins * 2 alct words

also store raw data buffer too; it is later returned by data() method

Definition at line 37 of file CSCALCTHeader.cc.

References ALCTDigis(), alcts2006, CSCALCTHeader2007::boardType, visDQMUpload::buf, collisionMasks, CSCALCTHeader2007::configPresent, configRegister, firmwareVersion, header2006, header2007, hotChannelMasks, mps_fire::i, CSCALCTHeader2007::lctBins, LogTrace, CSCALCTHeader2006::setFromBuffer(), CSCALCTHeader2007::setFromBuffer(), CSCALCTs2006::setFromBuffer(), CSCVirtexID::setFromBuffer(), CSCConfigurationRegister::setFromBuffer(), CSCALCTHeader2006::sizeInWords(), CSCALCTHeader2007::sizeInWords(), CSCALCTs2006::sizeInWords(), CSCVirtexID::sizeInWords(), CSCConfigurationRegister::sizeInWords(), sizeInWords(), sizeInWords2007_, theALCTs, theOriginalBuffer, and virtexID.

                                                      {
  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() [3/3]

CSCALCTHeader::CSCALCTHeader

(

const CSCALCTStatusDigi &

digi

)

Definition at line 117 of file CSCALCTHeader.cc.

References CSCALCTHeader(), and CSCALCTStatusDigi::header().

{ CSCALCTHeader(digi.header()); }

Member Function Documentation

ActiveFEBs()

unsigned short int CSCALCTHeader::ActiveFEBs ( ) const

inline

Definition at line 134 of file CSCALCTHeader.h.

References CSCALCTHeader2006::activeFEBs, and header2006.

{ return header2006.activeFEBs; }

add()

void CSCALCTHeader::add

(

const std::vector< CSCALCTDigi > &

digis

)

Definition at line 189 of file CSCALCTHeader.cc.

References CSCALCTs2006::add(), alcts2006, nano_mu_digi_cff::bx, firmwareVersion, header2007, mps_fire::i, CSCALCTHeader2007::lctBins, theALCTs, and validateGeometry_cfg::valid.

Referenced by CSCEventData::add(), check(), counter.Counter::register(), SequenceTypes._TaskBase::remove(), SequenceTypes._TaskBase::replace(), and selfTest().

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

addShower()

void CSCALCTHeader::addShower

(

const std::vector< CSCShowerDigi > &

digis

)

Add Run3 ALCT HMT shower bits.

Add ALCT anodes HMT shower bits per ALCT BX.

Definition at line 222 of file CSCALCTHeader.cc.

References CSCShowerDigi::bitsInTime(), nano_mu_digi_cff::bx, firmwareVersion, header2007, mps_fire::i, CSCShowerDigi::isValid(), CSCALCTHeader2007::lctBins, and theALCTs.

Referenced by CSCEventData::addAnodeALCTShower(), and check().

                                                                   {
  if (firmwareVersion == 2007) {
    if (theALCTs.empty()) {
      theALCTs.resize(header2007.lctBins * 2);
    }
    for (std::vector<CSCShowerDigi>::const_iterator digi = digis.begin(); digi != digis.end(); ++digi) {
      int bx = digi - digis.begin();
      if (bx < (int)header2007.lctBins) {
        const CSCShowerDigi &digi = digis[bx];
        int i = bx * 2;
        unsigned hmt_bits = digi.isValid() ? digi.bitsInTime() : 0;
        theALCTs[i].reserved = hmt_bits & 0x3;
        theALCTs[i + 1].reserved = hmt_bits & 0x3;
      }
    }
  }
}

ALCTDigis()

std::vector< CSCALCTDigi > CSCALCTHeader::ALCTDigis

(

)

const

loop over all alct words

Definition at line 152 of file CSCALCTHeader.cc.

References CSCALCTs2006::ALCTDigis(), alcts2006, BXNCount(), firmwareVersion, mps_fire::i, topSingleLeptonDQM_PU_cfi::pattern, quality, mps_fire::result, theALCTs, and validateGeometry_cfg::valid.

Referenced by CSCALCTHeader(), cscdqm::EventProcessor::processCSC(), and CSCEventData::unpack_data().

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

alctFirmwareRevision()

unsigned short int CSCALCTHeader::alctFirmwareRevision ( ) const

inline

Definition at line 139 of file CSCALCTHeader.h.

References CSCALCTHeader2007::firmwareVersion, firmwareVersion, and header2007.

Referenced by cscdqm::EventProcessor::processCSC().

                                                  {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return 0;
      case 2007:
        return header2007.firmwareVersion;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access ALCT firmware revision bits: ALCT firmware version is bad/not defined!";
        return 0;
    }
  }

alctFirmwareVersion()

unsigned short int CSCALCTHeader::alctFirmwareVersion ( ) const

inline

Definition at line 138 of file CSCALCTHeader.h.

References firmwareVersion.

Referenced by CSCEventData::checkALCTClasses(), and cscdqm::EventProcessor::processCSC().

{ return firmwareVersion; }

alctHeader2006()

CSCALCTHeader2006 CSCALCTHeader::alctHeader2006 ( ) const

inline

Definition at line 222 of file CSCALCTHeader.h.

References header2006.

{ return header2006; }

alctHeader2007()

CSCALCTHeader2007 CSCALCTHeader::alctHeader2007 ( ) const

inline

Definition at line 221 of file CSCALCTHeader.h.

References header2007.

{ return header2007; }

alctHMTs()

std::vector<unsigned short int> CSCALCTHeader::alctHMTs ( ) const

inline

Definition at line 187 of file CSCALCTHeader.h.

References nano_mu_digi_cff::bx, firmwareVersion, header2007, CSCALCTHeader2007::lctBins, mysort::results, and theALCTs.

                                                 {
    std::vector<unsigned short int> results;
    results.clear();
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return results;
      case 2007:
        // if (alctFirmwareRevision() >= 0) // TODO: Need ALCT Run3 firmware revision to properly detect presense of HMT bits in data format
        // {
        if ((!theALCTs.empty()) && (theALCTs.size() == unsigned(header2007.lctBins * 2))) {
          for (unsigned bx = 0; bx < header2007.lctBins; bx++) {
            results.push_back(theALCTs[bx * 2].reserved & 0x3);
          }
          return results;
        } else
          return results;
        // } else return results;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access ALCT HMT bits: ALCT firmware version is bad/not defined!";
        return results;
    }
  }

alctShowerDigis()

std::vector<CSCShowerDigi> CSCALCTHeader::alctShowerDigis ( ) const

inline

Definition at line 156 of file CSCALCTHeader.h.

References nano_mu_digi_cff::bx, firmwareVersion, header2007, CSCALCTHeader2007::lctBins, mysort::results, and theALCTs.

Referenced by cscdqm::EventProcessor::processCSC().

                                                   {
    std::vector<CSCShowerDigi> results;
    results.clear();
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return results;
      case 2007:
        // if (alctFirmwareRevision() >= 0) // TODO: Need ALCT Run3 firmware revision to properly detect presense of HMT bits in data format
        // {
        if ((!theALCTs.empty()) && (theALCTs.size() == unsigned(header2007.lctBins * 2))) {
          for (unsigned bx = 0; bx < header2007.lctBins; bx++) {
            //CSCID is set to be 0
            //ALCTshower, showerType_= 1, wireNHits and ComparatorNHits are not available in data
            results.push_back(
                CSCShowerDigi(theALCTs[bx * 2].reserved & 0x3, 0, 0, bx, CSCShowerDigi::ShowerType::kALCTShower, 0, 0));
          }
          return results;
        } else
          return results;
        // } else return results;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access ALCT HMT Shower Digis bits: ALCT firmware version is bad/not defined!";
        return results;
    }
  }

BoardID()

unsigned short int CSCALCTHeader::BoardID ( ) const

inline

Definition at line 59 of file CSCALCTHeader.h.

References CSCALCTHeader2006::boardID, and header2006.

{ return header2006.boardID; }

BXNCount()

unsigned short int CSCALCTHeader::BXNCount ( ) const

inline

Definition at line 62 of file CSCALCTHeader.h.

References CSCALCTHeader2007::bxnCount, CSCALCTHeader2006::bxnCount, firmwareVersion, header2006, and header2007.

Referenced by ALCTDigis(), and cscdqm::EventProcessor::processCSC().

                                      {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.bxnCount;
      case 2007:
        return header2007.bxnCount;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access BXNcount: ALCT firmware version is bad/not defined!";
        return 0;
    }
  }

check()

bool CSCALCTHeader::check ( ) const

inline

Definition at line 243 of file CSCALCTHeader.h.

References add(), addShower(), simCaloStage2Digis_cfi::firmware, firmwareVersion, CSCALCTHeader2007::flag1, CSCALCTHeader2006::flag_0, header2006, header2007, pack(), and selfTest().

Referenced by CSCEventData::unpack_data().

                     {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.flag_0 == 0xC;
      case 2007:
        return header2007.flag1 == 0xDB0A;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi") << "check(): ALCT firmware version is bad/not defined!";
        return false;
    }
  }

CSCID()

unsigned short int CSCALCTHeader::CSCID ( ) const

inline

Definition at line 61 of file CSCALCTHeader.h.

References CSCALCTHeader2006::cscID, and header2006.

{ return header2006.cscID; }

data()

unsigned short int* CSCALCTHeader::data ( )

inline

Definition at line 224 of file CSCALCTHeader.h.

References theOriginalBuffer.

Referenced by CSCEventData::pack(), pack(), and CSCEventData::unpack_data().

{ return theOriginalBuffer; }

ExtTrig()

unsigned short int CSCALCTHeader::ExtTrig ( ) const

inline

Definition at line 60 of file CSCALCTHeader.h.

References CSCALCTHeader2006::extTrig, and header2006.

{ return header2006.extTrig; }

FIFOMode()

unsigned short int CSCALCTHeader::FIFOMode ( ) const

inline

Definition at line 42 of file CSCALCTHeader.h.

References CSCALCTHeader2006::fifoMode, and header2006.

{ return header2006.fifoMode; }

L1Acc()

unsigned short int CSCALCTHeader::L1Acc ( ) const

inline

Definition at line 98 of file CSCALCTHeader.h.

References firmwareVersion, header2006, header2007, CSCALCTHeader2006::l1Acc, and CSCALCTHeader2007::l1aCounter.

Referenced by cscdqm::EventProcessor::processCSC().

                                   {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.l1Acc;
      case 2007:
        return header2007.l1aCounter;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access L1Acc: ALCT firmware version is bad/not defined!";
        return 0;
    }
  }

L1AMatch()

unsigned short int CSCALCTHeader::L1AMatch ( ) const

inline

Definition at line 133 of file CSCALCTHeader.h.

References header2006, and CSCALCTHeader2006::l1aMatch.

{ return header2006.l1aMatch; }

LCTChipRead()

unsigned short int CSCALCTHeader::LCTChipRead ( ) const

inline

Definition at line 137 of file CSCALCTHeader.h.

References header2006, and CSCALCTHeader2006::lctChipRead.

{ return header2006.lctChipRead; }

nLCTChipRead()

unsigned short CSCALCTHeader::nLCTChipRead

(

)

const

for packing

header2006 method

Definition at line 140 of file CSCALCTHeader.cc.

References firmwareVersion, header2006, and CSCALCTHeader2006::nLCTChipRead().

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

NTBins()

unsigned short int CSCALCTHeader::NTBins ( ) const

inline

Definition at line 43 of file CSCALCTHeader.h.

References firmwareVersion, header2006, header2007, CSCALCTHeader2006::nTBins, and CSCALCTHeader2007::rawBins.

                                    {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.nTBins;
      case 2007:
        return header2007.rawBins;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to access NTBINs: ALCT firmware version is bad/not defined!";
        return 0;
    }
  }

pack()

boost::dynamic_bitset CSCALCTHeader::pack

(

)

Definition at line 240 of file CSCALCTHeader.cc.

References alcts2006, bitset_utilities::append(), bitset_utilities::bitsetToChar(), data(), firmwareVersion, RecoTauValidation_cfi::header, header2006, header2007, mps_fire::i, mps_fire::result, CSCALCTHeader2006::sizeInWords(), CSCALCTHeader2007::sizeInWords(), CSCALCTs2006::sizeInWords(), sizeInWords(), theALCTs, and bitset_utilities::ushortToBitset().

Referenced by check(), and CSCEventData::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;
}

Promote1()

unsigned short int CSCALCTHeader::Promote1 ( ) const

inline

Definition at line 135 of file CSCALCTHeader.h.

References header2006, and CSCALCTHeader2006::promote1.

{ return header2006.promote1; }

Promote2()

unsigned short int CSCALCTHeader::Promote2 ( ) const

inline

Definition at line 136 of file CSCALCTHeader.h.

References header2006, and CSCALCTHeader2006::promote2.

{ return header2006.promote2; }

selfTest()

void CSCALCTHeader::selfTest ( int  firmware )

static

tests that we unpack what we packed

Definition at line 266 of file CSCALCTHeader.cc.

References add(), cms::cuda::assert(), hcalRecHitTable_cff::detId, simCaloStage2Digis_cfi::firmware, firmwareVersion, and relativeConstraints::station.

Referenced by check().

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

setBXNCount()

void CSCALCTHeader::setBXNCount ( unsigned int  bxn )

inline

Definition at line 79 of file CSCALCTHeader.h.

References CSCALCTHeader2007::bxnCount, CSCALCTHeader2006::bxnCount, firmwareVersion, header2006, and header2007.

Referenced by CSCEventData::add().

                                     {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        header2006.bxnCount = bxn % 0xFFF;
        break;
      case 2007:
        header2007.bxnCount = bxn % 0xFFF;
        break;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
            << "trying to set BXNcount: ALCT firmware version is bad/not defined!";
        break;
    }
  }

setDAVForChannel()

void CSCALCTHeader::setDAVForChannel ( int  wireGroup )

inline

Definition at line 215 of file CSCALCTHeader.h.

References firmwareVersion, header2006, CSCALCTHeader2006::setDAV(), and nano_mu_digi_cff::wireGroup.

Referenced by CSCEventData::add().

                                       {
    if (firmwareVersion == 2006) {
      header2006.setDAV((wireGroup - 1) / 16);
    }
  }

setDebug()

static void CSCALCTHeader::setDebug ( bool  value )

inlinestatic

to access data by via status digis

turns on the debug flag for this class

Definition at line 31 of file CSCALCTHeader.h.

References debug, and relativeConstraints::value.

Referenced by CSCDCCUnpacker::CSCDCCUnpacker().

{ debug = value; };

setEventInformation()

void CSCALCTHeader::setEventInformation

(

const CSCDMBHeader &

dmb

)

Definition at line 119 of file CSCALCTHeader.cc.

References firmwareVersion, header2006, header2007, CSCALCTHeader2006::setEventInformation(), and CSCALCTHeader2007::setEventInformation().

Referenced by CSCEventData::checkALCTClasses(), and CSCEventData::setEventInformation().

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

setL1Acc()

void CSCALCTHeader::setL1Acc ( unsigned int  l1a )

inline

Definition at line 115 of file CSCALCTHeader.h.

References firmwareVersion, header2006, header2007, CSCALCTHeader2006::l1Acc, and CSCALCTHeader2007::l1aCounter.

                                  {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        header2006.l1Acc = l1a % 0xF;
        break;
      case 2007:
        header2007.l1aCounter = l1a % 0xFFF;
        break;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi") << "trying to set L1Acc: ALCT firmware version is bad/not defined!";
        break;
    }
  }

sizeInWords()

int CSCALCTHeader::sizeInWords ( )

inline

in 16-bit words

Definition at line 227 of file CSCALCTHeader.h.

References firmwareVersion, and sizeInWords2007_.

Referenced by CSCEventData::checkALCTClasses(), CSCALCTHeader(), CSCEventData::pack(), pack(), and CSCEventData::unpack_data().

                    {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return 8;
      case 2007:
        return sizeInWords2007_;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi") << "SizeInWords(): ALCT firmware version is bad/not defined!";
        return 0;
    }
  }

Member Data Documentation

alcts2006

CSCALCTs2006 CSCALCTHeader::alcts2006

private

Definition at line 272 of file CSCALCTHeader.h.

Referenced by add(), ALCTDigis(), CSCALCTHeader(), and pack().

bxn0

unsigned short int CSCALCTHeader::bxn0

private

Definition at line 291 of file CSCALCTHeader.h.

bxn1

unsigned short int CSCALCTHeader::bxn1

private

Definition at line 291 of file CSCALCTHeader.h.

collisionMasks

std::vector<CSCCollisionMask> CSCALCTHeader::collisionMasks

private

Definition at line 275 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

configRegister

CSCConfigurationRegister CSCALCTHeader::configRegister

private

Definition at line 274 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

debug

std::atomic< bool > CSCALCTHeader::debug {false}

staticprivate

Definition at line 286 of file CSCALCTHeader.h.

Referenced by util.rrapi.RRApi::dprint(), rrapi.RRApi::dprint(), pkg.AbstractPkg::generate(), rrapi.RRApi::get(), util.rrapi.RRApi::get(), pkg.AbstractPkg::get_kwds(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), setDebug(), and pkg.AbstractPkg::write().

firmwareVersion

std::atomic< short unsigned int > CSCALCTHeader::firmwareVersion {2007}

staticprivate

Definition at line 287 of file CSCALCTHeader.h.

Referenced by add(), addShower(), ALCTDigis(), alctFirmwareRevision(), alctFirmwareVersion(), alctHMTs(), alctShowerDigis(), BXNCount(), check(), CSCALCTHeader(), L1Acc(), nLCTChipRead(), NTBins(), pack(), selfTest(), setBXNCount(), setDAVForChannel(), setEventInformation(), setL1Acc(), and sizeInWords().

header2006

CSCALCTHeader2006 CSCALCTHeader::header2006

private

Definition at line 269 of file CSCALCTHeader.h.

Referenced by ActiveFEBs(), alctHeader2006(), BoardID(), BXNCount(), check(), CSCALCTHeader(), CSCID(), ExtTrig(), FIFOMode(), L1Acc(), L1AMatch(), LCTChipRead(), nLCTChipRead(), NTBins(), pack(), Promote1(), Promote2(), setBXNCount(), setDAVForChannel(), setEventInformation(), and setL1Acc().

header2007

CSCALCTHeader2007 CSCALCTHeader::header2007

private

Definition at line 270 of file CSCALCTHeader.h.

Referenced by add(), addShower(), alctFirmwareRevision(), alctHeader2007(), alctHMTs(), alctShowerDigis(), BXNCount(), check(), CSCALCTHeader(), L1Acc(), NTBins(), pack(), setBXNCount(), setEventInformation(), and setL1Acc().

hotChannelMasks

std::vector<CSCHotChannelMask> CSCALCTHeader::hotChannelMasks

private

Definition at line 276 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

sizeInWords2007_

unsigned short int CSCALCTHeader::sizeInWords2007_

private

size of the 2007 header in words

Definition at line 291 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader(), and sizeInWords().

theALCTs

std::vector<CSCALCT> CSCALCTHeader::theALCTs

private

Definition at line 271 of file CSCALCTHeader.h.

Referenced by add(), addShower(), ALCTDigis(), alctHMTs(), alctShowerDigis(), CSCALCTHeader(), and pack().

theOriginalBuffer

unsigned short int CSCALCTHeader::theOriginalBuffer[116]

private

Definition at line 280 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader(), and data().

virtexID

CSCVirtexID CSCALCTHeader::virtexID

private

Definition at line 273 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().