In This Package:

PmtCalibLeadingEdgePrepare.cc

Go to the documentation of this file.

#include "PmtCalibLeadingEdge.h"

#include "Event/ReadoutPmtCrate.h"
#include "StatisticsSvc/IStatisticsSvc.h"
#include "DataSvc/ICableSvc.h"
#include "DataSvc/ICalibDataSvc.h"
#include "Context/ServiceMode.h"
#include "TH1F.h"
#include "TF1.h"
#include "TH2.h"
#include "TParameter.h"
#include <math.h>
#include "TGraph.h"

StatusCode PmtCalibLeadingEdge::prepareStats(const Context& context){
  // Create the histograms and parameters for this detector's statistics
  DayaBay::Detector detector(context.GetSite(), context.GetDetId());

  // Site
  {
    std::string name = "site";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = new TParameter<int>(name.c_str(), 
                                               context.GetSite());
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // Detector ID
  {
    std::string name = "detectorId";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = new TParameter<int>(name.c_str(), 
                                               context.GetDetId());
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // SimFlag
  {
    std::string name = "simFlag";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = new TParameter<int>(name.c_str(), 
                                               context.GetSimFlag());
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // Timestamp: seconds
  {
    std::string name = "timeSec";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = new TParameter<int>(name.c_str(), 
                                               context.GetTimeStamp().GetSec());
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // Timestamp: nanoseconds
  {
    std::string name = "timeNanoSec";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = 
      new TParameter<int>(name.c_str(), context.GetTimeStamp().GetNanoSec());
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // Number of Readouts
  {
    std::string name = "nReadouts";
    std::ostringstream path;
    path << this->getPath(detector) << "/" << name;
    TParameter<int>* par = new TParameter<int>(name.c_str(), 0);
    if( m_statsSvc->put(path.str(),par).isFailure() ) {
      error() << "prepareStats(): Could not register " << name 
              << " at " << path << endreq;
      delete par;
      par = 0;
      return StatusCode::FAILURE;
    }
  }

  // NChannel
  {
    std::ostringstream title, path;
    std::string name = "NChannel";
    title << "NChannel " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* nchannel = new TH1F(name.c_str(),title.str().c_str(),200,0,200);
    nchannel->GetXaxis()->SetTitle("NChannel");
    nchannel->GetYaxis()->SetTitle("Entries");
    if( m_statsSvc->put(path.str(),nchannel).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete nchannel;
      return StatusCode::FAILURE;
    }
  }
  // Raw Adc, mean
  {
    std::ostringstream title, path;
    std::string name = "adcRawMean";
    title << "Raw ADC, mean in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* adcRawMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    adcRawMean->GetXaxis()->SetTitle("Ring*24+Column");
    adcRawMean->GetYaxis()->SetTitle("Raw ADC mean");
    if( m_statsSvc->put(path.str(),adcRawMean).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete adcRawMean;
      return StatusCode::FAILURE;
    }
  }
  // Raw Adc, sigma
  {
    std::ostringstream title, path;
    std::string name = "adcRawSigma";
    title << "Raw ADC, sigma in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* adcRawSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    adcRawSigma->GetXaxis()->SetTitle("Ring*24+Column");
    adcRawSigma->GetYaxis()->SetTitle("Raw ADC sigma");
    if( m_statsSvc->put(path.str(),adcRawSigma).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete adcRawSigma;
      return StatusCode::FAILURE;
    }
  }
  // Adc - preAdc, mean
  {
    std::ostringstream title, path;
    std::string name = "quasiAdcMean";
    title << "ADC - preAdc, mean in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* quasiAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    quasiAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
    quasiAdcMean->GetYaxis()->SetTitle("QuasiAdc mean");
    if( m_statsSvc->put(path.str(),quasiAdcMean).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete quasiAdcMean;
      return StatusCode::FAILURE;
    }
  }
  // Adc - preAdc, sigma
  {
    std::ostringstream title, path;
    std::string name = "quasiAdcSigma";
    title << "ADC - preAdc, sigma in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* quasiAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    quasiAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
    quasiAdcSigma->GetYaxis()->SetTitle("QuasiAdc sigma");
    if( m_statsSvc->put(path.str(),quasiAdcSigma).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete quasiAdcSigma;
      return StatusCode::FAILURE;
    }
  }
  // Adc - Ave preAdc, mean
  {
    std::ostringstream title, path;
    std::string name = "expAdcMean";
    title << "ADC - ave preAdc, mean in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* expAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    expAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
    expAdcMean->GetYaxis()->SetTitle("ExpAdc mean");
    if( m_statsSvc->put(path.str(),expAdcMean).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete expAdcMean;
      return StatusCode::FAILURE;
    }
  }
  // Adc - Ave preAdc, sigma
  {
    std::ostringstream title, path;
    std::string name = "expAdcSigma";
    title << "ADC - ave preAdc, sigma in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* expAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    expAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
    expAdcSigma->GetYaxis()->SetTitle("ExpAdc sigma");
    if( m_statsSvc->put(path.str(),expAdcSigma).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete expAdcSigma;
      return StatusCode::FAILURE;
    }
  }
  // preAdc, mean
  {
    std::ostringstream title, path;
    std::string name = "preAdcMean";
    title << "preAdc, mean in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* preAdcMean = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    preAdcMean->GetXaxis()->SetTitle("Ring*24+Column");
    preAdcMean->GetYaxis()->SetTitle("preAdc mean");
    if( m_statsSvc->put(path.str(),preAdcMean).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete preAdcMean;
      return StatusCode::FAILURE;
    }
  }
  // preAdc, sigma
  {
    std::ostringstream title, path;
    std::string name = "preAdcSigma";
    title << "preAdc, sigma in " << detector.detName();
    path << this->getPath(detector) << "/" << name;
    TH1F* preAdcSigma = new TH1F(name.c_str(),title.str().c_str(),300,0,300);
    preAdcSigma->GetXaxis()->SetTitle("Ring*24+Column");
    preAdcSigma->GetYaxis()->SetTitle("preAdc sigma");
    if( m_statsSvc->put(path.str(),preAdcSigma).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete preAdcSigma;
      return StatusCode::FAILURE;
    }
  }
    // Occupancy for each channel (jpochoa)
    {
      std::ostringstream title, path;
      std::string name = "occupancy";
      title << "Occupancy per channel " << detector.detName();
      path << this->getPath(detector) << "/" << name;
      TH2F* occupancy = new TH2F(name.c_str(),title.str().c_str(),49,0.25,24.75,19,-0.75,8.75);
      occupancy->GetXaxis()->SetTitle("Column");
      occupancy->GetYaxis()->SetTitle("Ring");
      if( m_statsSvc->put(path.str(),occupancy).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete occupancy;
        return StatusCode::FAILURE;
      }
    }
  // Gain for each channel (jpochoa)
  {
      std::ostringstream title, path;
      std::string name = "gain2D";
      title << "Gain per channel " << detector.detName();
      path << this->getPath(detector) << "/" << name;
      TH2F* gain2D = new TH2F(name.c_str(),title.str().c_str(),49,0.25,24.75,19,-0.75,8.75);
      gain2D->GetXaxis()->SetTitle("Column");
      gain2D->GetYaxis()->SetTitle("Ring");
      if( m_statsSvc->put(path.str(),gain2D).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete gain2D;
        return StatusCode::FAILURE;
      }
    }
     // Gain for all channels (jpochoa)
  {
      std::ostringstream title, path;
      std::string name = "gain1D";
      title << "Gain for all channels " << detector.detName();
      path << this->getPath(detector) << "/" << name;
      TH1F* gain1D = new TH1F(name.c_str(),title.str().c_str(),50,20,60);
      gain1D->GetXaxis()->SetTitle("ADC/PE");
      gain1D->GetYaxis()->SetTitle("Number of entries");
      if( m_statsSvc->put(path.str(),gain1D).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete gain1D;
        return StatusCode::FAILURE;
      }
    }

  // ADC Sum spectrum
  {
    std::ostringstream title, path;
    std::string name = "adcSum";
    title << "ADC Sum for readouts in " << detector.detName(); 
    path << this->getPath(detector) << "/" << name;
    TH1F* adcSum = new TH1F(name.c_str(),title.str().c_str(),
                            2000,0,20000);
    adcSum->GetXaxis()->SetTitle("ADC Sum value");
    adcSum->GetYaxis()->SetTitle("Entries");
    // DEBUG
    info() << "name= " << adcSum->GetName() 
           << " at path = \"" << path.str() << "\"" << endreq;
    if( m_statsSvc->put(path.str(),adcSum).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete adcSum;
      return StatusCode::FAILURE;
    }
  }
  // TDC Mean spectrum
  {
    std::ostringstream title, path;
    std::string name = "tdcMean";
    title << "Mean TDC for readouts in " << detector.detName(); 
    path << this->getPath(detector) << "/" << name;
    TH1F* tdcMean = new TH1F(name.c_str(),title.str().c_str(),
                               2000,0,2000);
    tdcMean->GetXaxis()->SetTitle("TDC value");
    tdcMean->GetYaxis()->SetTitle("Entries");
    if( m_statsSvc->put(path.str(),tdcMean).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete tdcMean;
      return StatusCode::FAILURE;
    }
  }
  // Mean TDC Offset by AD ring
  {
    std::ostringstream title, path;
    std::string name = "meanTdcOffset";
    title << "Mean TDC offset by ring in " << detector.detName(); 
    path << this->getPath(detector) << "/" << name;
    TH1F* meanTdcOffset = new TH1F(name.c_str(),title.str().c_str(),
                                   8,1,9);
    meanTdcOffset->GetXaxis()->SetTitle("AD Ring");
    meanTdcOffset->GetYaxis()->SetTitle("Mean TDC Offset");
    if( m_statsSvc->put(path.str(),meanTdcOffset).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete meanTdcOffset;
      return StatusCode::FAILURE;
    }
  }
  // Mean Occupancy by AD ring
  {
    std::ostringstream title, path;
    std::string name = "meanOccupancy";
    title << "Mean occupancy by ring in " << detector.detName(); 
    path << this->getPath(detector) << "/" << name;
    TH1F* meanOccupancy = new TH1F(name.c_str(),title.str().c_str(),
                                   8,1,9);
    meanOccupancy->GetXaxis()->SetTitle("AD Ring");
    meanOccupancy->GetYaxis()->SetTitle("Mean Occupancy");
    if( m_statsSvc->put(path.str(),meanOccupancy).isFailure() ) {
      error() << "prepareStats(): Could not register " << path << endreq;
      delete meanOccupancy;
      return StatusCode::FAILURE;
    }
  }

  // Make sure summary histograms for each ring exist in detector statistics
  for(int ring = 0; ring <= 8; ring++){
    // Occupancy by ring
    {
      std::ostringstream title, path;
      std::string name = "occupancy";
      title << "Occupancy for PMTs in " << detector.detName() 
            << " ring " << ring; 
      path << this->getPath(detector, ring) << "/" << name;
      TH1F* occupancy = new TH1F(name.c_str(),title.str().c_str(),
                                 24,1,25);
      occupancy->GetXaxis()->SetTitle("Column");
      occupancy->GetYaxis()->SetTitle("Occupancy");
      if( m_statsSvc->put(path.str(),occupancy).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete occupancy;
        return StatusCode::FAILURE;
      }
    }
    // TDC offset by ring
    {
      std::ostringstream title, path;
      std::string name = "tdcOffset";
      title << "Time Offset for PMTs in " << detector.detName() 
            << " ring " << ring; 
      path << this->getPath(detector, ring) << "/" << name;
      TH1F* tdcOffset = new TH1F(name.c_str(),title.str().c_str(),
                           24,1,25);
      tdcOffset->GetXaxis()->SetTitle("Column");
      tdcOffset->GetYaxis()->SetTitle("Time Offset [tdc]");
      if( m_statsSvc->put(path.str(),tdcOffset).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete tdcOffset;
        return StatusCode::FAILURE;
      }
    }
    // ADC Mean by ring
    {
      std::ostringstream title, path;
      std::string name = "adcMean";
      title << "ADC Mean for PMTs in " << detector.detName() 
            << " ring " << ring; 
      path << this->getPath(detector, ring) << "/" << name;
      TH1F* adcMean = new TH1F(name.c_str(),title.str().c_str(),
                                 24,1,25);
      adcMean->GetXaxis()->SetTitle("Column");
      adcMean->GetYaxis()->SetTitle("Mean ADC");
      if( m_statsSvc->put(path.str(),adcMean).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete adcMean;
        return StatusCode::FAILURE;
      }
    }
    // ADC Sigma by ring
    {
      std::ostringstream title, path;
      std::string name = "adcSigma";
      title << "ADC Sigma for PMTs in " << detector.detName() 
            << " ring " << ring;
      path << this->getPath(detector, ring) << "/" << name;
      TH1F* adcSigma = new TH1F(name.c_str(),title.str().c_str(),
                                24,1,25);
      adcSigma->GetXaxis()->SetTitle("Column");
      adcSigma->GetYaxis()->SetTitle("ADC Sigma");
      if( m_statsSvc->put(path.str(),adcSigma).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete adcSigma;
        return StatusCode::FAILURE;
      }
    }
  }

  ServiceMode svcMode(context, 0);

  // Get list of all FEE channels
  const std::vector<DayaBay::FeeChannelId>& channelList 
    = m_cableSvc->feeChannelIds( svcMode );
  std::vector<DayaBay::FeeChannelId>::const_iterator chanIter, 
    chanEnd = channelList.end();
  // Initialize statistics for each channel
  for(chanIter = channelList.begin(); chanIter != chanEnd; chanIter++){
    DayaBay::FeeChannelId chanId = *chanIter;

    // Board Number
    {
      std::string name = "board";
      std::ostringstream path;
      path << this->getPath(chanId) << "/" << name;
      TParameter<int>* par = new TParameter<int>(name.c_str(), chanId.board());
      if( m_statsSvc->put(path.str(),par).isFailure() ) {
        error() << "prepareStats(): Could not register " << name 
                << " at " << path << endreq;
        delete par;
        par = 0;
        return StatusCode::FAILURE;
      }
    }

    // Connector Number
    {
      std::string name = "connector";
      std::ostringstream path;
      path << this->getPath(chanId) << "/" << name;
      TParameter<int>* par = new TParameter<int>(name.c_str(), 
                                                 chanId.connector());
      if( m_statsSvc->put(path.str(),par).isFailure() ) {
        error() << "prepareStats(): Could not register " << name 
                << " at " << path << endreq;
        delete par;
        par = 0;
        return StatusCode::FAILURE;
      }
    }

    // Number of Hits
    {
      std::string name = "nHits";
      std::ostringstream path;
      path << this->getPath(chanId) << "/" << name;
      TParameter<int>* par = new TParameter<int>(name.c_str(), 0);
      if( m_statsSvc->put(path.str(),par).isFailure() ) {
        error() << "prepareStats(): Could not register " << name 
                << " at " << path << endreq;
        delete par;
        par = 0;
        return StatusCode::FAILURE;
      }
    }

    // Raw TDC spectrum
    {
      std::string name = "tdcRaw";
      std::ostringstream title, path;
      title << "Raw TDC values for " << detector.detName() 
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* tdcRaw = new TH1F(name.c_str(),title.str().c_str(),
                              2000,0,2000);
      tdcRaw->GetXaxis()->SetTitle("TDC value");
      tdcRaw->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),tdcRaw).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete tdcRaw;
        return StatusCode::FAILURE;
      }
    }

    // TDC spectrum, mean corrected
    {
      std::string name = "tdcByMean";
      std::ostringstream title, path;
      title << "Mean-corrected TDC values for " << detector.detName() 
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* tdcByMean = new TH1F(name.c_str(),title.str().c_str(),
                                   600,-300,300);
      tdcByMean->GetXaxis()->SetTitle("TDC value");
      tdcByMean->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),tdcByMean).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete tdcByMean;
        return StatusCode::FAILURE;
      }
    }

    // Raw ADC spectrum
    {
      std::ostringstream title, path;
      std::string name = "adcRaw";
      title << "ADC values for " << detector.detName() 
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* adcRaw = new TH1F(name.c_str(),title.str().c_str(),
                              4096,0,4096);
      adcRaw->GetXaxis()->SetTitle("ADC value");
      adcRaw->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),adcRaw).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete adcRaw;
        return StatusCode::FAILURE;
      }
    }
    
    // Quasi ADC spectrum, baseline subtracted ( -preAdc)
    {
      std::ostringstream title, path;
      std::string name = "quasiAdc";
      title << "ADC - preAdc " << detector.detName()
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* quasiAdc = new TH1F(name.c_str(),title.str().c_str(),
                           1200,-200,1000);
      quasiAdc->GetXaxis()->SetTitle("QuasiADC value");
      quasiAdc->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),quasiAdc).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete quasiAdc;
        return StatusCode::FAILURE;
      }
    }    

    // ADC spectrum, average pedestal substracted
    {
      std::ostringstream title, path;
      std::string name = "adc";
      title << "ADC - Average preAdc " << detector.detName() 
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* adc = new TH1F(name.c_str(),title.str().c_str(),
                           1200,-200,1000);
      adc->GetXaxis()->SetTitle("ADC value");
      adc->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),adc).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete adc;
        return StatusCode::FAILURE;
      }
    }

    // PreADC spectrum, baseline subtracted
    {
      std::ostringstream title, path;
      std::string name = "preAdc";
      title << "PreADC values for " << detector.detName()
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* preAdc = new TH1F(name.c_str(),title.str().c_str(),
                           1200,-200,1000);
      preAdc->GetXaxis()->SetTitle("PreADC value");
      preAdc->GetYaxis()->SetTitle("Entries");
      if( m_statsSvc->put(path.str(),preAdc).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete preAdc;
        return StatusCode::FAILURE;
      }
    }

    // ADC spectrum by Clock Cycle
    {
      std::ostringstream title, path;
      std::string name = "adcByClock";
      title << "ADC values by clock cycle for " << detector.detName() 
            << " channel " << chanId.board() << "_"
            << chanId.connector();
      path << this->getPath(chanId) << "/" << name;
      TH1F* adcByClock = new TH1F(name.c_str(),title.str().c_str(),
                                  20,0,20);
      adcByClock->GetXaxis()->SetTitle("ADC Clock Cycle");
      adcByClock->GetYaxis()->SetTitle("ADC");
      if( m_statsSvc->put(path.str(),adcByClock).isFailure() ) {
        error() << "prepareStats(): Could not register " << path << endreq;
        delete adcByClock;
        return StatusCode::FAILURE;
      }
    }
  }  

  m_processedDetectors.push_back(detector);

  return StatusCode::SUCCESS;
}

---