CandEvent.cxx

Go to the documentation of this file.

// $Id: CandEvent.cxx,v 1.15 2006/05/01 20:34:39 musser Exp $
//
// CandEvent.cxx
//
// This is a concrete Event Candidate (Reconstruction) object.
// CandEvent 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 "RecoBase/CandEvent.h"
#include "RecoBase/CandEventHandle.h"
#include "RecoBase/CandShowerHandle.h" // Needed for IsEquivalent method
#include "RecoBase/CandSliceHandle.h"  // Needed for IsEquivalent method
#include "RecoBase/CandTrackHandle.h"  // Needed for IsEquivalent method

ClassImp(CandEvent)

//______________________________________________________________________
CVSID("$Id: CandEvent.cxx,v 1.15 2006/05/01 20:34:39 musser Exp $");

#include "Candidate/CandBase.tpl"

//______________________________________________________________________
CandEvent::CandEvent() :
  fPrimaryShower(0)
  , fPrimaryTrack(0)
  , fContained(0)
  ,  fEnergy(0.)
{
}

//______________________________________________________________________
CandEvent::CandEvent(AlgHandle &ah) :
  CandReco(ah)       // Should be the next class up on inheritance chain
, fPrimaryShower(0)
, fPrimaryTrack(0)
  ,fContained(0)
  ,  fEnergy(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.
}

//______________________________________________________________________
CandEvent::CandEvent(AlgHandle &ah, CandHandle &ch, CandContext &cx) :
  CandReco(ah)       // Should be the next class up on inheritance chain
, fPrimaryShower(0)
, fPrimaryTrack(0)
  , fContained(0)
  ,  fEnergy(0.)
{
  CreateLocalHandle();

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

//______________________________________________________________________
CandEvent::CandEvent(const CandEvent &rhs) :
  CandReco(rhs)      // Should be the next class up on inheritance chain
, fPrimaryShower(0)
, fPrimaryTrack(0)
  , fContained(rhs.fContained)
  ,  fEnergy(rhs.fEnergy)
{

//CreateLocalHandle(); // Moved to Dup function following copy-ctor call


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

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

// fShowerList and fTrackList contents owned from CandEvent version 2
  CandHandle *ch;
  TIter shwiter(&rhs.fShowerList);
  while ((ch = dynamic_cast<CandHandle *>(shwiter())))
    fShowerList.Add(ch->DupHandle());
  TIter trkiter(&rhs.fTrackList);
  while ((ch = dynamic_cast<CandHandle *>(trkiter())))
    fTrackList.Add(ch->DupHandle());
}

//______________________________________________________________________
CandEvent::~CandEvent()
{

// fPrimaryShower is owned CandHandle* starting at CandEvent version 2
// fPrimaryTrack is an owned CandHandle* starting at CandEvent version 2
// fCandSlice is an owned CandHandle* starting at CandEvent version 2
  delete fPrimaryShower;
  delete fPrimaryTrack;

  fShowerList.Delete();  // Owned CandHandle*'s from CandEvent version 2
  fTrackList.Delete();   // Owned CandHandle*'s from CandEvent version 2
}

//______________________________________________________________________
void CandEvent::CreateLocalHandle()
{
  SetLocalHandle(new CandEventHandle(this));
}

//______________________________________________________________________
CandEvent *CandEvent::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.
  CandEvent *cb = new CandEvent(*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 CandEvent::IsEquivalent(const TObject *rhs) const
{
  Bool_t result = true;
  if (!CandBase::IsEquivalent(rhs)) result = false;   // superclass test
  TestDisplayCandBanner("CandEvent");
  const CandEvent* rCnd = dynamic_cast<const CandEvent*>(rhs);
  if (rCnd == NULL) return false;

  result = TestTObjArrayCandHandleDup("fShowerList",
                                           this->fShowerList,
                                           rCnd->fShowerList) && result;
  result = TestTObjArrayCandHandleDup("fTrackList",
                                            this->fTrackList,
                                            rCnd->fTrackList) && result;
  result = TestCandHandleDup("fPrimaryShower",
                                        this->fPrimaryShower,
                                        rCnd->fPrimaryShower) && result;
  result = TestCandHandleDup("fPrimaryTrack",
                             this->fPrimaryTrack,
                             rCnd->fPrimaryTrack) && result;
  result = TestEquality("fEnergy",        this->fEnergy,
                        rCnd->fEnergy)      && result;
  result = TestEquality("fContained",        this->fContained,
                        rCnd->fContained)      && result;
 
  return result;
}

//______________________________________________________________________
CandEventHandle CandEvent::MakeCandidate(AlgHandle &ah, CandContext &cx)
{
  CandEventHandle csh;
  new CandEvent(ah, csh, cx);              // csh owns the new CandEvent
  return csh;
}

//______________________________________________________________________
std::ostream& CandEvent::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 << " Energy " << fEnergy << " Contained " << fContained << endl;
     os << indent << GetDataIndent() << "Primary:" << endl;
    IncIndent();
    if (fPrimaryShower) fPrimaryShower->Print("nd0");
    if (fPrimaryTrack)  fPrimaryTrack->Print("nd0");
    DecIndent();
 
  }
  return os;
}

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

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

// fShowerList and fTrackList contents owned from CandEvent version 2
      CandHandle *ch;
      TIter shwiter(&fShowerList);
      while ((ch = dynamic_cast<CandHandle *>(shwiter())))
        fShowerList.AddAt(ch->DupHandle(), fShowerList.IndexOf(ch));
      TIter trkiter(&fTrackList);
      while ((ch = dynamic_cast<CandHandle *>(trkiter())))
        fTrackList.AddAt(ch->DupHandle(), fTrackList.IndexOf(ch));
    }
  }
  else {
    CandEvent::Class()->WriteBuffer(R__b, this);
  }
}

//______________________________________________________________________

---