In This Package:

DaqDataHistogram.cc

Go to the documentation of this file.

// General stuff

#include <sstream>
#include <string>
#include <stdio.h>

// Root stuff

#include "TGraph.h"
#include "TH2F.h"
#include "TH1F.h"
#include "TH1I.h"
#include <TProfile.h>

// Local Alg stuff

#include "DaqDataHistogram.h"

// DaqReadout stuff

#include "Event/ReadoutHeader.h"
#include "Event/Readout.h"
#include "Event/DaqCrate.h"

#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventReadout.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "EventReadoutFormat/RomHeader.h"
#include "FeeReadoutFormat/FeeHit.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "FileReadoutFormat/DataSeparatorRecord.h"
#include "LtbReadoutFormat/LtbFrame.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "LtbReadoutFormat/LtbTime.h"
#include "FadcReadoutFormat/FadcBuffer.h"
#include "FadcReadoutFormat/FadcReadout.h"
#include "FadcReadoutFormat/FadcTraits.h"
#include "FadcReadoutFormat/FadcData.h"
#include "StatisticsSvc/IStatisticsSvc.h"

#include "FecReadoutFormat/FecReadout.h"
#include "FecReadoutFormat/FecData.h"
#include "RtmReadoutFormat/RtmReadout.h"
#include "RtmReadoutFormat/RtmData.h"

#include "DaqReadoutFormat/RomData.h"

using namespace std;
using namespace DayaBay;
using namespace DybDaq;

DaqDataHistogram::DaqDataHistogram(const string& name,
    ISvcLocator* pSvcLocator) :
  GaudiAlgorithm(name,
      pSvcLocator),
  m_statsSvc(0),
  m_daqCrateOrNot(0),
  m_firstTriggerTime(0),
  m_eventCount(0)
{
  declareProperty("PrintFreq", m_printFreq=0);
  declareProperty("AdcSumMax", m_adcSumMax=100000);
  declareProperty("HighGainFactor", m_highGainFactor=10);
}

DaqDataHistogram::~DaqDataHistogram()
{
}

StatusCode DaqDataHistogram::initialize()
{
  info() << "Initializing " << endreq;

  StatusCode sc = service("StatisticsSvc", m_statsSvc, true);
  if (sc.isFailure()) {
    error() << "Failed to get StatisticsSvc" << endreq;
    return sc;
  }

  verbose()<< "done init" << endreq;
  return sc;
}

StatusCode DaqDataHistogram::finalize()
{
  info() << "Finalizing " << endreq;
  
  if(m_daqCrateOrNot){
    double scale = 1/(m_lastTriggerTime - m_firstTriggerTime);
    m_scale->Scale(scale);
  }

  if( m_statsSvc ) {
    m_statsSvc->release();
  }

  return StatusCode::SUCCESS;
}

StatusCode DaqDataHistogram::execute()
{
  verbose() << "executing: " << m_eventCount << endreq;
  const ReadoutHeader* readoutHeader = get<ReadoutHeader>("/Event/Readout/ReadoutHeader");
  if (0 == readoutHeader) {
    error() << "Failed to get readout header." << endreq;
    return StatusCode::FAILURE;
  }

  const DayaBay::DaqCrate* daqCrate = readoutHeader->daqCrate();

  const DybDaq::EventReadout* event = 0;

  if ( daqCrate == 0 ) {
    const Readout* readout = readoutHeader->readout();
    if ( readout == 0 ) {
      error() << "Failed to get DAQ readout or readout from header" << endreq; 
      return StatusCode::FAILURE;
    }
    event = readout->eventReadout();
    if ( event ==  0 ) {
      error() << "Failed to get event readout from readout" << endreq; 
      return StatusCode::FAILURE;
    }
  } else {
    event = &(daqCrate->eventReadout());
  }

  if(!event){
    error() << "Failed to get event both from DaqCrate and Readout" << endreq;
    return StatusCode::SUCCESS;
  } else {
    const DybDaq::EventHeader* eventHeader = &(event->header());
    int run = eventHeader->run();
    int detectorInt = eventHeader->detector();
    if(detectorInt == 7){
      TH1F* h_fecId = dynamic_cast<TH1F*>(rpcGetOrMakeHist(1, detectorInt, 0, 0, kFecId));

      static const EventTraits& eventTraits = dynamic_cast<const EventTraits&>(event->header().daqTraits());
      static const unsigned int kRpcRomModuleType = eventTraits.moduleType(EventTraits::kRpcRomModule);
      static const unsigned int kRpcRtmModuleType = eventTraits.moduleType(EventTraits::kRpcRtmModule);

      const EventReadout::RomFragmentPtrList& fragments = event->romFragments();
      for(EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
                        fragment != fragments.end(); ++fragment) {

        const RomHeader& header = (*fragment)->header();

        if ( kRpcRomModuleType == header.moduleType() ) {
          handleFecReadout( dynamic_cast<const FecReadout&>((*fragment)->unwrappedData()) );
          
        } else if ( kRpcRtmModuleType == header.moduleType() ) {
          handleRtmReadout( dynamic_cast<const RtmReadout&>((*fragment)->unwrappedData()) );

        } else {
          std::cout << "Current fragment data is not RPC!" << std::endl;
        }
      }
    }
  }

  if(daqCrate){
    m_daqCrateOrNot = 1;
    // Convert to PMT crate readout
    const DayaBay::DaqPmtCrate* pmtCrate = daqCrate->asPmtCrate();
    if(!pmtCrate){
      // Not an AD, continue
      return StatusCode::SUCCESS;
    } 

    const DayaBay::Detector& detector = pmtCrate->detector();
    info() << "Detector = " << detector << endreq;

    if(!m_firstTriggerTime){
      m_firstTriggerTime = pmtCrate->triggerTime().GetSeconds();
    }

    int runNumber = pmtCrate->runNumber();
    TH1F* h_triggerType            = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kTriggerType));
    TH1F* h_rateVsTriggerType      = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kRateVsTriggerType));
    TH1F* h_adcSum                 = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kAdcSum));
    TH1F* h_nChannel               = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kNchannel));
    TH1F* h_hitNumber              = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kHitNumber));
    TH1F* h_hitRate                = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kHitRate));
    TH1F* h_adcMean                = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kAdcMean));
    TH1F* h_adcRMS                 = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kAdcRMS));
    TH1F* h_tdcMean                = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kTdcMean));
    TH1F* h_tdcRMS                 = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kTdcRMS));
    TH1F* h_preAdcMean             = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kPreAdcMean));
    TH1F* h_preAdcRMS              = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kPreAdcRMS));
    TH2F* h_adcVsChannel           = dynamic_cast<TH2F*>
                                     (getOrMakeHist(1, detector, 0, 0, kAdcVsChannel));
    TH2F* h_tdcVsChannel           = dynamic_cast<TH2F*>
                                     (getOrMakeHist(1, detector, 0, 0, kTdcVsChannel));
    TH2F* h_preAdcVsChannel        = dynamic_cast<TH2F*>
                                     (getOrMakeHist(1, detector, 0, 0, kPreAdcVsChannel));
    TH1F* h_darkRate               = dynamic_cast<TH1F*>
                                     (getOrMakeHist(1, detector, 0, 0, kDarkRate));
    TH2F* h_adcSumVsTriggerType    = dynamic_cast<TH2F*>
                                     (getOrMakeHist(1, detector, 0, 0, kAdcSumVsTriggerType));
    TProfile* h_darkNoiseVsChannel = dynamic_cast<TProfile*>
                                     (getOrMakeHist(1, detector, 0, 0, kDarkNoiseVsChannel));

    h_hitNumber->Fill(-1);  //total events in this detector
    h_darkRate->Fill(-1);

    const DayaBay::DaqPmtCrate::PmtChannelPtrList& channels
      = pmtCrate->channelReadouts();

    h_nChannel->Fill( channels.size() );

    DayaBay::DaqPmtCrate::PmtChannelPtrList::const_iterator channelIter,
      channelEnd = channels.end();

      float adcSum = 0;
    for(channelIter = channels.begin(); channelIter!=channelEnd; channelIter++) {
      const DayaBay::DaqPmtChannel& channel = *(*channelIter);

      int board = channel.channelId().board(); 
      int connector = channel.channelId().connector();
      int localId = board*16+connector;
      info() << "(board,connector) = (" << board << "," << connector << ")" << endreq;

      h_hitNumber->Fill(localId);

      TH1I* h_tdc          = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kTdc));
      TH1I* h_peakCycle    = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kPeakCycle));
      TH1I* h_range        = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kRange));
      TH1I* h_hitCount     = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kHitCount));
      TH1I* h_adcFine      = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kAdcFine));
      TH1I* h_adcCoarse    = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kAdcCoarse));
      TH1I* h_preAdcFine   = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kPreAdcFine));
      TH1I* h_preAdcCoarse = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kPreAdcCoarse));
      TH1I* h_darkNoise    = dynamic_cast<TH1I*>
                             (getOrMakeHist(1, detector, board, connector, kDarkNoise));

      for(unsigned int i=0; i<channel.hitCount(); i++) {
        int tdc = channel.tdc(i);
        int adc = channel.adc(i);
        float preAdc = channel.preAdcAvg(i);
        float deltaAdc = adc - preAdc;
        debug() << "tdc=" << tdc << ", adc=" << adc << endreq;

        h_tdc->Fill(tdc);
        h_peakCycle->Fill(channel.peakCycle(i));
        h_hitCount->Fill(i+1);
        if(channel.isHighGainAdc(i)) {
          h_range->Fill(1);
          h_adcFine->Fill(adc);
          h_preAdcFine->Fill(preAdc);
          if(tdc>=1070&&tdc<1170) {
            h_darkNoise->Fill(deltaAdc);
            h_darkNoiseVsChannel->Fill(localId,deltaAdc);
          }
          adcSum += deltaAdc;
          h_adcVsChannel->Fill(localId,deltaAdc);
    h_preAdcVsChannel->Fill(localId,preAdc);
        } else {
          h_range->Fill(2);
          h_adcCoarse->Fill(adc);
          h_preAdcCoarse->Fill(preAdc);
          adcSum += (deltaAdc)*m_highGainFactor;
          h_adcVsChannel->Fill(localId,(deltaAdc)*m_highGainFactor);
    h_adcVsChannel->Fill(localId,(preAdc)*m_highGainFactor);//High gain factor suit for preAdc?
        }
        h_tdcVsChannel->Fill(localId,tdc);
      }
    }

    h_adcSum->Fill(adcSum);

    int trigType = daqTrigType(pmtCrate->triggerType());
    for(unsigned i=0; i<16; i++) {
      if(trigType & 1<<i) {
        h_triggerType->Fill(i);
        h_rateVsTriggerType->Fill(i);
        h_adcSumVsTriggerType->Fill(i,adcSum);
      }
    }

    m_lastTriggerTime = pmtCrate->triggerTime().GetSeconds();
    ++m_eventCount;

    if (0 == (m_eventCount % 1000)) {
      info() << " Processed " << m_eventCount << " events" << endreq;
    }
  }
  return StatusCode::SUCCESS;
}

void DaqDataHistogram::handleFecReadout(const FecReadout& fecReadout){
  const FecReadout::FecDataPtrList& fecList = fecReadout.fecDataList();

  FecReadout::FecDataPtrList::const_iterator it = fecList.begin();
  while ( it != fecList.end() ) {
   handleFecData( *it );

    ++it;
  }
}

void DaqDataHistogram::handleFecData(const FecData* fecData){
  TH1F* h_fecId = m_statsSvc->getTH1F(m_rpcHistPath[kFecId].c_str());
  h_fecId->Fill(fecData->rpcFecId());
}

void DaqDataHistogram::handleRtmReadout(const RtmReadout& rtmReadout){
  const RtmReadout::RtmDataPtrList& rtmList = rtmReadout.rtmDataList();

  RtmReadout::RtmDataPtrList::const_iterator it = rtmList.begin();
  while ( it != rtmList.end() ) {
    handleRtmData( *it );

    const RtmData* rtmData = *it;
    ++it;
  }
}

void DaqDataHistogram::handleRtmData(const RtmData* rtmData){
  cout << " ** RtmData: " << std::endl;
    //<< rtmData->rpcCFId() << '\t' << rtmData->transErr() << '\t' << rtmData->validCLK() << endl
    //<< rtmData->second() << "s    " << rtmData->nanoSecond() << "ns    " << rtmData->accumulation() << endl
    //<< std::hex << "0x" << rtmData->triggerRot() << "    0x" << rtmData->triggerMap() << std::dec << endl;

}

TH1* DaqDataHistogram::rpcGetOrMakeHist(int run, int detector, int row, int column, int histIndex)
{
  debug() << "Detector=" << detector << endreq;

  std::map<int, TH1**>::iterator histIter = m_rpcHist.find(detector);
  TH1** histograms = 0;
  if( histIter == m_rpcHist.end() ){
    info() << "Create " << MAXRPCHISTS << " histograms for detector " << detector << endreq;
    // Initialize histogram 
    histograms = new TH1*[MAXRPCHISTS];
    for(int i = 0; i < MAXRPCHISTS; i++) histograms[i] = 0;
    m_rpcHist[detector] = histograms;
  } else {
    // Found detector
    histograms = histIter->second;
  }

  int iHist = row * NCOLUMN * NRPCHISTOGRAMS + column * NRPCHISTOGRAMS + histIndex;
  info() << "Histogram index = " << iHist << endreq;
  TH1* hist = histograms[iHist];
  if(!hist){
    // Make this histogram
    std::string histName;
    if(row){
      switch(histIndex){
        case kHitMap:
          hist = new TH1F("HitMap", "HitMap", 32, -0.5, 31.5);
          hist->GetXaxis()->SetTitle("ChannelId");
          hist->GetYaxis()->SetTitle("Entries");
          break;
        default:
          error() << "Unknown histogram for single channel: " << histIndex << endreq;
          return 0;
      }
    } else {
      switch(histIndex){
        case kFecId:
          hist = new TH1F("h_sum_FecId", "h_sum_FecId", 20, 0, 20);
          hist->GetXaxis()->SetTitle("FecId");
          hist->GetYaxis()->SetTitle("Entries");
          break;
        default:
          error() << "Unknown histogram for single channel: " << histIndex << endreq;
          return 0;
      }
    }

    info() << "Making histogram: " << hist->GetName() << endreq;
    std::string rpcHistPath = rpcGetPath(run, detector, row, column, hist->GetName());
    m_rpcHistPath[histIndex] = rpcHistPath;
    m_statsSvc->put( rpcHistPath, hist );
    histograms[iHist] = hist;
  }

  return hist;
}

std::string DaqDataHistogram::rpcGetPath(int run, int detector,
    int row, int column, const char* histName)
{
  // Construct histogram path in statistics service
  std::stringstream path;
  //path << "/file1/diagnostics/run_" << std::setfill('0') << std::setw(7)
   //    << run << "/SAB/RPC/";
  path << "/file1/EH1/RPC/";
  if(row){
    path << "row" << std::setfill('0') << std::setw(2) 
      << row << "_column" << std::setfill('0') << std::setw(2)
      << column;
  } else {
    path << "Raw";
  }
  path << "/" << histName;
  debug() << "Histogram path = " << path << endreq;
  return path.str();
}

TH1* DaqDataHistogram::getOrMakeHist(int run, const DayaBay::Detector& detector,
    int board, int connector, int histIndex)
{
  debug() << "Detector=" << detector << "," << detector.fullPackedData() << endreq;

  int detectorInt = detector.fullPackedData();
  std::map<int,TH1**>::iterator histIter = m_hist.find(detectorInt);
  TH1** histograms = 0;
  if( histIter == m_hist.end() ){
    info() << "Create " << MAXHISTS << " histograms for " << detector << endreq;
    // Initialize histogram 
    histograms = new TH1*[MAXHISTS];
    for(int i=0; i<MAXHISTS; i++) histograms[i] = 0;
    m_hist[detectorInt] = histograms;
  }else{
    // Found detector
    histograms = histIter->second;
  }

  int iHist = board * NCONNECTORS * NHISTOGRAMS + connector * NHISTOGRAMS + histIndex;
  info() << "Histogram index = " << iHist << endreq;
  TH1* hist = histograms[board * NCONNECTORS * NHISTOGRAMS + connector * NHISTOGRAMS + histIndex];
  if(!hist){
    // Make this histogram
    std::string histName;
    if(detector.detectorId()){
      if(board){
        // Make channel histograms
        switch(histIndex){
          case kTdc:
            hist = new TH1I("TDC","TDC",1000,300,1300);
            hist->GetXaxis()->SetTitle("TDC");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kAdcFine:
            // ADC Values (Fine Range)
            hist = new TH1I("ADCFine","ADC (Fine Range)",4096,0,4096);
            hist->GetXaxis()->SetTitle("ADC Fine");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kAdcCoarse:
            // ADC Values (Coarse Range)
            hist = new TH1I("ADCCoarse","ADC (Coarse Range)",4096,0,4096);
            hist->GetXaxis()->SetTitle("ADC Coarse");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kPeakCycle:
            hist = new TH1I("PeakCycle","PeakCycle",14,0,14);
            hist->GetXaxis()->SetTitle("PeakCycle");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kRange:
            hist = new TH1I("Range","Range",3,0,3);
            hist->GetXaxis()->SetTitle("Range");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kHitCount:
            hist = new TH1I("HitCount","HitCount",20,0,20);
            hist->GetXaxis()->SetTitle("HitCount");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kPreAdcFine:
            // PreADC Values (Fine Range)
            hist = new TH1I("PreADCFine","PreADC (Fine Range)",200,0,200);
            hist->GetXaxis()->SetTitle("PreADC Fine");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kPreAdcCoarse:
            // Pre ADC Values (Coarse Range)
            hist = new TH1I("PreADCCoarse","PreADC (Coarse Range)",200,0,200);
            hist->GetXaxis()->SetTitle("PreADC Coarse");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          case kDarkNoise:
            hist = new TH1I("DarkNoise","DarkNoise",250,-50,200);
            hist->GetXaxis()->SetTitle("Dark Noise");
            hist->GetYaxis()->SetTitle("Entries");
            break;
          default:
            error() << "Unknown histogram for single channel: " << histIndex << endreq;
            return 0;
        }
      } else {
        // Make detector histIndex
        switch(histIndex){
          case kTriggerType:
            hist = new TH1F("h_sum_triggerType", "h_triggerType;triggerType", 16, 0, 16);
            break;
          case kRateVsTriggerType:
            hist = new TH1F("h_sum_rateVsTriggerType", "h_rateVsTriggerType;triggerType", 16, 0, 16);
            hist->GetYaxis()->SetTitle("Rate");
            m_scale = hist; 
            break;
          case kAdcSum:
            hist = new TH1F("h_sum_FEEADCSUM", "h_FEEADCSUM", 1000 , 0, m_adcSumMax);
            break;
          case kNchannel:
            hist = new TH1F("h_sum_nChannel","Number of Channels in Event",200,0,200);
            hist->GetXaxis()->SetTitle("Number of Channels");
            break;
          case kHitRate:
            hist = new TH1F("h_sum_hitRate", "h_hitRate;channelIndex;hit_rate", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kHitNumber:
            hist = new TH1F("h_tmp_hitNumber", "h_hitNumber;channelIndex;hit_number", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kAdcMean:
            hist = new TH1F("h_sum_ADCMean", "h_ADCMean;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kAdcRMS:
            hist = new TH1F("h_sum_ADCRMS", "h_ADCRMS;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kTdcMean:
            hist = new TH1F("h_sum_TDCMean", "h_TDCMean;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kTdcRMS:
            hist = new TH1F("h_sum_TDCRMS", "h_TDCRMS;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kPreAdcMean:
            hist = new TH1F("h_sum_preAdcMean", "h_preAdcMean;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kPreAdcRMS:
            hist = new TH1F("h_sum_preAdcRMS", "h_preAdcRMS;channelIndex", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            break;
          case kAdcVsChannel:
            hist = new TH2F("h_sum_ADC_Channel", "h_sum_ADC_Channel", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5, (int)(4096*m_highGainFactor), 0, 4096*m_highGainFactor);
            hist->GetXaxis()->SetTitle("Board#times16+Channel");
            hist->GetYaxis()->SetTitle("ADC");
            break;
          case kTdcVsChannel:
            hist = new TH2F("h_sum_TDC_Channel", "h_sum_TDC_Channel", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5, 1000, 300, 1300);
            hist->GetXaxis()->SetTitle("Board#times16+Channel");
            hist->GetYaxis()->SetTitle("TDC");
            break;
          case kPreAdcVsChannel:
            hist = new TH2F("h_sum_preADC_Channel", "h_sum_preADC_Channel", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5, (int)(4096*m_highGainFactor), 0, 4096*m_highGainFactor);
            hist->GetXaxis()->SetTitle("Board#times16+Channel");
            hist->GetYaxis()->SetTitle("preADC");
            break;
          case kDarkRate:
            hist = new TH1F("h_sum_DarkRate", "h_DarkRate", MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5);
            hist->GetXaxis()->SetTitle("Board#times16+Channel");
            hist->GetYaxis()->SetTitle("Dark Rate (kHz)");
            break;
          case kDarkNoiseVsChannel:
            hist = new TProfile("h_sum_DarkNoise","h_sum_DarkNoise",MAXMODNUM*MAXCHNNUM , 0.5, MAXMODNUM*MAXCHNNUM+0.5,-50,250);
            hist->GetXaxis()->SetTitle("Board#times16+Channel");            
            hist->GetYaxis()->SetTitle("Dark Noise (ADC)");
            break;
          case kAdcSumVsTriggerType:
            hist = new TH2F("h_sum_AdcSum_TriggerType","h_sum_AdcSum_TriggerType", 16, 0, 16, 1000 , 0, m_adcSumMax);
            hist->GetXaxis()->SetTitle("Trigger Type");
            hist->GetYaxis()->SetTitle("ADCSum");
            break;
          default:
            error() << "Unknown histogram for event: " << histIndex << endreq;
            return 0;
        }
      }
    }
    debug() << "Making histogram: " << hist->GetName() << endreq;
    m_statsSvc->put( getPath(run, detector, board, connector, hist->GetName()), hist );
    histograms[ board * NCONNECTORS * NHISTOGRAMS + connector * NHISTOGRAMS + histIndex] = hist;
  }

  return hist;
}

std::string DaqDataHistogram::getPath(int run, const Detector &detector,
    int board, int connector, const char* histName)
{
  // Construct histogram path in statistics service
  std::stringstream path;
  //path << "/file1/diagnostics/run_" << std::setfill('0') << std::setw(7)
   //    << run << "/";
  path << "/file1/";
  path << Site::AsString(detector.site()) << "/" << DetectorId::AsString(detector.detectorId());
  if(board){
    path << "/board" << std::setfill('0') << std::setw(2) 
      << board << "_connector" << std::setfill('0') << std::setw(2)
      << connector;
  } else {
    path << "/Raw";
  }
  path << "/" << histName;
  debug() << "Histogram path = " << path << endreq;
  return path.str();
}

int DaqDataHistogram::daqTrigType(int offTrigType)
{
  int trigType = 0;
  if(offTrigType & DayaBay::Trigger::kMult) {
    trigType = trigType | (1<<8);
  }
  if(offTrigType & DayaBay::Trigger::kExternal) {  //CROSS_TRIGGER_IN
    trigType = trigType | (1<<1);
  }
  if(offTrigType & DayaBay::Trigger::kManual) {  //MANUAL_TRIGGER
    trigType = trigType | (1<<0);
  }
  if(offTrigType & DayaBay::Trigger::kPeriodic) {  //PERIODIC_TRIGGER
    trigType = trigType | (1<<2);
  }
  if(offTrigType & DayaBay::Trigger::kESumAll) {
    trigType = trigType | (1<<12);
  }
  if(offTrigType & DayaBay::Trigger::kESumHigh) {
    trigType = trigType | (1<<10);
  }
  if(offTrigType & DayaBay::Trigger::kESumLow) {
    trigType = trigType | (1<<11);
  }
  if(offTrigType & DayaBay::Trigger::kESumADC) {
    trigType = trigType | (1<<9);
  }
  if(offTrigType & DayaBay::Trigger::kCross) {  //CROSS_TRIGGER_IN
    trigType = trigType | (1<<1);
  }
  if(offTrigType & DayaBay::Trigger::kESum) {
    trigType = trigType | (1<<12);
  }
  return trigType;
}

---