In This Package:

CalibParamAlg.cc

Go to the documentation of this file.

#include "CalibParamAlg.h"

#include "Event/ReadoutHeader.h"
#include "Event/Readout.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/ReadoutRpcCrate.h"

#include "CalibParam/IPmtCalibParamTool.h"
#include "CalibParam/IRpcCalibParamTool.h"

#include "CLHEP/Units/SystemOfUnits.h"

using namespace DayaBay;

CalibParamAlg::CalibParamAlg(const std::string& name, ISvcLocator* pSvcLocator)
    : GaudiAlgorithm(name,pSvcLocator)
    , m_pmtTools(0)
    , m_rpcTools(0)
{
    declareProperty("ReadoutLocation",
                    m_readoutLocation=DayaBay::ReadoutHeaderLocation::Default,
                    "Location in the TES where the input ReadoutHeader is to be found.");
    declareProperty("PmtTools",m_pmtToolNames,
                    "Names of the PMT calibration tools");
    declareProperty("RpcTools",m_rpcToolNames,
                    "Names of the RPC calibration tools");
    declareProperty("UseFloatFeePedes",m_useFloatFeePedes=false,
                    "Use FloatFeePedes or not? In case of false, it will use CalibSvc.");
    declareProperty("FloatingFeePedestalSvcName",m_floatFeePedesSvcName="FloatingFeePedestalSvc",
                    "Name of service to access floating FEE channel baselines");
}

CalibParamAlg::~CalibParamAlg()
{
}

StatusCode CalibParamAlg::initialize()
{
  StatusCode sc = this->GaudiAlgorithm::initialize();
  if( sc != StatusCode::SUCCESS ) return sc;

  {  
    // Get PMT Calibration tools
    std::vector<std::string>::iterator toolIter, toolEnd=m_pmtToolNames.end();
    for(toolIter=m_pmtToolNames.begin(); toolIter != toolEnd; toolIter++){
      std::string toolName = *toolIter;
      IPmtCalibParamTool* calibTool = 0;
      try {
        calibTool = tool<IPmtCalibParamTool>(toolName);
      }
      catch(const GaudiException& exg) {
        fatal() << "Failed to get pmt calib tool: \"" << toolName << "\"" 
                << endreq;
        return StatusCode::FAILURE;
      }
      m_pmtTools.push_back(calibTool);
      info () << "Added pmt calib tool " << toolName << endreq;
    }
  }

  {
    // Get RPC Calibration tools
    std::vector<std::string>::iterator toolIter, toolEnd=m_rpcToolNames.end();
    for(toolIter=m_rpcToolNames.begin(); toolIter != toolEnd; toolIter++){
      std::string toolName = *toolIter;
      IRpcCalibParamTool* calibTool = 0;
      try {
        calibTool = tool<IRpcCalibParamTool>(toolName);
      }
      catch(const GaudiException& exg) {
        fatal() << "Failed to get rpc calib tool: \"" << toolName << "\"" 
                << endreq;
        return StatusCode::FAILURE;
      }
      m_rpcTools.push_back(calibTool);
      info () << "Added rpc calib tool " << toolName << endreq;
    }
  }

  if(m_useFloatFeePedes){
    // Get floating fee pedestal service
    m_floatFeePedesSvc = svc<IFloatingFeePedestalSvc>(m_floatFeePedesSvcName,true);
    if(!m_floatFeePedesSvc){
      error() << "Failed to access FloatingFeePedestalSvc: " << m_floatFeePedesSvcName << endreq;
      return StatusCode::FAILURE;
    }
  }

  return StatusCode::SUCCESS;
}

StatusCode CalibParamAlg::execute()
{
  debug() << "calling execute()" << endreq; 
  // Get input header
  DayaBay::ReadoutHeader* readoutHeader = 
    get<DayaBay::ReadoutHeader>(m_readoutLocation);

  if(m_useFloatFeePedes){
    // Drop a readoutHeader for pedestal calculation
    StatusCode sc = m_floatFeePedesSvc->cumulate( readoutHeader );
    if( sc.isFailure() ) {
      return sc;
    }
  }

  TimeStamp trigTime = readoutHeader->timeStamp();
  static bool first=true;
  if(first) {
    m_beginTime = trigTime;
    first = false;
  }
  m_endTime = trigTime;
  
  DayaBay::Detector det(readoutHeader->context().GetSite(),
                        readoutHeader->context().GetDetId());
  debug() << "Got readout from " << det.detName() <<" id= "
         << det.siteDetPackedData() <<endreq;
  
  if(det.isAD() || det.isWaterShield()){
    // Loop over each PMT calibration tool
    std::vector<IPmtCalibParamTool*>::iterator toolIter, 
      toolEnd=m_pmtTools.end();
    for(toolIter=m_pmtTools.begin(); toolIter != toolEnd; toolIter++){
      IPmtCalibParamTool* calibTool = *toolIter;
      StatusCode sc = calibTool->process(*readoutHeader);
      if( sc != StatusCode::SUCCESS ) return sc;
    }
    
  }else if(det.detectorId() == DetectorId::kRPC){
    // Process RPC readout
    debug() << "Processing RPC readout" <<endreq;
    // Loop over each RPC calibration tool
    std::vector<IRpcCalibParamTool*>::iterator toolIter, 
      toolEnd=m_rpcTools.end();
    for(toolIter=m_rpcTools.begin(); toolIter != toolEnd; toolIter++){
      IRpcCalibParamTool* calibTool = *toolIter;
      StatusCode sc = calibTool->process(*readoutHeader);
      if( sc != StatusCode::SUCCESS ) return sc;
    }
    
  }else{
    error() << "Unknown detector " << det << endreq; 
    info() << "I am ignoring for now! " << endreq;//tmp
    //return StatusCode::FAILURE;//tmp !! quick fix by jpochoa, temporary! See track ticket #737
    return StatusCode::SUCCESS;//tmp
  }
  
  return StatusCode::SUCCESS;
}

StatusCode CalibParamAlg::finalize()
{
  // Run calibration calculations for each tool
  {
    // Loop over each PMT calibration tool, calling calibrate()
    std::vector<IPmtCalibParamTool*>::iterator toolIter, 
      toolEnd=m_pmtTools.end();
    for(toolIter=m_pmtTools.begin(); toolIter != toolEnd; toolIter++){
      IPmtCalibParamTool* calibTool = *toolIter;
      StatusCode sc = calibTool->calibrate();
      if( sc != StatusCode::SUCCESS ) return sc;
    }
  }
  
  {
    // Loop over each RPC calibration tool, calling calibrate()
    std::vector<IRpcCalibParamTool*>::iterator toolIter, 
      toolEnd=m_rpcTools.end();
    for(toolIter=m_rpcTools.begin(); toolIter != toolEnd; toolIter++){
      IRpcCalibParamTool* calibTool = *toolIter;
      StatusCode sc = calibTool->calibrate();
      if( sc != StatusCode::SUCCESS ) return sc;
    }
  }

  info()<<"First trigger time: "<<m_beginTime.GetSec()<<" sec "<<m_beginTime.GetNanoSec()<<" nanoSec"<<endreq;
  info()<<"Last trigger time:  "<<m_endTime.GetSec()<<" sec "<<m_endTime.GetNanoSec()<<" nanoSec"<<endreq;

  return this->GaudiAlgorithm::finalize();
}

---