TriggerDefines.cpp

Go to the documentation of this file.

#include "DAQDataFormats/TriggerDefines.h"

// See https://cdcvs.fnal.gov/redmine/documents/253 for more info

namespace daqdataformats{
// Initialization of constant data associated with the trigger

// Verbose names for bits
  const char* trigIDStrings[] = {
    "NuMI Beam Spill Trigger",      // Bit 0
    "Booster Beam Spill Trigger",   // Bit 1
    "Periodic Calibration Pulser",  // Bit 2
    "Random Calibration Pulser",    // Bit 3
    "Manually Issued Trigger",      // Bit 4
    "Accelerator PPS Trigger",      // Bit 5
    "Periodic Streamer Pulser",     // Bit 6
    "Random Streamer Pulser",       // Bit 7
    "DAQ Status Block",             // Bit 8
    "Not Defined",                  // Bit 9
    "Not Defined",                  // Bit 10
    "Not Defined",                  // Bit 11
    "Data Driven Supernova",        // Bit 12
    "Data Driven Energy",           // Bit 13
    "Data Driven Calibration Muon", // Bit 14
    "Data Driven Upmu",             // Bit 15
    "Data Driven Numu",             // Bit 16
    "Data Driven Nue",              // Bit 17
    "Data Driven Fast Monopole",    // Bit 18
    "Data Driven Slow Monople",     // Bit 19
    "Data Driven FEB Overflow",     // Bit 20
    "Data Driven Activity 1",       // Bit 21
    "Data Driven Activity 2",       // Bit 22
    "Monte Carlo/Simulation Trigger", // Bit 23
    // Start Middle Trigger Word
    "SNEWS Trigger",                  // Bit 24
    "SNEWS Beat Slow",                // Bit 25
    "SNEWS Beat Fast",                // Bit 26
    "Data Driven Contained Vertex",   // Bit 27
    "Data Driven Moon",               // Bit 28
    "Data Driven Sun",                // Bit 29
    "Data Driven Michel",             // Bit 30
    "Supernova Cross-trigger",        // Bit 31
    "Data Driven Michel Variant 2",   // Bit 32
    "Data Driven Michel Variant 3",   // Bit 33
    "Data Driven Michel Variant 4",   // Bit 34
    "Data Driven Michel Test",        // Bit 35
    "Data Driven Fast Monopole Neural Network",           // Bit 36
    "Data Driven Fast Monopole Neural Network Variant 2", // Bit 37
    "Data Driven Fast Monopole Neural Network Variant 3", // Bit 38
    "Data Driven Fast Monopole Neural Network Test",      // Bit 39
    "LIGO Trigger",                   // Bit 40
    "LIGO Beat Slow",                 // Bit 41
    "LIGO Beat Fast",                 // Bit 42
    "Testbeam Whole Spill",           // Bit 43
    "Testbeam Triggered Particle",    // Bit 44
    "Data Driven Neutron-Antineutron",// Bit 45
    "Data Driven Horizontal Muon",    // Bit 46
    "Not Defined",                    // Bit 47
    "Not Defined",                    // Bit 48
    "Not Defined",                    // Bit 49
    "Not Defined",                    // Bit 50
    "Not Defined",                    // Bit 51
    "Not Defined",                    // Bit 52
    "Not Defined",                    // Bit 53
    "Not Defined",                    // Bit 54
    "Not Defined",                    // Bit 55
    "Not Defined",                    // Bit 56
    "Not Defined",                    // Bit 57
    "Not Defined",                    // Bit 58
    "Not Defined",                    // Bit 59
    "Not Defined",                    // Bit 60
    "Not Defined",                    // Bit 61
    "Not Defined",                    // Bit 62
    "Not Defined",                    // Bit 63
    "Not Defined",                    // Bit 64
    "Not Defined",                    // Bit 65
    "Not Defined",                    // Bit 66
    "Not Defined",                    // Bit 67
    "Not Defined",                    // Bit 68
    "Not Defined",                    // Bit 69
    "Not Defined",                    // Bit 70
    "Not Defined",                    // Bit 71
    "Not Defined",                    // Bit 72
    "Not Defined",                    // Bit 73
    "Not Defined",                    // Bit 74
    "Not Defined",                    // Bit 75
    "Not Defined",                    // Bit 76
    "Not Defined",                    // Bit 77
    "Not Defined",                    // Bit 78
    "Not Defined",                    // Bit 79
    "Not Defined",                    // Bit 80
    "Not Defined",                    // Bit 81
    "Not Defined",                    // Bit 82
    "Not Defined",                    // Bit 83
    "Not Defined",                    // Bit 84
    "Not Defined",                    // Bit 85
    "Not Defined",                    // Bit 86
    "Not Defined",                    // Bit 87
    "Not Defined",                    // Bit 88
  };

// Terse names for bits
  const char* trigIDShortStrings[] = {
    "NuMI",                // Bit 0
    "BnB",                 // Bit 1
    "PerCal",              // Bit 2
    "RandCal",             // Bit 3
    "Manual",              // Bit 4
    "PPS",                 // Bit 5
    "PerStream",           // Bit 6
    "RandStream",          // Bit 7
    "DAQStatus",           // Bit 8
    "ND",                  // Bit 9
    "ND",                  // Bit 10
    "ND",                  // Bit 11
    "DDSN",                // Bit 12
    "DDenergy",            // Bit 13
    "DDcalmu",             // Bit 14
    "DDupmu",              // Bit 15
    "DDnumu",              // Bit 16
    "DDnue",               // Bit 17
    "DDfastmono",          // Bit 18
    "DDslowmono",          // Bit 19
    "FEBOverflow",         // Bit 20
    "DDActivity1",         // Bit 21
    "DDActivity2",         // Bit 22
    "MC",                  // Bit 23
    // Start Middle Trigger Word
    "SNEWSTrig",           // Bit 24
    "SNEWSBeatSlow",       // Bit 25
    "SNEWSBeatFast",       // Bit 26
    "DDContained",         // Bit 27
    "DDMoon",              // Bit 28
    "DDSun",               // Bit 29
    "DDMichel",            // Bit 30
    "SNXTrig",             // Bit 31
    "DDMichelV2",          // Bit 32
    "DDMichelV3",          // Bit 33
    "DDMichelV4",          // Bit 34
    "DDMichelTest",        // Bit 35
    "DDFastMonoNN",        // Bit 36
    "DDFastMonoNNV2",      // Bit 37
    "DDFastMonoNNV3",      // Bit 38
    "DDFastMonoNNTest",    // Bit 39
    "LIGOTrig",            // Bit 40
    "LIGOBeatSlow",        // Bit 41
    "LIGOBeatFast",        // Bit 42
    "TBSpill",             // Bit 43
    "TBTrig",              // Bit 44
    "DDNNBar",             // Bit 45
    "DDHmu",               // Bit 46
    "ND",                  // Bit 47
    "ND",                  // Bit 48
    "ND",                  // Bit 49
    "ND",                  // Bit 50
    "ND",                  // Bit 51
    "ND",                  // Bit 52
    "ND",                  // Bit 53
    "ND",                  // Bit 54
    "ND",                  // Bit 55
    "ND",                  // Bit 56
    "ND",                  // Bit 57
    "ND",                  // Bit 58
    "ND",                  // Bit 59
    "ND",                  // Bit 60
    "ND",                  // Bit 61
    "ND",                  // Bit 62
    "ND",                  // Bit 63
    "ND",                  // Bit 64
    "ND",                  // Bit 65
    "ND",                  // Bit 66
    "ND",                  // Bit 67
    "ND",                  // Bit 68
    "ND",                  // Bit 69
    "ND",                  // Bit 70
    "ND",                  // Bit 71
    "ND",                  // Bit 72
    "ND",                  // Bit 73
    "ND",                  // Bit 74
    "ND",                  // Bit 75
    "ND",                  // Bit 76
    "ND",                  // Bit 77
    "ND",                  // Bit 78
    "ND",                  // Bit 79
    "ND",                  // Bit 80
    "ND",                  // Bit 81
    "ND",                  // Bit 82
    "ND",                  // Bit 83
    "ND",                  // Bit 84
    "ND",                  // Bit 85
    "ND",                  // Bit 86
    "ND",                  // Bit 87
    "ND",                  // Bit 88
  };

  const char* getTriggerName(trigID t){
    if(t < 0){return "Invalid Trigger";}
    if(t == 0){return "NULL Trigger";}
    if(t > MAX_TRIGGER_BITS){return "Invalid Trigger";}
    return trigIDStrings[t-1];
  }

  const char* getTriggerNameFromMask(unsigned int t){
    return getTriggerName(DecodeTrigMask32(t) );
  }

  const char* getTriggerShortName(trigID t){
    if(t < 0){return "Invalid Trigger";}
    if(t == 0){return "NULL";}
    if(t > MAX_TRIGGER_BITS){return "Invalid Trigger";}
    return trigIDShortStrings[t-1];
  }

  const char* getTriggerShortNameFromMask(unsigned int t){
    return getTriggerShortName(DecodeTrigMask32(t) );
  }

  /**
   * Encode a trigger masked based on a given trigger ID
   *
   */

  trigBitID EncodeTrigMask32(trigID t){
    if( t < 1){return TRIG_BIT_NULL;}
    if( t > MAX_TRIGGER_BITS){return TRIG_BIT_NULL;}

    // We return only a 32bit mask for the trigger
    // triggers > 32 are returned shifted down by 32/64 bits

    if( t < 33){
      return (trigBitID)( 0x1 << (t-1));
    }else{
      return (trigBitID)( 0x1 << (t % 33));
    }
    return TRIG_BIT_NULL;
  }

  /**
   * Decode a trigger masked based to a given trigger ID
   *
   */
  trigID DecodeTrigMask32(unsigned int t){

    if( t == TRIG_BIT_NULL){return TRIG_ID_NULL;}

    // We only decode a 32bit word and return
    // the lowest bit that was set
    int i=0;
    for(i=0; i<32; ++i){
      if( t & (0x1 << i)){return (trigID)(i+1);}
    }
    return TRIG_ID_NULL;
  }

  /**
   * Map an integer partition number to an enum trigSourceSubID
   *
   */
  trigSourceSubID PartitionToSubID(int32_t partition)
  {
    switch(partition) {
      case 0:
        return TRIGSRC_SUBID_PARTITION_0;
        break;
      case 1:
        return TRIGSRC_SUBID_PARTITION_1;
        break;
      case 2:
        return TRIGSRC_SUBID_PARTITION_2;
        break;
      case 3:
        return TRIGSRC_SUBID_PARTITION_3;
        break;
      case 4:
        return TRIGSRC_SUBID_PARTITION_4;
        break;
      default:
        return TRIGSRC_SUBID_DUMMY;
    }
  }


  /**
   * Map an enum trigSourceSubID to an integer partition
   *
   */
  int32_t SubIDtoPartition(trigSourceSubID subid)
  {
    switch(subid) {
      case TRIGSRC_SUBID_PARTITION_0:
        return 0;
        break;
      case TRIGSRC_SUBID_PARTITION_1:
        return 1;
        break;
      case TRIGSRC_SUBID_PARTITION_2:
        return 2;
        break;
      case TRIGSRC_SUBID_PARTITION_3:
        return 3;
        break;
      case TRIGSRC_SUBID_PARTITION_4:
        return 4;
        break;
      default:
        return -1;
    }
  }

}