AlgEventSR.cxx

Go to the documentation of this file.

// $Id: AlgEventSR.cxx,v 1.29 2007/10/13 23:33:03 musser Exp $
//
// AlgEventSR.cxx
//
// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br> 
//
// AlgEventSR is a concrete EventSR Algorithm class.
//
// Author:  R. Lee 2001.03.07
//
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and 
// <a href="../CandEventSR.html"> CandEventSR Classes</a> (part of
// <a href="../index.html">The MINOS Class User Guide</a>)End_Html

#include <cassert>
#include <map>

#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "Algorithm/AlgConfig.h"
#include "Candidate/CandContext.h"
#include "CandEventSR/AlgEventSR.h"
#include "RecoBase/CandEventHandle.h"
#include "CandFitTrackSR/CandFitTrackSRHandle.h"
#include "CandTrackSR/CandTrackSRHandle.h"
#include "CandTrackSR/Track2DSR.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandShowerHandle.h"
#include "RecoBase/CandTrackHandle.h"
#include "Validity/VldContext.h"
#include "VertexFinder/VertexFinder.h"
#include "Calibrator/Calibrator.h"
#include "DataUtil/PlaneOutline.h"
#include "UgliGeometry/UgliGeomHandle.h"

ClassImp(AlgEventSR)

//______________________________________________________________________
CVSID("$Id: AlgEventSR.cxx,v 1.29 2007/10/13 23:33:03 musser Exp $");

//______________________________________________________________________
AlgEventSR::AlgEventSR()
{
}

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

//______________________________________________________________________
void AlgEventSR::RunAlg(AlgConfig &ac, CandHandle &ch, CandContext &cx)
{

  // get alg parameters
  Double_t shwshwdz = ac.GetDouble("ShwShwDz");
  Double_t minShwEFract = ac.GetDouble("MinShwEFract");
  Double_t isCosmic = ac.GetInt("IsCosmic");

  // check that all is well with inputs

  const CandRecord* candrec = dynamic_cast<CandRecord*>
    (cx.GetMom()->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (candrec==0) {
    MSG("EventSR", Msg::kWarning)
      << "No PrimaryCandidateRecord in MOM." << endl;
  }
  assert(candrec);
  const VldContext *vldcptr = candrec->GetVldContext();
  assert(vldcptr);
  assert(ch.InheritsFrom("CandEventHandle"));
  CandEventHandle &ceh = dynamic_cast<CandEventHandle &>(ch);
  assert(cx.GetDataIn());
  assert(cx.GetDataIn()->InheritsFrom("TObjArray"));
  const TObjArray *tary =
     dynamic_cast<const TObjArray*>(cx.GetDataIn());
  assert(tary->GetLast()>=0);


  // construct daughter strip list, and track and shower lists
  for (Int_t i=0; i<=tary->GetLast(); i++) {
    TObject *tobj = tary->At(i);
    assert(tobj->InheritsFrom("CandRecoHandle"));
    CandRecoHandle *recohandle = dynamic_cast<CandRecoHandle*>(tobj);
    CandStripHandleItr stripItr(recohandle->GetDaughterIterator());
    while (CandStripHandle *strip = stripItr()) {
      ceh.AddDaughterLink(*strip);
    }
    if (tobj->InheritsFrom("CandShowerHandle")) {
      CandShowerHandle *showerhandle = dynamic_cast<CandShowerHandle*>(tobj);
      ceh.AddShower(showerhandle);
    }
    if (tobj->InheritsFrom("CandTrackHandle")) {
      CandTrackHandle *trackhandle = dynamic_cast<CandTrackHandle*>(tobj);
      ceh.AddTrack(trackhandle);
    }
  }

  ceh.SetPrimaryTrack();
  ceh.SetPrimaryShower(minShwEFract,shwshwdz);

  MSG("EventSR", Msg::kVerbose)
      << "End Setting Primary Track and Shower" << endl;

  CandTrackHandle * besttrack = ceh.GetPrimaryTrack();
  CandShowerHandle * bestshower = ceh.GetPrimaryShower();

  // Use Boehm vertex finder - this is the default vertex for non-cosmic events
  VertexFinder Vfinder(&ceh,vldcptr); 
  Int_t result = Vfinder.FindVertex();

  if (besttrack) {
    ceh.SetVtxU(besttrack->GetVtxU());
    ceh.SetVtxV(besttrack->GetVtxV());
    ceh.SetVtxZ(besttrack->GetVtxZ());
    ceh.SetVtxT(besttrack->GetVtxT());
    ceh.SetVtxPlane(besttrack->GetVtxPlane());
    ceh.SetEndU(besttrack->GetEndU());
    ceh.SetEndV(besttrack->GetEndV());
    ceh.SetEndZ(besttrack->GetEndZ());
    ceh.SetEndT(besttrack->GetEndT());
    ceh.SetEndPlane(besttrack->GetTermPlane());
    ceh.SetVtxDirCosU(besttrack->GetVtxDirCosU());
    ceh.SetVtxDirCosV(besttrack->GetVtxDirCosV());
    ceh.SetVtxDirCosZ(besttrack->GetVtxDirCosZ());
    ceh.SetEndDirCosU(besttrack->GetEndDirCosU());
    ceh.SetEndDirCosV(besttrack->GetEndDirCosV());
    ceh.SetEndDirCosZ(besttrack->GetEndDirCosZ());
  }
  else if (bestshower) {
    ceh.SetVtxU(bestshower->GetVtxU());
    ceh.SetVtxV(bestshower->GetVtxV());
    ceh.SetVtxZ(bestshower->GetVtxZ());
    ceh.SetVtxT(bestshower->GetVtxT());
    ceh.SetVtxPlane(bestshower->GetVtxPlane());
    ceh.SetEndU(bestshower->GetEndU());
    ceh.SetEndV(bestshower->GetEndV());
    ceh.SetEndZ(bestshower->GetEndZ());
    ceh.SetEndT(bestshower->GetEndT());
    ceh.SetEndPlane(bestshower->GetTermPlane());
    ceh.SetVtxDirCosU(bestshower->GetVtxDirCosU());
    ceh.SetVtxDirCosV(bestshower->GetVtxDirCosV());
    ceh.SetVtxDirCosZ(bestshower->GetVtxDirCosZ());
    ceh.SetEndDirCosZ(bestshower->GetEndDirCosZ());
    ceh.SetEndDirCosU(bestshower->GetEndDirCosU());
    ceh.SetEndDirCosV(bestshower->GetEndDirCosV());
  }
  if(result==1 && !isCosmic){
    ceh.SetVtxU(Vfinder.VtxU());
    ceh.SetVtxV(Vfinder.VtxV());
    ceh.SetVtxZ(Vfinder.VtxZ());
    ceh.SetVtxPlane(Vfinder.VtxPlane());
  }

  Calibrate(&ceh);
  bool contained = true;
  // determine whether event is contained.
  // set energy
  Float_t energy=0;
  if(ceh.GetPrimaryTrack()){
    energy+=ceh.GetPrimaryTrack()->GetMomentum();
    contained = ceh.GetPrimaryTrack()->IsContained();
  }
  if(ceh.GetPrimaryShower()){
    energy+=ceh.GetPrimaryShower()->GetEnergy();
    contained &= ceh.GetPrimaryShower()->IsContained();
  }
  ceh.SetEnergy(energy);
  ceh.SetContained(contained);
}

//______________________________________________________________________
void AlgEventSR::Trace(const char * /* c */) const
{
}

---