CandCluster.cxx

Go to the documentation of this file.

// $Id: CandCluster.cxx,v 1.13 2005/02/02 11:38:35 tagg Exp $
//
// CandCluster.cxx
//
// This is a concrete Event Candidate (Reconstruction) object.
// CandCluster is descended from CandBase.
//
// 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/CandCluster.h"
#include "RecoBase/CandClusterHandle.h"
#include "RecoBase/CandSliceHandle.h"  // Needed for IsEquivalent method

ClassImp(CandCluster)

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

#include "Candidate/CandBase.tpl"

//______________________________________________________________________
CandCluster::CandCluster() :
  fCandSlice(0),
  fTrackLike(0),
  fShowerLike(0)
{
  MSG("Cand", Msg::kDebug)
                    << "Begin CandCluster::CandCluster() ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
                      << "End CandCluster::CandCluster() ctor." << endl;
}

//______________________________________________________________________
CandCluster::CandCluster(AlgHandle &ah) :
  CandBase(ah),       // Should be the next class up on inheritance chain
  fCandSlice(0),
  fTrackLike(0),
  fShowerLike(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.
}

//______________________________________________________________________
CandCluster::CandCluster(AlgHandle &ah, CandHandle &ch,
                                                      CandContext &cx) :
  CandBase(ah),       // Should be the next class up on inheritance chain
  fCandSlice(0),
  fTrackLike(0),
  fShowerLike(0)
{
  CreateLocalHandle();
  MSG("Cand", Msg::kDebug)
         << "Begin CandCluster::CandCluster(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
           << "End CandCluster::CandCluster(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor." << endl;

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

//______________________________________________________________________
CandCluster::CandCluster(const CandCluster &rhs) :
  CandBase(rhs),      // Should be the next class up on inheritance chain
  fCandSlice(0),
  fTrackLike(rhs.fTrackLike),
  fShowerLike(rhs.fShowerLike)
{

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

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

}

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

// fCandSlice is an owned CandHandle* starting at CandCluster version 2
   delete fCandSlice;
}

//______________________________________________________________________
void CandCluster::CreateLocalHandle()
{
  SetLocalHandle(new CandClusterHandle(this));
}

//______________________________________________________________________
CandCluster *CandCluster::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.
  CandCluster *cb = new CandCluster(*this);       // Copy-ctor dups ptrs
  cb->CreateLocalHandle();   // Initializes fLocalHandle after copy-ctor
  cb->SetCandRecord(fCandRecord);
  TIter iterdau = GetDaughterIterator();
  CandHandle *dau;
  while ((dau=(CandHandle *) iterdau())) cb->AddDaughterLink(*dau);
  return cb;
}

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

  result = TestCandHandleDup("fCandSlice", this->fCandSlice,
                             rCnd->fCandSlice) && result;
  result = TestEquality("fTrackLike", this->fTrackLike, 
                        rCnd->fTrackLike)   && result;
  
  result = TestEquality("fShowerLike", this->fShowerLike,
                        rCnd->fShowerLike) && result; 
  return result;
}

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

//______________________________________________________________________
std::ostream& CandCluster::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();

    os << indent << GetDataIndent()
       << "TrackLike=" << (fTrackLike?"true":"false")
       << " ShowerLike=" << (fShowerLike?"true":"false")
       << endl;
  }
  return os;
  
}

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

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

//______________________________________________________________________

---