CandEventHandle.cxx

Go to the documentation of this file.

// $Id: CandEventHandle.cxx,v 1.36 2006/12/01 20:19:16 rhatcher Exp $
//
// CandEventHandle.cxx
//
// CandEventHandle is the specialized access handle to CandEvent.
//
// Each concrete CandHandle must define a DupHandle function.
//
// Author:  R. Lee

#include <cassert>
#include <cmath>
#include <iostream>
#include <map>

#include "Conventions/CalDigitType.h"
#include "MessageService/MsgService.h"
#include "RecoBase/CandRecoHandle.h"
#include "RecoBase/CandEventHandle.h"
#include "RecoBase/CandEvent.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandShowerHandle.h"
#include "RecoBase/CandTrackHandle.h"
#include "DataUtil/PlaneOutline.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "Validity/VldContext.h"


ClassImp(CandEventHandle)

//______________________________________________________________________
CVSID("$Id: CandEventHandle.cxx,v 1.36 2006/12/01 20:19:16 rhatcher Exp $");

//______________________________________________________________________
CandEventHandle::CandEventHandle()
{
}

//______________________________________________________________________
CandEventHandle::CandEventHandle(const CandEventHandle &cdh) :
  CandRecoHandle(cdh)
{
}

//______________________________________________________________________
CandEventHandle::CandEventHandle(CandEvent *cd) :
  CandRecoHandle(cd)
{
}

//______________________________________________________________________
CandEventHandle::~CandEventHandle()
{
}

//______________________________________________________________________
CandEventHandle *CandEventHandle::DupHandle() const
{
   return (new CandEventHandle(*this));
}


//______________________________________________________________________
void CandEventHandle::Trace(const char *c) const
{
  MSG("Cand", Msg::kDebug)
    << "**********Begin CandEventHandle::Trace(\"" << c << "\")" << endl
           << "Information from CandEventHandle's CandHandle: " << endl;
  CandHandle::Trace(c);
  MSG("Cand", Msg::kDebug)
     << "**********End CandEventHandle::Trace(\"" << c << "\")" << endl;
}

//______________________________________________________________________
void CandEventHandle::SetCandSlice(const CandSliceHandle *slice)
{
  if (slice) {                 // fCandSlice is now an owned CandHandle*
    CandSliceHandle *ch = slice->DupHandle();
    delete (dynamic_cast<CandEvent *>(GetOwnedCandBase()))->fCandSlice;
    dynamic_cast<CandEvent *>(GetOwnedCandBase())->fCandSlice = ch;
  }
}

//______________________________________________________________________
const CandSliceHandle *CandEventHandle::GetCandSlice() const
{
  return dynamic_cast<const CandEvent *>(GetCandBase())->fCandSlice;
}

NavKey CandEventHandle::KeyFromSlice(const CandEventHandle *event)
{
  if (event->GetCandSlice()) {
    return static_cast<Int_t>(event->GetCandSlice()->GetUidInt());
  }
  return 0;
}


//______________________________________________________________________
Int_t CandEventHandle::GetLastShower() const
{
  return
   dynamic_cast<const CandEvent*>(GetCandBase())->fShowerList.GetLast();
}

//______________________________________________________________________
Int_t CandEventHandle::GetLastTrack() const
{
  return
    dynamic_cast<const CandEvent*>(GetCandBase())->fTrackList.GetLast();
}

//______________________________________________________________________
CandShowerHandle *CandEventHandle::GetPrimaryShower() const
{
  return dynamic_cast<const CandEvent*>(GetCandBase())->fPrimaryShower;
}

//______________________________________________________________________
CandTrackHandle *CandEventHandle::GetPrimaryTrack() const
{
  return dynamic_cast<const CandEvent*>(GetCandBase())->fPrimaryTrack;
}

//______________________________________________________________________
Int_t CandEventHandle::GetPrimaryShowerIndex() const
{

  if(!GetPrimaryShower()) return -1;
  const TObjArray &showerlist =
                  (dynamic_cast<const CandEvent*>(GetCandBase()))->fShowerList;
  for (Int_t i=0; i<=showerlist.GetLast(); i++) {
    CandShowerHandle *shower =
      dynamic_cast<CandShowerHandle*>(showerlist.At(i));
    CandShowerHandle * primaryshower = GetPrimaryShower();
    if (*primaryshower == *shower) {
      return i;
    }
  }
  return -1;
}

//______________________________________________________________________
Int_t CandEventHandle::GetPrimaryTrackIndex() const
{
  if(!GetPrimaryTrack()) return -1;
  
  const TObjArray &tracklist =
                  (dynamic_cast<const CandEvent*>(GetCandBase()))->fTrackList;
  for (Int_t i=0; i<= tracklist.GetLast(); i++) {
    CandTrackHandle *track =
      dynamic_cast<CandTrackHandle*>(tracklist.At(i));
    CandTrackHandle * primarytrack = GetPrimaryTrack();
    if ( *primarytrack == *track) {
      return i;
    }
  }
  return -1;
}

//______________________________________________________________________
const CandShowerHandle *CandEventHandle::GetShower(Int_t i) const
{
  const TObjArray *fShowerList =
          &(dynamic_cast<const CandEvent*>(GetCandBase())->fShowerList);
  if (i>fShowerList->GetLast()) {
    return 0;
  }
  return dynamic_cast<const CandShowerHandle*>(fShowerList->At(i));
}

//______________________________________________________________________
CandShowerHandle *CandEventHandle::GetShowerWritable(Int_t i)
{
  const TObjArray *fShowerList =
     &(dynamic_cast<const CandEvent*>(GetOwnedCandBase())->fShowerList);
  if (i>fShowerList->GetLast()) {
    return 0;
  }
  return dynamic_cast<CandShowerHandle*>(fShowerList->At(i));
}

//______________________________________________________________________
const CandTrackHandle *CandEventHandle::GetTrack(Int_t i) const
{
  const TObjArray *fTrackList =
           &(dynamic_cast<const CandEvent*>(GetCandBase())->fTrackList);
  if (i>fTrackList->GetLast()) {
    return 0;
  }
  return dynamic_cast<const CandTrackHandle*>(fTrackList->At(i));
}

void CandEventHandle::SetPrimaryShower(const CandShowerHandle * primaryshower){

  const TObjArray &showerlist =
                 (dynamic_cast<CandEvent*>(GetCandBase()))->fShowerList;
  Bool_t found=0;
  Int_t iprimary = -1;
  for (Int_t i=0; i<=showerlist.GetLast() && !found; i++) {
    CandShowerHandle *shower =
      dynamic_cast<CandShowerHandle*>(showerlist.At(i));
    if (*primaryshower == *shower) {
      found = 1;
      iprimary = i;
    }
  }
  if (iprimary>0) {
    CandShowerHandle *shower =
               dynamic_cast<CandShowerHandle*>(showerlist.At(iprimary));
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fShowerList.
                                      AddAt(showerlist.At(0), iprimary);
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fShowerList.
                                                       AddAt(shower, 0);
  }
  CandShowerHandle *ch = primaryshower->DupHandle();
  delete (dynamic_cast<CandEvent *>
          (GetOwnedCandBase()))->fPrimaryShower;
  (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryShower = ch;

}
//______________________________________________________________________
void CandEventHandle::SetPrimaryShower(Double_t minShwEFract, Double_t minShwShwDZ)
{

  CandTrackHandle *primarytrack = 0;
  if(!GetPrimaryTrack())SetPrimaryTrack();
  primarytrack = GetPrimaryTrack();
  const TObjArray &showerlist =
                 (dynamic_cast<CandEvent*>(GetCandBase()))->fShowerList;

  // find the shower closest to the track vertex, and the shower with highest energy
    
  CandShowerHandle *closestshower = 0;
  CandShowerHandle *largestshower = 0;
  CandShowerHandle *primaryshower = 0;
  Float_t largestenergy=-1;
  Float_t closestenergy=-1;
  Float_t dzlargest=0;
  Float_t dzclosest=1e6;


  for (Int_t i=0; i<=showerlist.GetLast(); i++) {
    CandShowerHandle *shower =
      dynamic_cast<CandShowerHandle*>(showerlist.At(i));
    if (!largestshower || shower->GetEnergy()>largestenergy) {
      largestenergy = shower->GetEnergy();
      largestshower = shower;
      if(primarytrack)dzlargest = fabs(shower->GetVtxZ()-primarytrack->GetVtxZ());
    }
    if(primarytrack){
      if(fabs(shower->GetVtxZ()-primarytrack->GetVtxZ())<dzclosest){
        dzclosest=fabs(shower->GetVtxZ()-primarytrack->GetVtxZ());
        closestshower=shower;
        closestenergy=shower->GetEnergy();
      }
    }
  }
  // if the largest shower is greater than shwshwdz from the track vertex, 
  // and the closest shower has energy greater than minshwEfract
  // call the closest shower the primary
  float eratio = 1.;
  if(largestenergy>0) eratio = closestenergy/largestenergy; 
  if(closestshower && (dzlargest-dzclosest)>minShwShwDZ && eratio>minShwEFract){
    primaryshower = closestshower;
  }
  //largest shower is the primary if there is no track
  else{
    primaryshower = largestshower;
  }

  if(primaryshower && primaryshower->GetEnergy()<2*Munits::GeV){
    if(primarytrack){
      if(fabs(primarytrack->GetVtxZ()-primaryshower->GetVtxZ())>0.5*Munits::m)
        primaryshower = 0;
    }
  }
  if(!primaryshower){
    delete (dynamic_cast<CandEvent *>
            (GetOwnedCandBase()))->fPrimaryShower;
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryShower = 0;
    return;
  }

  Bool_t found=0;
  Int_t iprimary = -1;
  for (Int_t i=0; i<=showerlist.GetLast() && !found; i++) {
    CandShowerHandle *shower =
      dynamic_cast<CandShowerHandle*>(showerlist.At(i));
    if (*primaryshower == *shower) {
      found = 1;
      iprimary = i;
    }
  }
  if (iprimary>0) {
    CandShowerHandle *shower =
               dynamic_cast<CandShowerHandle*>(showerlist.At(iprimary));
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fShowerList.
                                      AddAt(showerlist.At(0), iprimary);
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fShowerList.
                                                       AddAt(shower, 0);
  }
  CandShowerHandle *ch = primaryshower->DupHandle();
  delete (dynamic_cast<CandEvent *>
          (GetOwnedCandBase()))->fPrimaryShower;
  (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryShower = ch;

}

void CandEventHandle::SetPrimaryTrack(const CandTrackHandle * primarytrack){

  const TObjArray &tracklist =
                  (dynamic_cast<CandEvent*>(GetCandBase()))->fTrackList;

  Bool_t found(0);
  Int_t iprimary=-1;
  for (Int_t i=0; i<=tracklist.GetLast() && !found; i++) {
    CandTrackHandle *track =
                        dynamic_cast<CandTrackHandle*>(tracklist.At(i));
    
    if (*primarytrack == *track) {
      found = 1;
      iprimary = i;
    }
  }


  if (iprimary>0) {
    CandTrackHandle *track =
                 dynamic_cast<CandTrackHandle*>(tracklist.At(iprimary));
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fTrackList.
      AddAt(tracklist.At(0), iprimary);
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fTrackList.
      AddAt(track, 0);
  }
  if (primarytrack) {       // fPrimaryTrack is now an owned CandHandle*
    CandTrackHandle *ch = primarytrack->DupHandle();
    delete (dynamic_cast<CandEvent *>
                                   (GetOwnedCandBase()))->fPrimaryTrack;
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryTrack = ch;
  }
  else {
    delete (dynamic_cast<CandEvent *>
                                   (GetOwnedCandBase()))->fPrimaryTrack;
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryTrack = 0;
  }

}
//______________________________________________________________________
void CandEventHandle::SetPrimaryTrack()
{

  const TObjArray &tracklist =
                  (dynamic_cast<CandEvent*>(GetCandBase()))->fTrackList;

  Double_t bestscore=0;
  Bool_t found(0);
  Int_t iprimary=-1;
  CandTrackHandle *primarytrack=0;

  for (Int_t i=0; i<=tracklist.GetLast() && !found; i++) {
    CandTrackHandle *track =
                        dynamic_cast<CandTrackHandle*>(tracklist.At(i));
    
    if (!primarytrack || track->GetScore()>bestscore) {
      primarytrack = track;
      bestscore=track->GetScore();
      found = 1;
      iprimary = i;
    }
  }

  if (iprimary>0) {
    CandTrackHandle *track =
                 dynamic_cast<CandTrackHandle*>(tracklist.At(iprimary));
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fTrackList.
      AddAt(tracklist.At(0), iprimary);
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fTrackList.
      AddAt(track, 0);
  }
  if (primarytrack) {       // fPrimaryTrack is now an owned CandHandle*
    CandTrackHandle *ch = primarytrack->DupHandle();
    delete (dynamic_cast<CandEvent *>
                                   (GetOwnedCandBase()))->fPrimaryTrack;
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryTrack = ch;
  }
  else {
    delete (dynamic_cast<CandEvent *>
                                   (GetOwnedCandBase()))->fPrimaryTrack;
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fPrimaryTrack = 0;
  }
}

//______________________________________________________________________
void CandEventHandle::AddShower(const CandShowerHandle *shower)
{
  const TObjArray &showerlist =
                 (dynamic_cast<CandEvent*>(GetCandBase()))->fShowerList;
  Bool_t found(0);
  for (Int_t i=0; i<=showerlist.GetLast() && !found; i++) {
    CandShowerHandle *target =
                      dynamic_cast<CandShowerHandle*>(showerlist.At(i));
    if (*shower == *target) found = 1;
  }
  
  if (!found)                  // don't want to duplicate object in list
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fShowerList.
                                               Add(shower->DupHandle());
  return;
}

//______________________________________________________________________
void CandEventHandle::AddTrack(const CandTrackHandle *track)
{
  const TObjArray &tracklist =
                  (dynamic_cast<CandEvent*>(GetCandBase()))->fTrackList;
  Bool_t found(0);
  for (Int_t i=0; i<=tracklist.GetLast() && !found; i++) {
    CandTrackHandle *target =
                        dynamic_cast<CandTrackHandle*>(tracklist.At(i));
    if (*track == *target) found = 1;
  }

  if (!found)                  // don't want to duplicate object in list
    (dynamic_cast<CandEvent*>(GetOwnedCandBase()))->fTrackList.
                                                Add(track->DupHandle());
  return;
}

//______________________________________________________________________
void CandEventHandle::CompressShower()
{
  dynamic_cast<CandEvent*>(GetOwnedCandBase())->fShowerList.Compress();
}

//______________________________________________________________________
void CandEventHandle::CompressTrack()
{
  dynamic_cast<CandEvent*>(GetOwnedCandBase())->fTrackList.Compress();
}

void CandEventHandle::SetContained(Bool_t contained)
{
  dynamic_cast<CandEvent*>(GetOwnedCandBase())->fContained=contained;
}

Bool_t CandEventHandle::IsContained()
{
  return dynamic_cast<CandEvent*>(GetCandBase())->fContained;
}
//______________________________________________________________________

void CandEventHandle::SetEnergy(Double_t energy)
{
  dynamic_cast<CandEvent*>(GetOwnedCandBase())->fEnergy = energy;
}

Double_t CandEventHandle::GetEnergy() const
{
  return dynamic_cast<const CandEvent*>(GetCandBase())->fEnergy;
}


XXXITRIMP(CandEventHandle)

---