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)
std::vector< CSCALCTDigi >	ALCTDigis () const
unsigned short int	alctFirmwareVersion () const
CSCALCTHeader2006	alctHeader2006 () const
CSCALCTHeader2007	alctHeader2007 () const
unsigned short int	BoardID () const
unsigned short int	BXNCount () const
bool	check () const
	CSCALCTHeader (const CSCALCTStatusDigi &digi)
	CSCALCTHeader (const unsigned short *buf)
	for packing More...
	CSCALCTHeader (int chamberType)
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 21 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 40 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.

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

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

Referenced by CSCALCTHeader().

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.

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

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.

CSCALCTHeader() [3/3]

CSCALCTHeader::CSCALCTHeader

(

const CSCALCTStatusDigi &

digi

)

Definition at line 117 of file CSCALCTHeader.cc.

{ CSCALCTHeader(digi.header()); }

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

Member Function Documentation

ActiveFEBs()

unsigned short int CSCALCTHeader::ActiveFEBs ( ) const

inline

Definition at line 133 of file CSCALCTHeader.h.

{ return header2006.activeFEBs; }

References CSCALCTHeader2006::activeFEBs, and header2006.

add()

void CSCALCTHeader::add

(

const std::vector< CSCALCTDigi > &

digis

)

Definition at line 189 of file CSCALCTHeader.cc.

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

References CSCALCTs2006::add(), alcts2006, l1GtPatternGenerator_cfi::bx, firmwareVersion, header2007, mps_fire::i, CSCALCTHeader2007::lctBins, q1, q2, theALCTs, and RunInfoPI::valid.

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

ALCTDigis()

std::vector< CSCALCTDigi > CSCALCTHeader::ALCTDigis

(

)

const

loop over all alct words

Definition at line 152 of file CSCALCTHeader.cc.

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

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

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

alctFirmwareVersion()

unsigned short int CSCALCTHeader::alctFirmwareVersion ( ) const

inline

Definition at line 137 of file CSCALCTHeader.h.

{ return firmwareVersion; }

References firmwareVersion.

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

alctHeader2006()

CSCALCTHeader2006 CSCALCTHeader::alctHeader2006 ( ) const

inline

Definition at line 144 of file CSCALCTHeader.h.

{ return header2006; }

References header2006.

alctHeader2007()

CSCALCTHeader2007 CSCALCTHeader::alctHeader2007 ( ) const

inline

Definition at line 143 of file CSCALCTHeader.h.

{ return header2007; }

References header2007.

BoardID()

unsigned short int CSCALCTHeader::BoardID ( ) const

inline

Definition at line 58 of file CSCALCTHeader.h.

{ return header2006.boardID; }

References CSCALCTHeader2006::boardID, and header2006.

BXNCount()

unsigned short int CSCALCTHeader::BXNCount ( ) const

inline

Definition at line 61 of file CSCALCTHeader.h.

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

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

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

check()

bool CSCALCTHeader::check ( ) const

inline

Definition at line 165 of file CSCALCTHeader.h.

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

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

Referenced by CSCEventData::unpack_data().

CSCID()

unsigned short int CSCALCTHeader::CSCID ( ) const

inline

Definition at line 60 of file CSCALCTHeader.h.

{ return header2006.cscID; }

References CSCALCTHeader2006::cscID, and header2006.

data()

unsigned short int* CSCALCTHeader::data ( )

inline

Definition at line 146 of file CSCALCTHeader.h.

{ return theOriginalBuffer; }

References theOriginalBuffer.

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

ExtTrig()

unsigned short int CSCALCTHeader::ExtTrig ( ) const

inline

Definition at line 59 of file CSCALCTHeader.h.

{ return header2006.extTrig; }

References CSCALCTHeader2006::extTrig, and header2006.

FIFOMode()

unsigned short int CSCALCTHeader::FIFOMode ( ) const

inline

Definition at line 41 of file CSCALCTHeader.h.

{ return header2006.fifoMode; }

References CSCALCTHeader2006::fifoMode, and header2006.

L1Acc()

unsigned short int CSCALCTHeader::L1Acc ( ) const

inline

Definition at line 97 of file CSCALCTHeader.h.

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

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

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

L1AMatch()

unsigned short int CSCALCTHeader::L1AMatch ( ) const

inline

Definition at line 132 of file CSCALCTHeader.h.

{ return header2006.l1aMatch; }

References header2006, and CSCALCTHeader2006::l1aMatch.

LCTChipRead()

unsigned short int CSCALCTHeader::LCTChipRead ( ) const

inline

Definition at line 136 of file CSCALCTHeader.h.

{ return header2006.lctChipRead; }

References header2006, and CSCALCTHeader2006::lctChipRead.

nLCTChipRead()

unsigned short CSCALCTHeader::nLCTChipRead

(

)

const

for packing

header2006 method

Definition at line 140 of file CSCALCTHeader.cc.

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

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

NTBins()

unsigned short int CSCALCTHeader::NTBins ( ) const

inline

Definition at line 42 of file CSCALCTHeader.h.

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

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

pack()

boost::dynamic_bitset CSCALCTHeader::pack

(

)

Definition at line 221 of file CSCALCTHeader.cc.

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

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().

Promote1()

unsigned short int CSCALCTHeader::Promote1 ( ) const

inline

Definition at line 134 of file CSCALCTHeader.h.

{ return header2006.promote1; }

References header2006, and CSCALCTHeader2006::promote1.

Promote2()

unsigned short int CSCALCTHeader::Promote2 ( ) const

inline

Definition at line 135 of file CSCALCTHeader.h.

{ return header2006.promote2; }

References header2006, and CSCALCTHeader2006::promote2.

selfTest()

void CSCALCTHeader::selfTest ( int  firmware )

static

tests that we unpack what we packed

Definition at line 247 of file CSCALCTHeader.cc.

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

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

Referenced by check().

setBXNCount()

void CSCALCTHeader::setBXNCount ( unsigned int  bxn )

inline

Definition at line 78 of file CSCALCTHeader.h.

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

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

Referenced by CSCEventData::add().

setDAVForChannel()

void CSCALCTHeader::setDAVForChannel ( int  wireGroup )

inline

Definition at line 138 of file CSCALCTHeader.h.

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

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

Referenced by CSCEventData::add().

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 30 of file CSCALCTHeader.h.

{ debug = value; };

References debug, and relativeConstraints::value.

Referenced by CSCDCCUnpacker::CSCDCCUnpacker().

setEventInformation()

void CSCALCTHeader::setEventInformation

(

const CSCDMBHeader &

dmb

)

Definition at line 119 of file CSCALCTHeader.cc.

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

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

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

setL1Acc()

void CSCALCTHeader::setL1Acc ( unsigned int  l1a )

inline

Definition at line 114 of file CSCALCTHeader.h.

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

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

sizeInWords()

int CSCALCTHeader::sizeInWords ( )

inline

in 16-bit words

Definition at line 149 of file CSCALCTHeader.h.

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

References firmwareVersion, and sizeInWords2007_.

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

Member Data Documentation

alcts2006

CSCALCTs2006 CSCALCTHeader::alcts2006

private

Definition at line 192 of file CSCALCTHeader.h.

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

bxn0

unsigned short int CSCALCTHeader::bxn0

private

Definition at line 211 of file CSCALCTHeader.h.

bxn1

unsigned short int CSCALCTHeader::bxn1

private

Definition at line 211 of file CSCALCTHeader.h.

collisionMasks

std::vector<CSCCollisionMask> CSCALCTHeader::collisionMasks

private

Definition at line 195 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

configRegister

CSCConfigurationRegister CSCALCTHeader::configRegister

private

Definition at line 194 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

debug

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

staticprivate

Definition at line 206 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 207 of file CSCALCTHeader.h.

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

header2006

CSCALCTHeader2006 CSCALCTHeader::header2006

private

Definition at line 189 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 190 of file CSCALCTHeader.h.

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

hotChannelMasks

std::vector<CSCHotChannelMask> CSCALCTHeader::hotChannelMasks

private

Definition at line 196 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().

sizeInWords2007_

unsigned short int CSCALCTHeader::sizeInWords2007_

private

size of the 2007 header in words

Definition at line 211 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader(), and sizeInWords().

theALCTs

std::vector<CSCALCT> CSCALCTHeader::theALCTs

private

Definition at line 191 of file CSCALCTHeader.h.

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

theOriginalBuffer

unsigned short int CSCALCTHeader::theOriginalBuffer[116]

private

Definition at line 200 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader(), and data().

virtexID

CSCVirtexID CSCALCTHeader::virtexID

private

Definition at line 193 of file CSCALCTHeader.h.

Referenced by CSCALCTHeader().