L1TriggerRates.cc

Go to the documentation of this file.

/*
 *   File: DataFormats/Scalers/src/L1TriggerRates.cc   (W.Badgett)
 */

#include "DataFormats/Scalers/interface/L1TriggerRates.h"
#include "DataFormats/Scalers/interface/L1TriggerScalers.h"

#include <iostream>
#include <cstdio>

L1TriggerRates::L1TriggerRates():
  version_(0),
  collectionTimeSummary_(0,0),
  deltaT_(0),
  deltaTActive_(0),
  triggerNumberRate_(0.0),
  eventNumberRate_(0.0),
  finalTriggersDistributedRate_(0.0),
  finalTriggersGeneratedRate_(0.0),
  randomTriggersRate_(0.0),
  calibrationTriggersRate_(0.0),
  totalTestTriggersRate_(0.0),
  orbitNumberRate_(0.0),
  numberResetsRate_(0.0),
  deadTimePercent_(0.0),
  deadTimeActivePercent_(0.0),
  deadTimeActiveCalibrationPercent_(0.0),
  deadTimeActivePrivatePercent_(0.0),
  deadTimeActivePartitionPercent_(0.0),
  deadTimeActiveThrottlePercent_(0.0),
  deadTimeActiveTimeSlotPercent_(0.0),
  finalTriggersInvalidBCPercent_(0.0),
  lostFinalTriggersPercent_(0.0),
  lostFinalTriggersActivePercent_(0.0),
  triggersRate_(L1TriggerScalers::nL1Triggers),
  testTriggersRate_(L1TriggerScalers::nL1TestTriggers),
  triggerNumberRunRate_(0.0),
  eventNumberRunRate_(0.0),
  finalTriggersDistributedRunRate_(0.0),
  finalTriggersGeneratedRunRate_(0.0),
  randomTriggersRunRate_(0.0),
  calibrationTriggersRunRate_(0.0),
  totalTestTriggersRunRate_(0.0),
  orbitNumberRunRate_(0.0),
  numberResetsRunRate_(0.0),
  deadTimeRunPercent_(0.0),
  deadTimeActiveRunPercent_(0.0),
  deadTimeActiveCalibrationRunPercent_(0.0),
  deadTimeActivePrivateRunPercent_(0.0),
  deadTimeActivePartitionRunPercent_(0.0),
  deadTimeActiveThrottleRunPercent_(0.0),
  deadTimeActiveTimeSlotRunPercent_(0.0),
  finalTriggersInvalidBCRunPercent_(0.0),
  lostFinalTriggersRunPercent_(0.0),
  lostFinalTriggersActiveRunPercent_(0.0),
  collectionTimeDetails_(0,0),
  triggersRunRate_(L1TriggerScalers::nL1Triggers),
  testTriggersRunRate_(L1TriggerScalers::nL1TestTriggers)
{ 
}

L1TriggerRates::L1TriggerRates(L1TriggerScalers const& s)
{ 
  L1TriggerRates();
  computeRunRates(s);
}

L1TriggerRates::L1TriggerRates(L1TriggerScalers const& s1,
                   L1TriggerScalers const& s2)
{  
  L1TriggerRates();

  const L1TriggerScalers *t1 = &s1;
  const L1TriggerScalers *t2 = &s2;

  // Choose the later sample to be t2
  if ( t1->orbitNumber() > t2->orbitNumber())
  {
    t1 = &s2;
    t2 = &s1;
  }

  computeRunRates(*t2);
  computeRates(*t1,*t2);
}

L1TriggerRates::~L1TriggerRates() { } 


void L1TriggerRates::computeRates(L1TriggerScalers const& t1,
                  L1TriggerScalers const& t2)
{
  double deltaOrbit = (double)t2.orbitNumber() - (double)t1.orbitNumber();
  if ( deltaOrbit > 0 )
  {
    // Convert orbits into crossings and time in seconds
    double deltaBC       = deltaOrbit * N_BX;
    double deltaBCActive = deltaOrbit * N_BX_ACTIVE;
    deltaT_              = deltaBC * BX_SPACING;
    deltaTActive_        = deltaBCActive * BX_SPACING;

    triggerNumberRate_ = ((double)t2.triggerNumber() 
              - (double)t1.triggerNumber()) / deltaT_;
    eventNumberRate_ = ((double)t2.eventNumber() 
            - (double)t1.eventNumber()) / deltaT_;
    finalTriggersDistributedRate_ = ((double)t2.finalTriggersDistributed() 
                 - (double)t1.finalTriggersDistributed()) / deltaT_;
    finalTriggersGeneratedRate_ = ((double)t2.finalTriggersGenerated() 
    - (double)t1.finalTriggersGenerated()) / deltaT_;
    randomTriggersRate_ = ((double)t2.randomTriggers() 
                - (double)t1.randomTriggers()) / deltaT_;
    calibrationTriggersRate_ = ((double)t2.calibrationTriggers() 
                 - (double)t1.calibrationTriggers()) / deltaT_;
    totalTestTriggersRate_ = ((double)t2.totalTestTriggers() 
             - (double)t1.totalTestTriggers()) / deltaT_;
    orbitNumberRate_ = ((double)t2.orbitNumber() 
            - (double)t1.orbitNumber()) / deltaT_;
    numberResetsRate_ = ((double)t2.numberResets() 
             - (double)t1.numberResets()) / deltaT_;
    
    deadTimePercent_ = 100.0 * ((double)t2.deadTime() 
                - (double)t1.deadTime()) / deltaBC;
    deadTimeActivePercent_ = 100.0 * ((double)t2.deadTimeActive() 
               - (double)t1.deadTimeActive()) / deltaBCActive;
    deadTimeActiveCalibrationPercent_ = 100.0 * ((double)t2.deadTimeActiveCalibration() 
                      - (double)t1.deadTimeActiveCalibration()) / deltaBCActive;
    deadTimeActivePrivatePercent_ = 100.0 * ((double)t2.deadTimeActivePrivate() 
                  - (double)t1.deadTimeActivePrivate()) / deltaBCActive;
    deadTimeActivePartitionPercent_ = 100.0 * ((double)t2.deadTimeActivePartition() 
                    - (double)t1.deadTimeActivePartition()) / deltaBCActive;
    deadTimeActiveThrottlePercent_ = 100.0 * ((double)t2.deadTimeActiveThrottle() 
                   - (double)t1.deadTimeActiveThrottle()) / deltaBCActive;
    deadTimeActiveTimeSlotPercent_ = 100.0 * ((double)t2.deadTimeActiveTimeSlot() 
                 - (double)t1.deadTimeActiveTimeSlot()) / deltaBCActive;
    finalTriggersInvalidBCPercent_ = 100.0 * ((double)t2.finalTriggersInvalidBC() 
                   - (double)t1.finalTriggersInvalidBC()) / deltaBC;
    lostFinalTriggersPercent_ = 100.0 * ((double)t2.lostFinalTriggers() 
             - (double)t1.lostFinalTriggers()) / deltaBC;
    lostFinalTriggersActivePercent_ = 100.0 * ((double)t2.lostFinalTriggersActive() 
                   - (double)t1.lostFinalTriggersActive()) / deltaBCActive;

    int length1 = t1.triggers().size();
    int length2 = t2.triggers().size();
    int minLength;
    ( length1 >= length2 ) ? minLength = length2 : minLength=length1;
    std::vector<unsigned int> triggers1 = t1.triggers();
    std::vector<unsigned int> triggers2 = t2.triggers();
    for ( int i=0; i<minLength; i++)
    {
      double rate = ((double)triggers2[i] -
             (double)triggers1[i] ) / deltaT_;
      triggersRate_.push_back(rate);
    }


    length1 = t1.testTriggers().size();
    length2 = t2.testTriggers().size();
    ( length1 >= length2 ) ? minLength = length2 : minLength=length1;
    std::vector<unsigned int> testTriggers1 = t1.testTriggers();
    std::vector<unsigned int> testTriggers2 = t2.testTriggers();
    for ( int i=0; i<minLength; i++)
    {
      double rate = ((double)testTriggers2[i] -
             (double)testTriggers1[i] ) / deltaT_;
      testTriggersRate_.push_back(rate);
    }
  }
}

void L1TriggerRates::computeRunRates(L1TriggerScalers const& t)
{
  version_ = t.version();

  collectionTimeSummary_.set_tv_sec(static_cast<long>(t.collectionTimeSummary().tv_sec));
  collectionTimeSummary_.set_tv_nsec(t.collectionTimeSummary().tv_nsec);

  collectionTimeDetails_.set_tv_sec(static_cast<long>(t.collectionTimeDetails().tv_sec));
  collectionTimeDetails_.set_tv_nsec(t.collectionTimeDetails().tv_nsec);

  double deltaOrbit = (double)t.orbitNumber();
  if ( deltaOrbit > 0 )
  {
    // Convert orbits into crossings and time in seconds
    double deltaBC       = deltaOrbit * N_BX;
    double deltaBCActive = deltaOrbit * N_BX_ACTIVE;
    deltaTRun_           = deltaBC * BX_SPACING;
    deltaTRunActive_     = deltaBCActive * BX_SPACING;

    triggerNumberRunRate_ = (double)t.triggerNumber() / deltaTRun_;
    eventNumberRunRate_ = (double)t.eventNumber() / deltaTRun_;
    finalTriggersDistributedRunRate_ = (double)t.finalTriggersDistributed() 
      / deltaTRun_;
    finalTriggersGeneratedRunRate_ = (double)t.finalTriggersGenerated() / deltaTRun_;
    randomTriggersRunRate_ = (double)t.randomTriggers() / deltaTRun_;
    calibrationTriggersRunRate_ = (double)t.calibrationTriggers() / deltaTRun_;
    totalTestTriggersRunRate_ = (double)t.totalTestTriggers() / deltaTRun_;
    orbitNumberRunRate_ = (double)t.orbitNumber() / deltaTRun_;
    numberResetsRunRate_ = (double)t.numberResets() / deltaTRun_;
    
    deadTimeRunPercent_ = 100.0 * (double)t.deadTime() / deltaBC;
    deadTimeActiveRunPercent_ = 100.0 * (double)t.deadTimeActive() / deltaBCActive;
    deadTimeActiveCalibrationRunPercent_ = 100.0 * (double)t.deadTimeActiveCalibration() / deltaBCActive;
    deadTimeActivePrivateRunPercent_ = 100.0 * (double)t.deadTimeActivePrivate() / deltaBCActive;
    deadTimeActivePartitionRunPercent_ = 100.0 * (double)t.deadTimeActivePartition() / deltaBCActive;
    deadTimeActiveThrottleRunPercent_ = 100.0 * (double)t.deadTimeActiveThrottle() / deltaBCActive;
    deadTimeActiveTimeSlotRunPercent_ = 100.0 * (double)t.deadTimeActiveTimeSlot() / deltaBCActive;
    finalTriggersInvalidBCRunPercent_ = 100.0 * (double)t.finalTriggersInvalidBC() / deltaBC;
    lostFinalTriggersRunPercent_ = 100.0 * (double)t.lostFinalTriggers() / deltaBC;
    lostFinalTriggersActiveRunPercent_ = 100.0 * (double)t.lostFinalTriggersActive() / deltaBCActive;

    int length = t.triggers().size();
    for ( int i=0; i<length; i++)
    {
      double rate = ((double)t.triggers()[i]) / deltaTRun_;
      triggersRunRate_.push_back(rate);
    }
  }
}


std::ostream& operator<<(std::ostream& s, const L1TriggerRates& c) 
{
  s << "L1TriggerRates Version: " << c.version() 
    << " Differential Rates in Hz, DeltaT: " <<
    c.deltaT() << " sec" << std::endl;
  char line[128];

  sprintf(line,
      " TriggerNumber:       %e  EventNumber:             %e",
      c.triggerNumberRate(), c.eventNumberRate());
  s << line << std::endl;

  sprintf(line,
      " TriggersDistributed: %e  TriggersGenerated:     %e",
      c.finalTriggersDistributedRate(), c.finalTriggersGeneratedRate());
  s << line << std::endl;

  sprintf(line,
      " RandomTriggers:      %e  CalibrationTriggers:    %e",
      c.randomTriggersRate(), c.calibrationTriggersRate());
  s << line << std::endl;

  sprintf(line,
      " TotalTestTriggers:   %e  OrbitNumber:             %e",
      c.totalTestTriggersRate(), c.orbitNumberRate());
  s << line << std::endl;

  sprintf(line,
      " NumberResets:        %e  DeadTime:                %3.3f%%",
      c.numberResetsRate(), c.deadTimePercent());
  s << line << std::endl;

  sprintf(line,
      " DeadTimeActive:        %3.3f%%    DeadTimeActiveCalibration:  %3.3f%%",
      c.deadTimeActivePercent(), 
      c.deadTimeActiveCalibrationPercent());
  s << line << std::endl;

  sprintf(line,
      " LostTriggers:          %3.3f%%    DeadTimeActivePartition:    %3.3f%%",
      c.lostFinalTriggersPercent(), 
      c.deadTimeActivePartitionPercent());
  s << line << std::endl;

  sprintf(line,
      " LostTriggersActive:    %3.3f%%    DeadTimeActiveThrottle:     %3.3f%%",
      c.lostFinalTriggersActivePercent(),
      c.deadTimeActiveThrottlePercent());
  s << line << std::endl;

  sprintf(line,
      " TriggersInvalidBC:     %3.3f%%    DeadTimeActivePrivate:      %3.3f%%",
      c.finalTriggersInvalidBCPercent(), 
      c.deadTimeActivePrivatePercent());
  s << line << std::endl;

  sprintf(line,
      "                                   DeadTimeActiveTimeSlot:     %3.3f%%",
      c.deadTimeActiveTimeSlotPercent());
  s << line << std::endl;

  std::vector<double> triggersRate = c.triggersRate();
  int length = triggersRate.size() / 4;
  for ( int i=0; i<length; i++)
  {
    sprintf(line," %3.3d:%e    %3.3d:%e    %3.3d:%e    %3.3d:%e",
        i,              triggersRate[i], 
        (i+length),     triggersRate[i+length], 
        (i+(length*2)), triggersRate[i+(length*2)], 
        (i+(length*3)), triggersRate[i+(length*3)]);
    s << line << std::endl;
  }

  std::vector<double> testTriggersRate = c.testTriggersRate();
  length = testTriggersRate.size() / 4;
  for ( int i=0; i<length; i++)
  {
    sprintf(line," %3.3d:%e    %3.3d:%e    %3.3d:%e    %3.3d:%e",
        i,              testTriggersRate[i], 
        (i+length),     testTriggersRate[i+length], 
        (i+(length*2)), testTriggersRate[i+(length*2)], 
        (i+(length*3)), testTriggersRate[i+(length*3)]);
    s << line << std::endl;
  }


  // Run Average rates

  s << "L1TriggerRates Version: " << c.version() 
    << " Run Average Rates in Hz, DeltaT: " <<
    c.deltaTRun() << " sec" << std::endl;

  sprintf(line,
      " TriggerNumber:     %e  EventNumber:             %e",
      c.triggerNumberRunRate(), c.eventNumberRunRate());
  s << line << std::endl;

  sprintf(line,
      " TriggersDistributed:  %e  TriggersGenerated:     %e",
      c.finalTriggersDistributedRunRate(), 
      c.finalTriggersGeneratedRunRate());
  s << line << std::endl;

  sprintf(line,
      " RandomTriggers:   %e  CalibrationTriggers:    %e",
      c.randomTriggersRunRate(), c.calibrationTriggersRunRate());
  s << line << std::endl;

  sprintf(line,
      " TotalTestTriggers: %e  OrbitNumber:             %e",
      c.totalTestTriggersRunRate(), c.orbitNumberRunRate());
  s << line << std::endl;

  sprintf(line,
      " NumberResets:      %e  DeadTime:                %3.3f%%",
      c.numberResetsRunRate(), c.deadTimeRunPercent());
  s << line << std::endl;

  sprintf(line,
      " DeadTimeActive:        %3.3f%%    DeadTimeActiveCalibration:  %3.3f%%",
      c.deadTimeActiveRunPercent(), 
      c.deadTimeActiveCalibrationRunPercent());
  s << line << std::endl;

  sprintf(line,
      " LostTriggers:          %3.3f%%    DeadTimeActivePartition:    %3.3f%%",
      c.lostFinalTriggersRunPercent(), 
      c.deadTimeActivePartitionRunPercent());
  s << line << std::endl;

  sprintf(line,
      " LostTriggersActive:    %3.3f%%    DeadTimeActiveThrottle:     %3.3f%%",
      c.lostFinalTriggersActiveRunPercent(),
      c.deadTimeActiveThrottleRunPercent());
  s << line << std::endl;

  sprintf(line,
      " FinalTriggersInvalidBC:    %3.3f%%    DeadTimeActivePrivate:      %3.3f%%",
      c.finalTriggersInvalidBCRunPercent(), 
      c.deadTimeActivePrivateRunPercent());
  s << line << std::endl;

  sprintf(line,
      " DeadTimeActiveTimeSlot:      %3.3f%%",
      c.deadTimeActiveTimeSlotRunPercent());
  s << line << std::endl;

  std::vector<double> triggersRunRate = c.triggersRunRate();
  length = triggersRunRate.size() / 4;
  for ( int i=0; i<length; i++)
  {
    sprintf(line," %3.3d:%e    %3.3d:%e    %3.3d:%e    %3.3d:%e",
        i,              triggersRunRate[i], 
        (i+length),     triggersRunRate[i+length], 
        (i+(length*2)), triggersRunRate[i+(length*2)], 
        (i+(length*3)), triggersRunRate[i+(length*3)]);
    s << line << std::endl;
  }

  return s;
}