In This Package:

SimpPmtCalibTool.cc

Go to the documentation of this file.

#include "SimpPmtCalibTool.h"

#include "Event/ReadoutHeader.h"
#include "Event/DaqCrate.h"
#include "Event/DaqPmtCrate.h"
#include "Event/DaqPmtChannel.h"

#include "Event/CalibReadoutHeader.h"
#include "Event/CalibReadoutPmtChannel.h"
#include "Event/CalibReadoutPmtCrate.h"
#include "Event/CalibReadout.h"

#include "Context/TimeStamp.h"

#include "CLHEP/Vector/ThreeVector.h"
#include "DataSvc/ICalibDataSvc.h"
#include "DataSvc/ICableSvc.h"

#include "Conventions/Detectors.h"
#include "Conventions/Trigger.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "GaudiKernel/PhysicalConstants.h"

#include <vector>
#include <fstream>

using namespace Gaudi;
using namespace DayaBay;
using namespace std;

SimpPmtCalibTool::SimpPmtCalibTool(const std::string& type,
    const std::string& name,
    const IInterface* parent)
  :  GaudiTool(type, name, parent)
  ,  m_calibDataSvc(0)
  ,  m_cableSvc(0)
{
  declareInterface< ICalibTool >(this);
  declareProperty("CalibDataSvcName", m_calibDataSvcName = "StaticCalibDataSvc",
                  "Name of Pmt calibration data Service");
  declareProperty("CableSvcName", m_cableSvcName = "StaticCableSvc",
                  "Name of Cable Service");
  declareProperty("UseDynamicPedestal", m_useDynamicPedestal=true, 
                  "Use pedestal value embedded with each hit"); 
  declareProperty("UseUncalibratedCharge", m_useUncalibratedCharge=false, 
                  "Use approximate charge calibration"); 
  declareProperty("UseUncalibratedTime", m_useUncalibratedTime=false, 
                  "Use approximate time calibration"); 
}

SimpPmtCalibTool::~SimpPmtCalibTool() {}

StatusCode SimpPmtCalibTool::initialize()
{
  // Get CalibData Service
  m_calibDataSvc = svc<ICalibDataSvc>(m_calibDataSvcName, true);

  // Get CableData Service
  m_cableSvc = svc<ICableSvc>(m_cableSvcName, true);

  debug() << "successfully get CableSvc and CalibSvc" << endreq;

  return StatusCode::SUCCESS;
}


StatusCode SimpPmtCalibTool::finalize()
{
  return StatusCode::SUCCESS;
}

StatusCode SimpPmtCalibTool::calibration(const DayaBay::DaqCrate* readout,  
                                         DayaBay::CalibReadout* calibReadout)
{
  debug() << "running calibration() " << endreq;
  StatusCode sc;
  
  // Convert to PMT crate readout
  const DayaBay::DaqPmtCrate* pmtReadout = readout->asPmtCrate();
  if(!pmtReadout){
    error() << "calibration():  no pmt readouts." << endreq;
    return StatusCode::FAILURE;
  }
  
  DayaBay::CalibReadoutPmtCrate* calibReadoutCrate 
    = dynamic_cast<DayaBay::CalibReadoutPmtCrate*>(calibReadout);
  // Check CalibReadoutCrate
  if(calibReadoutCrate == NULL) {
    error() << "calibration():  no calib pmt readouts." << endreq;
    return StatusCode::FAILURE;
  }
  
  const std::vector<DayaBay::DaqPmtChannel*>& channels 
    = pmtReadout->channelReadouts();
  std::vector<DayaBay::DaqPmtChannel*>::const_iterator channelIter, 
    channelEnd = channels.end();
  
  int task = 0;
  Context context = calibReadoutCrate->header()->context();
  ServiceMode svcMode(context, task);
  
  // Simple calibration channel by channel
  for(channelIter = channels.begin();
      channelIter!=channelEnd; 
      channelIter++){ 
    const DayaBay::DaqPmtChannel* channel = *channelIter; 
    const DayaBay::FeeChannelId& channelId = channel->channelId();
    
    // Get pmt calib data from CalibDataSvc
    const DayaBay::DetectorSensor& sensDetId 
      = m_cableSvc->sensor(channelId, svcMode);
    
    calibReadoutCrate->addSensor(sensDetId);
    DayaBay::CalibReadoutPmtChannel& cro_ch 
      = *(calibReadoutCrate->sensor(sensDetId)); 
    
    const DayaBay::PmtCalibData* pmtCalib = 0;
    if(!m_useUncalibratedCharge || !m_useUncalibratedTime){
      pmtCalib = m_calibDataSvc->pmtCalibData(sensDetId, svcMode);
      if(!pmtCalib) {
        error() << "No calibration properties for PMT: " << sensDetId 
                << endreq;
        return StatusCode::FAILURE;
      }
    }
    
    const DayaBay::FeeCalibData* feeCalib = 0; 
    if(!m_useDynamicPedestal){ 
      feeCalib = m_calibDataSvc->feeCalibData(channelId, svcMode); 
      if(!feeCalib) {
        error() << "No calibration properties for FEE channel: " 
                << channelId << endreq;
        return StatusCode::FAILURE;
      }
    }
    
    // simple tdc calibration
    std::vector<double> calib_time;
    std::vector<double> calib_charge;
    double tdcToTime = -(1.0/DayaBay::TdcFrequencyHz) * Units::second;
    for(unsigned int hitIdx=0; hitIdx<channel->hitCount(); hitIdx++){
      // Convert TDC to nanoseconds, and remove PMT time offset
      double calibTime = channel->tdc(hitIdx) * tdcToTime;
      if(!m_useUncalibratedTime) calibTime -= pmtCalib->m_timeOffset;
      calib_time.push_back( calibTime ); 
      
      double adcBaseline = 0.;
      double adcToSpe = 0.;
      if(channel->adc(hitIdx)==0) {
        // Catch invalid ADC values, set to zero charge
        calib_charge.push_back(0.);
        continue;
      }
      // Find ADC pedestal for this channel 
      if(m_useDynamicPedestal){
        adcBaseline = channel->preAdcAvg(hitIdx); 
      }else{
        if( channel->isHighGainAdc(hitIdx) ){
          adcBaseline = feeCalib->m_adcBaselineHigh;
        }else{
          adcBaseline = feeCalib->m_adcBaselineLow;
        }
      }
      
      // Find ADC to charge conversion
      if(m_useUncalibratedCharge){
        // Use mean charge conversion, instead of PMT calibration parameters
        adcToSpe = 1. / 20.;
        if(! channel->isHighGainAdc(hitIdx) ) adcToSpe = 1.0;
      }else{
        // Use PMT calibration parameters
        if(channel->isHighGainAdc(hitIdx)) {  //high
          adcToSpe = 1.0 / pmtCalib->m_speHigh;
        }else{
          adcToSpe = 1.0 / pmtCalib->m_speLow;
        }
      }
      calib_charge.push_back( (channel->adc(hitIdx) - adcBaseline) * adcToSpe);
      
    }
    cro_ch.setTime(calib_time);
    cro_ch.setCharge(calib_charge);
  }
  
  return StatusCode::SUCCESS;
}

---