In This Package:

FloatingDaqFeePedestalSvc.cc

Go to the documentation of this file.

#include "FloatingDaqFeePedestalSvc.h"
#include "Event/ReadoutPmtCrate.h"
#include "Event/ReadoutPmtChannel.h"
#include "Event/Readout.h"
#include "Event/ReadoutHeader.h"

#include "Conventions/Electronics.h"
#include "Context/TimeStamp.h"

using namespace std;
using namespace DayaBay;

FloatingDaqFeePedestalSvc::FloatingDaqFeePedestalSvc(const std::string& name, ISvcLocator *svc)
  : Service(name,svc)
{
  declareProperty("Limit",m_limit=500,
                  "Number of preAdcs to document");

  declareProperty("TimeCutInSec",m_timeCutInSec=0.0001,  // 100 us
                  "Time cut in second to remove afterpulses");
}

FloatingDaqFeePedestalSvc::~FloatingDaqFeePedestalSvc()
{
}

StatusCode FloatingDaqFeePedestalSvc::initialize()
{
  StatusCode sc;
  sc = this->Service::initialize();

  m_finePreAdc.clear();
  m_crsePreAdc.clear();

  m_finePedes.clear();
  m_crsePedes.clear();

  m_lastTrig = TimeStamp::GetBOT();

  return sc;
}

StatusCode FloatingDaqFeePedestalSvc::finalize()
{
  StatusCode sc;
  sc = this->Service::finalize();

  return sc;
}

StatusCode FloatingDaqFeePedestalSvc::queryInterface(const InterfaceID& riid,
                                                  void** ppvInterface)
{
  StatusCode sc = StatusCode::FAILURE;
  if (ppvInterface) {
    *ppvInterface = 0;
    
    if (IFloatingFeePedestalSvc::interfaceID().versionMatch(riid)) {
      *ppvInterface = static_cast<IFloatingFeePedestalSvc*>(this);
      sc = StatusCode::SUCCESS;
      addRef();
    }
    else sc = Service::queryInterface( riid, ppvInterface );
  }
  return sc;
}

// Record the preAdc value from past events,                                                                              
StatusCode FloatingDaqFeePedestalSvc::cumulate( const DayaBay::ReadoutHeader* rh )
{
    MsgStream log(msgSvc(), "FloatingFeePedestalSvc");

      const DaqCrate* daqCrate = rh->daqCrate();
      if(!daqCrate) {
        log << MSG::ERROR <<"Failed to get daqCrate from header"<<endreq;
        return StatusCode::FAILURE;
      }

      // check for rpc's sneaking in
      if( ! (daqCrate->detector().isAD() || daqCrate->detector().isWaterShield() ) ) {
          return StatusCode::SUCCESS;
      }

      TimeStamp trigTime = daqCrate->triggerTime();

      if( (m_lastTrig == TimeStamp::GetBOT()) ||
          ((trigTime-m_lastTrig).GetSeconds() > m_timeCutInSec) ) {

          const DaqPmtCrate* pPmtCrate=daqCrate->asPmtCrate();
          if(!pPmtCrate) {
              log << MSG::ERROR <<"Failed to get ReadoutPmtCrate"<<endreq;
              return StatusCode::FAILURE;
          }

          DaqPmtCrate::PmtChannelPtrList channels = pPmtCrate->pmtChannelReadouts();
          DaqPmtCrate::PmtChannelPtrList::iterator ci, ci_end = channels.end();

          for(ci = channels.begin(); ci!=ci_end; ci++) {

              DaqPmtChannel *channel = *ci;
              FeeChannelId channelId = channel->channelId();

              float preAdc = channel->preAdcAvg(0);
              int range  = channel->isHighGainAdc(0) ? FeeGain::kHigh 
                                                     : FeeGain::kLow ;

              if( range == FeeGain::kHigh ) {
                  list<float>& preAdcs = m_finePreAdc[ channelId ];
                  m_finePedes[ channelId ] = updatePedestal( preAdcs, preAdc );
              }
              if( range == FeeGain::kLow ) {
                  list<float>& preAdcs = m_crsePreAdc[ channelId ];
                  m_crsePedes[ channelId ] = updatePedestal( preAdcs, preAdc );
              }
          }

          m_lastTrig = trigTime;
      }

      return StatusCode::SUCCESS;
}

// Return the FEE Calibration data
double FloatingDaqFeePedestalSvc::pedestal( const DayaBay::FeeChannelId& channelId,
                                         int gain ) const
{
  MsgStream log(msgSvc(), "FloatingDaqFeePedestalSvc");

  if( gain==FeeGain::kHigh ) {
    PedestalArray::const_iterator ci;
    ci = m_finePedes.find( channelId );
    if( ci != m_finePedes.end() ) {
      return ci->second;
    } else {
      log << MSG::WARNING <<"Incomplete fine range pedestal map. Try preADC."<<endreq;
      return -1000;
    }
  }

  if( gain==FeeGain::kLow ) {
    PedestalArray::const_iterator ci;
    ci = m_crsePedes.find( channelId );
    if( ci != m_crsePedes.end() ) {
      return ci->second;
    } else {
      log << MSG::WARNING <<"Incomplete coarse range pedestal map. Try preADC."<<endreq;
      return -1000;
    }
  }

  log << MSG::ERROR <<"Query with wrong gain parameter"<<endreq;
  return -1000;
}

double FloatingDaqFeePedestalSvc::updatePedestal( list<float>& PreAdcs, float newPreAdc )
{
  PreAdcs.push_front( newPreAdc );
  if( PreAdcs.size()>m_limit ) PreAdcs.pop_back();

  double sum=0;
  int count = PreAdcs.size();
  list<float>::iterator li,liend=PreAdcs.end();
  for( li=PreAdcs.begin(); li!=liend; li++ ) {
    sum+= (*li);
  }
  
  sum = sum/count;
  
  return sum;
}

---