CandReco.cxx

Go to the documentation of this file.

// $Id: CandReco.cxx,v 1.19 2005/02/02 11:38:35 tagg Exp $
//
// CandReco.cxx
//
// This is an abstract Event Candidate (Reconstruction) object.
// CandReco is descended from CandBase.  This class should and cannot
// be instantiated.
//
// Each concrete CandBase must define a Dup function.
// CandBase must grant friendship to class CandRefer.
//
// Author:  R. Lee

#include "TClass.h"

#include "Algorithm/AlgHandle.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"
#include "RecoBase/CandReco.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandStripHandle.h"
#include "Conventions/Munits.h"

ClassImp(CandReco)

//______________________________________________________________________
CVSID("$Id: CandReco.cxx,v 1.19 2005/02/02 11:38:35 tagg Exp $");

#include "Candidate/CandBase.tpl"

//______________________________________________________________________
CandReco::CandReco() :
  fCandSlice(0)
, fVtxDirCosU(0.)
, fVtxDirCosV(0.)
, fVtxDirCosZ(0.)
, fEndDirCosU(0.)
, fEndDirCosV(0.)
, fEndDirCosZ(0.)
, fTimeSlope(0.)
, fTimeOffset(0.)
{
  MSG("Cand", Msg::kDebug)
                          << "Begin CandReco::CandReco() ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
                            << "End CandReco::CandReco() ctor." << endl;
}

//______________________________________________________________________
CandReco::CandReco(AlgHandle &ah) :
  CandBase(ah)       // Should be the next class up on inheritance chain
, fCandSlice(0)
, fVtxDirCosU(0.)
, fVtxDirCosV(0.)
, fVtxDirCosZ(0.)
, fEndDirCosU(0.)
, fEndDirCosV(0.)
, fEndDirCosZ(0.)
, fTimeSlope(0.)
, fTimeOffset(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.
}

//______________________________________________________________________
CandReco::CandReco(const CandReco &rhs) :
  CandBase(rhs)      // Should be the next class up on inheritance chain
, fCandSlice(0)
, fVertex(rhs.fVertex)
, fVtxDirCosU(rhs.fVtxDirCosU)
, fVtxDirCosV(rhs.fVtxDirCosV)
, fVtxDirCosZ(rhs.fVtxDirCosZ)
, fTerm(rhs.fTerm)
, fEndDirCosU(rhs.fEndDirCosU)
, fEndDirCosV(rhs.fEndDirCosV)
, fEndDirCosZ(rhs.fEndDirCosZ)
, fTimeSlope(rhs.fTimeSlope)
, fTimeOffset(rhs.fTimeOffset)
{

//CreateLocalHandle(); // Moved to Dup function following copy-ctor call
  MSG("Cand", Msg::kDebug)
       << "Begin CandReco::CandReco(const CandReco &rhs) ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
         << "Term CandReco::CandReco(const CandReco &rhs) ctor." << endl;

  if (rhs.fCandSlice)                       // Make an owned CandHandle*
    fCandSlice = (rhs.fCandSlice)->DupHandle();

  fSigMapped.erase(fSigMapped.begin(),fSigMapped.end());
  fMIP.erase(fMIP.begin(),fMIP.end());
  TIter stripItr(rhs.GetDaughterIterator());
  while (const CandStripHandle *strip =
                           dynamic_cast<CandStripHandle*>(stripItr())) {
    if (strip->GetNDigit(StripEnd::kNegative)>0) {
      Int_t encodedNegative =
                 strip->GetStripEndId(StripEnd::kNegative).GetEncoded();
      fSigMapped[encodedNegative] = rhs.fSigMapped[encodedNegative];
      fMIP[encodedNegative] = rhs.fMIP[encodedNegative];
    }
    if (strip->GetNDigit(StripEnd::kPositive)>0) {
      Int_t encodedPositive =
                 strip->GetStripEndId(StripEnd::kPositive).GetEncoded();
      fSigMapped[encodedPositive] = rhs.fSigMapped[encodedPositive];
      fMIP[encodedPositive] = rhs.fMIP[encodedPositive];
    }
  }
}

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

// fCandSlice is an owned CandHandle* starting at CandReco version 3
   delete fCandSlice;
}

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

  result = TestCandHandleDup("fCandSlice",
                                       this->fCandSlice,
                                       rCnd->fCandSlice)  && result;
  result = TestEquality("fVertex",     this->fVertex,
                                       rCnd->fVertex)     && result;
  result = TestEquality("fTerm",     this->fTerm,
                                       rCnd->fTerm)     && result;
  result = TestEquality("fVtxDirCosU",    this->fVtxDirCosU,
                                       rCnd->fVtxDirCosU)    && result;
  result = TestEquality("fVtxDirCosV",    this->fVtxDirCosV,
                                       rCnd->fVtxDirCosV)    && result;
  result = TestEquality("fVtxDirCosZ",    this->fVtxDirCosZ,
                                       rCnd->fVtxDirCosZ)    && result;
  result = TestEquality("fEndDirCosU",    this->fEndDirCosU,
                                       rCnd->fEndDirCosU)    && result;
  result = TestEquality("fEndDirCosV",    this->fEndDirCosV,
                                       rCnd->fEndDirCosV)    && result;
  result = TestEquality("fEndDirCosZ",    this->fEndDirCosZ,
                                       rCnd->fEndDirCosZ)    && result;
  result = TestEquality("fTimeSlope",  this->fTimeSlope,
                                       rCnd->fTimeSlope)  && result;
  result = TestEquality("fTimeOffset", this->fTimeOffset,
                                       rCnd->fTimeOffset) && result;
  result = TestEquality("fSigMapped",  this->fSigMapped,
                                       rCnd->fSigMapped)  && result;
  result = TestEquality("fMIP",        this->fMIP,
                                       rCnd->fMIP)        && result;

  return result;
}

//______________________________________________________________________
std::ostream& CandReco::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 timefmt("f10.9");
    os << indent << GetDataIndent()
       << "Vertex " << fVertex.AsString()
       << endl;    os << indent << GetDataIndent()
       << "Term " << fTerm.AsString()
       << endl;
    os << indent << GetDataIndent()
       << "Vertex DirCos: U=" << fVtxDirCosU
       << " V=" << fVtxDirCosV
       << " Z=" << fVtxDirCosZ
       << " Term DirCos: U=" << fEndDirCosU
       << " V=" << fEndDirCosV
       << " Z=" << fEndDirCosZ
       << endl
       << indent << GetDataIndent()
       << "Time(ns) Slope=" << fTimeSlope/Munits::ns
       << " Offset=" << fTimeOffset/Munits::ns
       << endl;
  }
  return os;
  
}

//______________________________________________________________________
void CandReco::Streamer(TBuffer &R__b)
{

// Stream an object of class CandReco.
  if (R__b.IsReading()) {
    UInt_t R__s, R__c;
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
    CandReco::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
    if (R__v < 3) {
      if (fCandSlice) fCandSlice = fCandSlice->DupHandle();
    }
  }
  else {
    CandReco::Class()->WriteBuffer(R__b, this);
  }
}

//______________________________________________________________________

---