LumiRawDataStructures.h

Go to the documentation of this file.

#ifndef RecoLuminosity_LumiProducer_LUMIRAWDATASTRUCTURES_H
#define RecoLuminosity_LumiProducer_LUMIRAWDATASTRUCTURES_H
//Note: this header file corresponds to svn.cern.ch/reps/Luminosity/HLXReadOut/HLXCoreLibs/include/LumiStructures.hh - Revision 512 LumiDAQ
/*
  LumiNibble structure definitions
*/
 
// The string and stream definitions
// Type definitions used by the HAL, etc...
 
#define HCAL_HLX_MAX_BUNCHES 4096
#define HCAL_HLX_MAX_HLXS 36
 
// Changes
// Namespace for the HCAL HLX
#include <cstdint>
 
namespace HCAL_HLX {
 
  struct DAQ_HEART_BEAT {
    uint32_t runNumber;
    uint32_t sectionNumber;
    uint32_t bCMSLive;
 
    uint32_t timestamp;
    uint32_t timestamp_micros;
  };
 
  struct RUN_SUMMARY {
    char runSequenceName[128];
    uint32_t HLTConfigId;
    uint32_t timestamp;
    uint32_t timestamp_micros;
    uint32_t startOrbitNumber;
    uint32_t endOrbitnumber;
 
    uint32_t runNumber;
    uint32_t fillNumber;
 
    uint32_t numberCMSLumiSections;  // number of lumi sections from the trigger
    uint32_t numberLumiDAQLumiSections;
  };
 
  struct RUN_QUALITY {
    uint32_t runNumber;
    uint32_t sectionNumber;
 
    int HLX;
    int HFLumi;
    int ECAL;
    int HCAL;
    int Tracker;
    int RPC;
    int DT;
    int CSC;
  };
 
  struct RCMS_CONFIG {
    uint32_t runNumber;
 
    char CMSSW_Tag[32];
    char TriDAS_Tag[32];
 
    uint32_t FirmwareVersion;
    uint32_t ExpectedFirmwareVersion;
    char AddressTablePath[256];
 
    char CfgDBTag[64];
    char CfgDBAccessor[64];
    bool UseConfigDB;
 
    uint32_t DestIPHigh;
    uint32_t DestIPLow;
 
    uint32_t SrcIPBaseHigh;
    uint32_t SrcIPBaseLow;
 
    uint32_t DestMacAddrHigh;
    uint32_t DestMacAddrMed;
    uint32_t DestMacAddrLow;
 
    uint32_t SrcMacAddrHigh;
    uint32_t SrcMacAddrMed;
    uint32_t SrcMacAddrLow;
 
    uint32_t SrcPort;
    uint32_t DestPort;
 
    uint32_t DebugData;
    uint32_t DebugReadout;
    uint32_t DebugSingleCycle;
 
    uint32_t NumOrbits;
    uint32_t OrbitPeriod;
 
    uint32_t Id;
 
    uint32_t TTCBC0Pattern;
    uint32_t TTCSTARTPattern;
    uint32_t TTCSTOPPattern;
 
    uint32_t BC0Delay;
 
    uint32_t OccThresholdLowBottom;
    uint32_t OccThresholdLowTop;
    uint32_t OccThresholdHighBottom;
    uint32_t OccThresholdHighTop;
 
    uint32_t LHCThresholdBottom;
    uint32_t LHCThresholdTop;
 
    uint32_t ETSumCutoffBottom;
    uint32_t ETSumCutoffTop;
 
    uint32_t OCCMaskBottom;
    uint32_t OCCMaskTop;
 
    uint32_t LHCMaskLowBottom;
    uint32_t LHCMaskLowTop;
    uint32_t LHCMaskHighBottom;
    uint32_t LHCMaskHighTop;
 
    uint32_t SumETMaskLowBottom;
    uint32_t SumETMaskLowTop;
    uint32_t SumETMaskHighBottom;
    uint32_t SumETMaskHighTop;
  };
 
  struct LUMI_SUMMARY {
    float DeadTimeNormalization;
    float LHCNormalization;  // recieved from LHC
 
    float InstantLumi;
    float InstantLumiErr;
    int16_t InstantLumiQlty;
 
    float InstantETLumi;
    float InstantETLumiErr;
    int16_t InstantETLumiQlty;
    float ETNormalization;  // Calculated
 
    float InstantOccLumi[2];
    float InstantOccLumiErr[2];
    int16_t InstantOccLumiQlty[2];
    float OccNormalization[2];
 
    float lumiNoise[2];
  };
 
  struct LUMI_DETAIL {
    float LHCLumi[HCAL_HLX_MAX_BUNCHES];  // Sum of LHC.data over all HLX's
 
    float ETLumi[HCAL_HLX_MAX_BUNCHES];
    float ETLumiErr[HCAL_HLX_MAX_BUNCHES];
    int16_t ETLumiQlty[HCAL_HLX_MAX_BUNCHES];
    float ETBXNormalization[HCAL_HLX_MAX_BUNCHES];
 
    float OccLumi[2][HCAL_HLX_MAX_BUNCHES];
    float OccLumiErr[2][HCAL_HLX_MAX_BUNCHES];
    int16_t OccLumiQlty[2][HCAL_HLX_MAX_BUNCHES];
    float OccBXNormalization[2][HCAL_HLX_MAX_BUNCHES];
  };
 
  /**************** Trigger *********************/
 
  struct LEVEL1_PATH {
    char pathName[128];
    uint64_t counts;
    uint64_t prescale;
  };
 
  struct LEVEL1_TRIGGER {
    uint32_t runNumber;
    uint32_t sectionNumber;  // Lumi section number recorded by the daq.
 
    uint32_t timestamp;
    uint32_t timestamp_micros;
 
    uint64_t deadtimecount;
 
    char GTLumiInfoFormat[32];
 
    LEVEL1_PATH GTAlgo[128];
    LEVEL1_PATH GTTech[64];
  };
 
  struct HLT_PATH {      // only object that uses STL and is variable size.
    char PathName[128];  //This is the name of trigger path
    uint32_t L1Pass;     //Number of times the path was entered
    uint32_t PSPass;     //Number after prescaling
    uint32_t PAccept;    //Number of accepts by the trigger path
    uint32_t PExcept;    //Number of exceptional event encountered
    uint32_t PReject;
    char PrescalerModule[64];  //Name of the prescale module in the path
    uint32_t PSIndex;          //Index into the set of pre defined prescales
    uint32_t Prescale;
 
    uint32_t HLTConfigId;
  };
 
  struct HLTRIGGER {
    uint32_t runNumber;
    uint32_t sectionNumber;
    uint32_t numPaths;
 
    HLT_PATH HLTPaths[256];
  };
 
  /***************** Internal use ****************/
  struct LUMI_RAW_HEADER {  // Used in NibbleCollector
    uint16_t marker;
    uint8_t hlxID;
    uint8_t packetID;
    uint32_t startOrbit;
    uint16_t numOrbits;
    uint16_t startBunch;  // Starting bunch in this packet
    uint16_t numBunches;  // Total number of bunches in histogram
    uint8_t histogramSet;
    uint8_t histogramSequence;
    uint16_t allA;
    uint16_t allF;
  };
 
  struct LUMI_NIBBLE_HEADER {
    uint32_t startOrbit;
    uint16_t numOrbits;
    uint16_t numBunches;  // Number of bunches histogrammed
    bool bCMSLive;
    bool bOC0;
  };
 
  struct ET_SUM_NIBBLE {
    LUMI_NIBBLE_HEADER hdr;
    uint32_t data[HCAL_HLX_MAX_BUNCHES];
  };
 
  struct OCCUPANCY_NIBBLE {
    LUMI_NIBBLE_HEADER hdr;
    uint16_t data[6][HCAL_HLX_MAX_BUNCHES];
  };
 
  struct LHC_NIBBLE {
    LUMI_NIBBLE_HEADER hdr;
    uint16_t data[HCAL_HLX_MAX_BUNCHES];
  };
 
  //***********************************************************
 
  struct LUMI_SECTION_HEADER {
    uint32_t timestamp;
    uint32_t timestamp_micros;
 
    uint32_t runNumber;      // Run number
    uint32_t sectionNumber;  // Section number
 
    uint32_t startOrbit;  // Start orbit of lumi section
    uint32_t numOrbits;   // Total number of orbits recorded in lumi section
    uint16_t numBunches;  // Total number of bunches (from start of orbit)
    uint16_t numHLXs;     // Number of HLXs in lumi section
 
    bool bCMSLive;  // Is CMS taking data?
    bool bOC0;      // Was section initialised by an OC0?
  };
 
  struct LUMI_SECTION_SUB_HEADER {
    uint32_t numNibbles;  // Number of nibbles in this histogram
    bool bIsComplete;     // Is this histogram complete (i.e. no missing nibbles)
  };
 
  struct ET_SUM_SECTION {
    LUMI_SECTION_SUB_HEADER hdr;
    float data[HCAL_HLX_MAX_BUNCHES];
  };
 
  struct OCCUPANCY_SECTION {
    LUMI_SECTION_SUB_HEADER hdr;
    uint32_t data[6][HCAL_HLX_MAX_BUNCHES];
  };
 
  struct LHC_SECTION {
    LUMI_SECTION_SUB_HEADER hdr;
    uint32_t data[HCAL_HLX_MAX_BUNCHES];
  };
 
  struct LUMI_SECTION {
    LUMI_SECTION_HEADER hdr;
    LUMI_SUMMARY lumiSummary;
    LUMI_DETAIL lumiDetail;
 
    ET_SUM_SECTION etSum[HCAL_HLX_MAX_HLXS];
    OCCUPANCY_SECTION occupancy[HCAL_HLX_MAX_HLXS];
    LHC_SECTION lhc[HCAL_HLX_MAX_HLXS];
  };
 
  struct DIP_STRUCT_BASE {
    int MessageQuality;
    uint32_t timestamp;
    uint32_t timestamp_micros;
    uint32_t runNumber;
    uint32_t sectionNumber;
  };
 
  struct VDM_SCAN_DATA : public DIP_STRUCT_BASE {
    bool VdmMode;  //True when a scan at one of the IPs is imminent, false otherwise
    int IP;
    bool RecordDataFlag;  // True while data for one of the scan points at one of the IPs is being taken, false otherwise
    double BeamSeparation;  //separation in sigma for the scan point
    bool isXaxis;           //true if scanning xaxis, otherwise yaxis is being scanned
    int Beam;
    double StepProgress;
  };
 
  struct BRAN_DATA : public DIP_STRUCT_BASE {
    double MeanCrossingAngle;
    int AcqMode;
    double MeanLuminosity;
  };
 
  struct BRAN_BX_DATA : public DIP_STRUCT_BASE {
    double bunchByBunchLuminosity[3564];
    int AcqMode;
  };
 
  struct LHC_BEAM_CONFIG : public DIP_STRUCT_BASE {
    int beamConfig[3564];
  };
 
  struct LHC_FILL_DATA : public DIP_STRUCT_BASE {
    uint32_t FillNumber;
  };
 
  struct CMS_LUMI_DIP_DATA : public DIP_STRUCT_BASE {
    uint32_t numHLXs;
    uint32_t startOrbit;
    uint32_t numOrbits;
    uint32_t numBunches;
    float instantLumi;
    float instantLumiErr;
  };
 
  struct CMS_LUMI_LH_DIP_DATA : public DIP_STRUCT_BASE {
    float lumiHisto[3564];
    uint32_t numBunches;
  };
 
  struct CMS_STATUS_DATA : public DIP_STRUCT_BASE {
    char status[64];
  };
 
  struct TRIGGER_LUMI_SEGMENT : public DIP_STRUCT_BASE {
    char state[64];
    uint32_t deadtime;
    uint32_t deadtimeBeamActive;
    uint32_t lumiSegmentNumber;
  };
 
  struct LHC_BEAM_MODE_DATA : public DIP_STRUCT_BASE {
    char beamMode[64];
  };
 
  struct LHC_BEAM_ENERGY_DATA : public DIP_STRUCT_BASE {
    float singleBeamEnergy;  //GeV
  };
 
  struct LHC_BEAM_INTENSITY_DATA : public DIP_STRUCT_BASE {
    double beamIntensity;  //total num protons in beam summed over all bxs
    double primitiveLifetime;
    uint64_t acqTimeStamp;
  };
 
  struct LHC_BEAM_FBCT_INTENSITY_DATA : public DIP_STRUCT_BASE {
    double bestLifetime;
    double averageBeamIntensity;
    float averageBunchIntensities[3564];
  };
 
  struct CMS_SCAN_TUNE_DATA : public DIP_STRUCT_BASE {
    double IntTime;
    double CollRate;
    double CollRateErr;
    bool Preferred;
    char Source[64];
  };
 
  struct DIP_ACQUISITION_MODE : public DIP_STRUCT_BASE {
    char mode[64];
  };
 
  struct BEAM_INFO {
    double totalIntensity;
    double primitiveLifetime;
    double bestLifeTime;
    double averageBeamIntensity;
    float orbitFrequency;
    float averageBunchIntensities[3564];
    int beamConfig[3564];
  };
 
  struct BRANA_INFO {
    double meanCrossingAngle;
    int acqMode;
    double meanLuminosity;
    double bunchByBunchLuminosity[3564];
  };
 
  struct BRANP_INFO {
    double meanCrossingAngle;
    int acqMode;
    int counterAcquisition;
    double meanLuminosity;
    double meanCrossingAngleError;
    double meanLuminosityError;
    double bunchByBunchLuminosity[3564];
  };
 
  struct BRAN_INFO {
    BRANA_INFO branA;
    BRANP_INFO branP;
  };
 
  struct DIP_COMBINED_DATA : public DIP_STRUCT_BASE {
    char beamMode[128];
 
    float Energy;
 
    uint32_t FillNumber;
 
    BEAM_INFO Beam[2];
 
    BRAN_INFO BRAN4L1;
    BRAN_INFO BRAN4R1;
    BRAN_INFO BRAN4L5;
    BRAN_INFO BRAN4R5;
 
    VDM_SCAN_DATA VdMScan;
  };
 
}  // namespace HCAL_HLX
 
#endif  //RecoLuminosity_LumiProducer_LUMIRAWDATASTRUCTURES_H