CandShower.cxx

Go to the documentation of this file.

// $Id: CandShower.cxx,v 1.15 2008/11/05 17:33:15 rodriges Exp $
//
// CandShower.cxx
//
// This is a concrete Event Candidate (Reconstruction) object.
// CandShower is descended from CandReco.
//
// 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/CandShower.h"
#include "RecoBase/CandShowerHandle.h"
#include "RecoBase/CandStrip.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandClusterHandle.h"
ClassImp(CandShower)

//______________________________________________________________________
CVSID("$Id: CandShower.cxx,v 1.15 2008/11/05 17:33:15 rodriges Exp $");

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

//______________________________________________________________________
CandShower::CandShower(AlgHandle &ah) :
  CandReco(ah),      // Should be the next class up on inheritance chain
  fEnergy(0.),
  fEnergy_wtCC(0.),
  fEnergy_CC(0.),
  fEnergy_wtNC(0.),
  fEnergy_NC(0.),
  fEnergy_EM(0.),
  fMinStripPE(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.
}

//______________________________________________________________________
CandShower::CandShower(AlgHandle &ah, CandHandle &ch, CandContext &cx) :
  CandReco(ah),      // Should be the next class up on inheritance chain
  fEnergy(0.),
  fEnergy_wtCC(0.),
  fEnergy_CC(0.),
  fEnergy_wtNC(0.),
  fEnergy_NC(0.),
  fEnergy_EM(0.),
  fMinStripPE(0.)
{
  CreateLocalHandle();
  MSG("Cand", Msg::kDebug)
           << "Begin CandShower::CandShower(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor: " << endl
                                           << "UidInt = " << GetUidInt()
                           << ", ArchUidInt " << GetArchUidInt() << endl
                             << "No. of links = " << GetNLinks() << endl
             << "End CandShower::CandShower(AlgHandle &, CandHandle &, "
                                      << "CandContext &) ctor." << endl;

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

//______________________________________________________________________
CandShower::CandShower(const CandShower &rhs) :
  CandReco(rhs),     // Should be the next class up on inheritance chain
  fEnergy(rhs.fEnergy),
  fEnergy_wtCC(rhs.fEnergy_wtCC),
  fEnergy_CC(rhs.fEnergy_CC),
  fEnergy_wtNC(rhs.fEnergy_wtNC),
  fEnergy_NC(rhs.fEnergy_NC),
  fEnergy_EM(rhs.fEnergy_EM),
  fMinStripPE(rhs.fMinStripPE)
{

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

   fUPos.erase(fUPos.begin(),fUPos.end());
   fVPos.erase(fVPos.begin(),fVPos.end());
   fTime[0].erase(fTime[0].begin(),fTime[0].end());
   fTime[1].erase(fTime[1].begin(),fTime[1].end());
   TIter stripItr(rhs.GetDaughterIterator());
   while (const CandStripHandle *striphandle =
                           dynamic_cast<CandStripHandle*>(stripItr())) {

    fUPos[striphandle->GetPlane()] = rhs.fUPos[striphandle->GetPlane()];
    fVPos[striphandle->GetPlane()] = rhs.fVPos[striphandle->GetPlane()];
    fTime[0][striphandle->GetPlane()] = rhs.fTime[0][striphandle->GetPlane()];
    fTime[1][striphandle->GetPlane()] = rhs.fTime[1][striphandle->GetPlane()];
  }

// fClusterList contents owned from CandShower version 2
  CandHandle *ch;
  TIter cliter(&rhs.fClusterList);
  while ((ch = dynamic_cast<CandHandle *>(cliter())))
    fClusterList.Add(ch->DupHandle());
}

//______________________________________________________________________
CandShower::~CandShower()
{

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

  fClusterList.Delete();   // Owned CandHandle*'s from CandShower vers 2
}

//______________________________________________________________________
void CandShower::CreateLocalHandle()
{
  SetLocalHandle(new CandShowerHandle(this));
}

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

  result = TestTObjArrayCandHandleDup("fClusterList", 
                                          this->fClusterList,
                                          rCnd->fClusterList) && result;
  result = TestEquality("fEnergy",        this->fEnergy,
                                          rCnd->fEnergy)      && result;
  result = TestEquality("fEnergy_wtCC",   this->fEnergy_wtCC,
                                          rCnd->fEnergy_wtCC)      && result;
  result = TestEquality("fEnergyCC",      this->fEnergy_CC,
                                          rCnd->fEnergy_CC)      && result;
  result = TestEquality("fEnergy_wtNC",   this->fEnergy_wtNC,
                                          rCnd->fEnergy_wtNC)      && result;
  result = TestEquality("fEnergy_NC",     this->fEnergy_NC,
                                          rCnd->fEnergy_NC)      && result;
  result = TestEquality("fEnergy_EM",     this->fEnergy_EM,
                                          rCnd->fEnergy_EM)      && result;
  result = TestEquality("fUPos",          this->fUPos,
                                          rCnd->fUPos)        && result;
  result = TestEquality("fVPos",          this->fVPos,
                                          rCnd->fVPos)        && result;
  result = TestArrayEquality("fTime", 2,  this->fTime,
                                          rCnd->fTime)     && result;
  return result;
}

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

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

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

    os << indent << GetDataIndent()
       << "fClusterList.size " << fClusterList.GetSize()
       << " Energy " << fEnergy
       << " de-weighted CC Energy " << fEnergy_wtCC
       << " linear CC Energy " << fEnergy_CC
       << " de-weighted NC Energy " << fEnergy_wtNC
       << " linear NC Energy " << fEnergy_NC
       << " EM Energy " << fEnergy_EM
       << " UVPos map sizes " << fUPos.size() << " " << fVPos.size()
       << " Time map sizes " << fTime[0].size() << " " << fTime[1].size()
       << endl;
  }
  return os;
  
}

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

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

// fClusterList contents owned from CandShower version 2
      CandHandle *ch;
      TIter cliter(&fClusterList);
      while ((ch = dynamic_cast<CandHandle *>(cliter())))
        fClusterList.AddAt(ch->DupHandle(), fClusterList.IndexOf(ch));
    }
  }
  else {
    CandShower::Class()->WriteBuffer(R__b, this);
  }
}

//______________________________________________________________________

---