CandDigit.cxx

Go to the documentation of this file.

// $Id: CandDigit.cxx,v 1.12 2008/05/09 14:52:28 boehm Exp $
//
// CandDigit.cxx
//
// This is a concrete Event Candidate (Reconstruction) object.
// CandDigit is descended from CandBase.
//
// Each concrete CandBase must define a Dup function.
// CandBase must grant friendship to class CandRefer.
//
// Author:  G. Irwin 1/2000

#include "Algorithm/AlgHandle.h"
#include "CandDigit/CandDigit.h"
#include "CandDigit/CandDigitHandle.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"

ClassImp(CandDigit)

// New variable to control the ability to compare a demux and 
// standard digit list
// 0 - no check on the plex list is made
// 1 - standard check on plex list
// 2 - look for digit in full demuxed list
static int CandDigitPlexListInEquivTestState = 1;
                                                                                
void SetCandDigitPlexListInEquivTestState(int state){
  CandDigitPlexListInEquivTestState = state;
}
                                                                                
int  GetCandDigitPlexListInEquivTestState()
{
 return CandDigitPlexListInEquivTestState;
}

//______________________________________________________________________
CVSID("$Id: CandDigit.cxx,v 1.12 2008/05/09 14:52:28 boehm Exp $");

#include "Candidate/CandBase.tpl"

//______________________________________________________________________
CandDigit::CandDigit() :
  fRawDigitIndex(-1)
, fVaErrorBits(0)
, fQieErrorBits(0)
{
//CreateLocalHandle();       // LocalHandle is now furnished by Streamer
  MSG("Cand", Msg::kDebug)
                        << "Begin CandDigit::CandDigit() ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
                          << "End CandDigit::CandDigit() ctor." << endl;
}

//______________________________________________________________________
CandDigit::CandDigit(AlgHandle &ah) :
  CandBase(ah)       // Should be the next class up on inheritance chain
, fRawDigitIndex(-1)
, fVaErrorBits(0)
, fQieErrorBits(0)
{

// The sole purpose of this constructor is to transmit the AlgHandle
// up the inheritance chain to CandBase without having to invoke the
// full constructor of an intermediate Candidate type which the highest
// level Candidate might inherit from.  One only wants to create the
// LocalHandle and invoke the RunAlg() method in the lowest level class.

}

//______________________________________________________________________
CandDigit::CandDigit(AlgHandle &ah, CandHandle &ch, CandContext &cx) :
  CandBase(ah)       // Should be the next class up on inheritance chain
, fRawDigitIndex(-1)
, fVaErrorBits(0)
, fQieErrorBits(0)
{
  CreateLocalHandle();

#ifdef ENABLE_DEBUG_MSG
  MSG("Cand", Msg::kDebug)
             << "Begin CandDigit::CandDigit(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
               << "End CandDigit::CandDigit(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor." << endl;
#endif

// Run Algorithm to construct Candidate
   {                                         // Start of scope.
     CandDigitHandle cdh(this);              // cdh will go out of scope
     ch = cdh;                               // after setting ch.
   }                                         // End of scope.
   ah.RunAlg(ch, cx);
}

//______________________________________________________________________
CandDigit::CandDigit(const CandDigit &rhs) :
  CandBase(rhs)      // Should be the next class up on inheritance chain
, fChannelId(rhs.fChannelId)
, fCharge(rhs.fCharge)
, fPlexSEIdAltL(rhs.fPlexSEIdAltL)
, fRawDigitIndex(rhs.fRawDigitIndex)
, fTime(rhs.fTime)
, fVaErrorBits(rhs.fVaErrorBits)
, fQieErrorBits(rhs.fQieErrorBits) 
{
//CreateLocalHandle(); // Moved to Dup function following copy-ctor call

#ifdef ENABLE_DEBUG_MSG
  MSG("Cand", Msg::kDebug)
    << "Begin CandDigit::CandDigit(const CandDigit &rhs) ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
      << "End CandDigit::CandDigit(const CandDigit &rhs) ctor." << endl;
#endif
}

//______________________________________________________________________
CandDigit::~CandDigit()
{
#ifdef ENABLE_DEBUG_MSG
  MSG("Cand", Msg::kDebug)
                       << "Begin CandDigit::~CandDigit() dtor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
                         << "End CandDigit::~CandDigit() dtor." << endl;
#endif
}

//______________________________________________________________________
void CandDigit::CreateLocalHandle()
{
  SetLocalHandle(new CandDigitHandle(this));
}

//______________________________________________________________________
CandDigit *CandDigit::Dup() const
{

// Base copy ctor dups owned pointers, but defers copying Daughter List.
// Daughter List copy is made in the derived class Dup() function.
// This is because base class copy constructor hasn't yet created
// fLocalHandle with a CandHandle* of the full derived type.
  CandDigit *cb = new CandDigit(*this);           // Copy-ctor dups ptrs
  cb->CreateLocalHandle();   // Initializes fLocalHandle after copy-ctor
  TIter iterdau = GetDaughterIterator();
  CandHandle *dau;
  while ((dau=(CandHandle *) iterdau())) cb->AddDaughterLink(*dau);
  return cb;
}

//______________________________________________________________________
Bool_t CandDigit::IsEquivalent(const TObject *rhs) const
{
  Bool_t result = true;
  if (!CandBase::IsEquivalent(rhs)) result = false;   // superclass test
  TestDisplayCandBanner("CandDigit");
  const CandDigit* rCnd = dynamic_cast<const CandDigit*>(rhs);
  if (rCnd == NULL) return false;

  result = TestEquality("fChannelId",   this->fChannelId,
                                        rCnd->fChannelId)     && result;
  result = TestEquality("fCharge",      this->fCharge,
                                        rCnd->fCharge)        && result;

  if(CandDigitPlexListInEquivTestState == 1){
  result = TestEquality("fPlexSEIdAltL",
                                        this->fPlexSEIdAltL,
                                        rCnd->fPlexSEIdAltL)  && result;
  }
  if(CandDigitPlexListInEquivTestState == 2){
    //Highly specific to a Nue search matching a demux digit against
    // an original digit
    bool match = false;
    if(rCnd->fPlexSEIdAltL.size() == 1){
      PlexSEIdAltLItem best    = rCnd->fPlexSEIdAltL.GetBestItem();
      for(unsigned int i = 0; i < this->fPlexSEIdAltL.size(); i++){
        const PlexSEIdAltLItem& item = this->fPlexSEIdAltL[i];
        if(item == best) match = true;
      }
    }
    result = match && result;
  }

  result = TestEquality("fRawDigitIndex",
                                        this->fRawDigitIndex,
                                        rCnd->fRawDigitIndex) && result;
  result = TestEquality("fTime",        this->fTime,
                                        rCnd->fTime)          && result;
  result = TestEquality("fVaErrorBits", this->fVaErrorBits,
                                        rCnd->fVaErrorBits)   && result;
  result = TestEquality("fQieErrorBits",this->fQieErrorBits,
                                        rCnd->fQieErrorBits)  && result;
  return result;
}

//______________________________________________________________________
CandDigitHandle CandDigit::MakeCandidate(AlgHandle &ah, CandContext &cx)
{
  CandDigitHandle cdh;
  new CandDigit(ah, cdh, cx);              // cdh owns the new CandDigit
  return cdh;
}

//______________________________________________________________________
std::ostream& CandDigit::FormatToOStream(std::ostream& os,
                                         Option_t *option) const
{
  CandBase::FormatToOStream(os,option);

  TString opt(option);
  if (!opt.Contains("v0")) { // v0 means suppress the data values
    const TString& indent = GetIndentString();

    static MsgFormat qfmt("f7.1");
    static MsgFormat indxfmt("i6");
    static MsgFormat timefmt("f10.9");
    os << indent << GetDataIndent()
       << "[" << indxfmt(fRawDigitIndex) << "] "
       << fChannelId
       << " Q=" << qfmt(fCharge)
       << " Time " << timefmt(fTime);
    if ( fVaErrorBits || fQieErrorBits ) {
      os << hex << setfill('0'); // prepare for hex words
      // the error bits are of type Char_t, but we want them interpreted 
      // as int-like values (rather than as ASCII chars) so we cast them 
      // to something larger
      if ( fVaErrorBits )  os << " VaErr  0x" << setw(2) << (short)fVaErrorBits;
      if ( fQieErrorBits ) os << " QieErr 0x" << setw(2) << (short)fQieErrorBits;
      os << dec << setfill(' '); // done with hex words
    }
    os << endl;
    //fPlexSEIdAltL.Print("C");
  }
  return os;
  
}

//______________________________________________________________________

---