CandDigitHandle.cxx

Go to the documentation of this file.

// $Id: CandDigitHandle.cxx,v 1.23 2005/01/19 13:33:37 kordosky Exp $
//
// CandDigitHandle.cxx
//
// CandDigitHandle is the specialized access handle to CandDigit.
//
// Each concrete CandHandle must define a DupHandle function.
//
// Author:  G. Irwin 5/2000

#include <cassert>
#include <iostream>

#include "CandDigit/CandDigit.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitListHandle.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexSEIdAltLItem.h"

ClassImp(CandDigitHandle)

//______________________________________________________________________
CVSID("$Id: CandDigitHandle.cxx,v 1.23 2005/01/19 13:33:37 kordosky Exp $");

//______________________________________________________________________
CandDigitHandle::CandDigitHandle()
{
}

//______________________________________________________________________
CandDigitHandle::CandDigitHandle(const CandDigitHandle &cdh) :
  CandHandle(cdh)
{
}

//______________________________________________________________________
CandDigitHandle::CandDigitHandle(CandDigit *cd) :
  CandHandle(cd)
{
}

//______________________________________________________________________
CandDigitHandle::~CandDigitHandle()
{
}

//______________________________________________________________________
CandDigitHandle *CandDigitHandle::DupHandle() const
{
   return (new CandDigitHandle(*this));
}

//______________________________________________________________________
RawChannelId CandDigitHandle::GetChannelId() const
{
   return ((CandDigit *) GetCandBase())->fChannelId;
}

//______________________________________________________________________
Float_t CandDigitHandle::GetCharge(CalDigitType::CalDigitType_t
                                                        caltype_t) const
{

// Return uncalibrated charge straight away, if desired.
   if (caltype_t == CalDigitType::kNone) {
     return ((CandDigit *) GetCandBase())->fCharge;
   }

// Check against Demux veto before returning a calibrated charge.
   const PlexSEIdAltL &seidl = GetPlexSEIdAltL();
   if (seidl.GetDemuxVetoFlag() != 0) {
     MSG("Cand", Msg::kWarning)
            << " *** Invalid PlexSEIdAltL.  DeMuxVetoFlag = "
            << seidl.GetDemuxVetoFlag() << endl
            << "Return uncalibrated charge." << endl;
     return ((CandDigit *) GetCandBase())->fCharge;
   }

   switch (caltype_t) {
     // M. Kordosky, Jan 19, 2005 ... noticed while browsing
     // We check for caltype_t==kNone and deal with it 
     // in the first line of the present function.
     // Why do it again?
     //     case (CalDigitType::kNone):
     //       return ((CandDigit *) GetCandBase())->fCharge;
     //       break;
     case (CalDigitType::kSigLin):
       return seidl.GetBestItem().GetSigLin();
       break;
     case (CalDigitType::kSigCorr):
       return seidl.GetBestItem().GetSigCorr();
       break;
     case (CalDigitType::kPE):
       return seidl.GetBestItem().GetPE();
       break;
     default:
       MSG("Cand", Msg::kError)
           << " *** Unknown Digit charge type = "
           << caltype_t << endl
           << "Return uncalibrated charge."
           << endl;
       return ((CandDigit *) GetCandBase())->fCharge;
       break;
   }
}

//______________________________________________________________________
const PlexSEIdAltL &CandDigitHandle::GetPlexSEIdAltL() const
{
   return ((CandDigit *) GetCandBase())->fPlexSEIdAltL;
}

//______________________________________________________________________
PlexSEIdAltL &CandDigitHandle::GetPlexSEIdAltLWritable()
{
   return ((CandDigit *) GetOwnedCandBase())->fPlexSEIdAltL;
}

//______________________________________________________________________
Int_t CandDigitHandle::GetRawDigitIndex() const
{
   return ((CandDigit *) GetCandBase())->fRawDigitIndex;
}

//______________________________________________________________________
Double_t CandDigitHandle::GetSubtractedTime(CalTimeType::CalTimeType_t
                                                        caltype_t) const
{

// Return GetTime() value minus mother CandDigitList GetAbsTime() offset
// No offset subtraction is done if no CandDigitList mother exists.
   const CandDigitListHandle *mother =
                 dynamic_cast<const CandDigitListHandle *>(GetMother());
   if (mother) return GetTime(caltype_t) - mother->GetAbsTime();
   else return GetTime(caltype_t);
}

//______________________________________________________________________
Double_t CandDigitHandle::GetTime(CalTimeType::CalTimeType_t caltype_t)
                                                                   const
{

// Return digit time without CandDigitList GetAbsTime offset subtraction

// Return uncalibrated time straight away, if desired.
   if (caltype_t == CalTimeType::kNone) {
     return ((CandDigit *) GetCandBase())->fTime;
   }

// Check against Demux veto before returning a calibrated time.
   const PlexSEIdAltL &seidl = GetPlexSEIdAltL();
   if (seidl.GetDemuxVetoFlag() != 0) {
     MSG("Cand", Msg::kWarning)
            << " *** Invalid PlexSEIdAltL.  DeMuxVetoFlag = "
            << seidl.GetDemuxVetoFlag() << endl
            << "Return uncalibrated time." << endl;
     return ((CandDigit *) GetCandBase())->fTime;
   }

   switch (caltype_t) {
     // M. Kordosky, Jan 19, 2005 ... noticed while browsing
     // We check for caltype_t==kNone and deal with it 
     // in the first line of the present function.
     // Why do it again?
     //     case (CalTimeType::kNone):
     //       return ((CandDigit *) GetCandBase())->fTime;
     //       break;
     case (CalTimeType::kT0):
       return seidl.GetBestItem().GetTime();
       break;
     default:
       MSG("Cand", Msg::kError)
           << " *** Unknown Digit time type = "
           << caltype_t << endl
           << "Return uncalibrated time."
           << endl;
       return ((CandDigit *) GetCandBase())->fTime;
       break;
   }
}

//______________________________________________________________________
Char_t CandDigitHandle::GetVaErrorBits() const
{
   return ((CandDigit *) GetCandBase())->fVaErrorBits;
}

//______________________________________________________________________
Char_t CandDigitHandle::GetQieErrorBits() const
{
   return ((CandDigit *) GetCandBase())->fQieErrorBits;
}

//______________________________________________________________________
void CandDigitHandle::SetChannelId(RawChannelId chid)
{
   ((CandDigit *) GetOwnedCandBase())->fChannelId = chid;
}

//______________________________________________________________________
void CandDigitHandle::SetCharge(Float_t chg)
{
   ((CandDigit *) GetOwnedCandBase())->fCharge = chg;
}

//______________________________________________________________________
void CandDigitHandle::SetPlexSEIdAltL(PlexSEIdAltL &altlist)
{
   ((CandDigit *) GetOwnedCandBase())->fPlexSEIdAltL = altlist;
}

//______________________________________________________________________
void CandDigitHandle::SetRawDigitIndex(Int_t rawdigitindex)
{
   ((CandDigit *) GetOwnedCandBase())->fRawDigitIndex = rawdigitindex;
}

//______________________________________________________________________
void CandDigitHandle::SetTime(Double_t time)
{
   ((CandDigit *) GetOwnedCandBase())->fTime = time;
}

//______________________________________________________________________
void CandDigitHandle::SetVaErrorBits(Char_t vaerrbits)
{
   ((CandDigit *) GetOwnedCandBase())->fVaErrorBits = vaerrbits;
}

//______________________________________________________________________
void CandDigitHandle::SetQieErrorBits(Char_t qieerrbits)
{
   ((CandDigit *) GetOwnedCandBase())->fQieErrorBits = qieerrbits;
}

//______________________________________________________________________
void CandDigitHandle::Trace(const char *c) const
{
  MSG("Cand", Msg::kDebug)
    << "**********Begin CandDigitHandle::Trace(\"" << c << "\")" << endl
           << "Information from CandDigitHandle's CandHandle: " << endl;
  CandHandle::Trace(c);
  MSG("Cand", Msg::kDebug)
     << "**********End CandDigitHandle::Trace(\"" << c << "\")" << endl;
}

XXXITRIMP(CandDigitHandle)

---