////////////////////////////////////////////////////////////////////////
// Analysis Module for CandFitTrackCam
//
// For analysis and display of TrackFitting results
// Note the Pause() function which can be included or excluded in line 401
//
// marshall@hep.phy.cam.ac.uk
////////////////////////////////////////////////////////////////////////
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "JobControl/JobCModuleRegistry.h"

#include "Validity/VldContext.h"

// Reconstruction includes
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandSliceListHandle.h"
#include "RecoBase/CandSliceHandle.h"
#include "RecoBase/CandShowerListHandle.h"
#include "RecoBase/CandShowerHandle.h"
#include "RecoBase/CandTrackListHandle.h"
#include "RecoBase/CandTrackHandle.h"

#include "CandDigit/CandDeMuxDigitHandle.h"
#include "CandDigit/CandDeMuxDigit.h"

#include "CandFitTrackCam/CandFitTrackCamHandle.h"
#include "CandFitTrackCam/CandFitTrackCamListHandle.h"
#include "CandFitTrackCam/FitTrackCamAnalysisModule.h"

// For Truth info
#include "Record/SimSnarlRecord.h"
#include "Record/SimSnarlHeader.h"
#include "REROOT_Classes/REROOT_NeuKin.h"
#include "CandData/CandHeader.h"
#include "DataUtil/Truthifier.h"

// ROOT includes
#include "TH2F.h"
#include "TCanvas.h"
#include "TPad.h"
#include "TApplication.h"
#include "TSystem.h"
#include "TMarker.h"

// For pause function
#include <fcntl.h>
#include <unistd.h>

// for fabs()
#include <cmath>

using std::cout;
using std::endl;

JOBMODULE(FitTrackCamAnalysisModule, "FitTrackCamAnalysisModule", "Analyses track fit results");
CVSID("$Id: FitTrackCamAnalysisModule.cxx,v 1.12 2007/11/11 08:43:39 rhatcher Exp $");

////////////////////////////////////////////////////////////////////////
FitTrackCamAnalysisModule::FitTrackCamAnalysisModule()
{
  isMC=0;

  fListInSlc="CandSliceList";
  fListInShw="CandShowerList";
  fListInTrk="CandTrackSRList";
  fListInFitTrk="CandFitTrackCamList";

  fTrackCanvas = new TCanvas("fTrackCanvas","TrackView",800,500);
  fTrackCanvas->Draw();
  
  // Pads
  fUZPad   = new TPad("upad","U pad",0.010,0.505,0.495,0.990);
  fVZPad   = new TPad("vpad","V pad",0.010,0.010,0.495,0.495);
  fUZMCPad   = new TPad("uMCpad","U pad",0.505,0.505,0.990,0.990);
  fVZMCPad   = new TPad("vMCpad","V pad",0.505,0.010,0.990,0.495);

  fUZPad->SetFillColor(10);
  fVZPad->SetFillColor(10);
  fUZMCPad->SetFillColor(10);
  fVZMCPad->SetFillColor(10);

  fUZPad->SetLeftMargin(0.05);
  fUZPad->SetRightMargin(0.001);
  fUZPad->SetTopMargin(0.0001);
  fUZPad->SetBottomMargin(0.055);
  fVZPad->SetLeftMargin(0.05);
  fVZPad->SetRightMargin(0.001);
  fVZPad->SetTopMargin(0.0001);
  fVZPad->SetBottomMargin(0.055);

  fUZMCPad->SetLeftMargin(0.05);
  fUZMCPad->SetRightMargin(0.001);
  fUZMCPad->SetTopMargin(0.0001);
  fUZMCPad->SetBottomMargin(0.055);
  fVZMCPad->SetLeftMargin(0.05);
  fVZMCPad->SetRightMargin(0.001);
  fVZMCPad->SetTopMargin(0.0001);
  fVZMCPad->SetBottomMargin(0.055);

  fUZPad->Draw();
  fVZPad->Draw();
  fUZMCPad->Draw();
  fVZMCPad->Draw();

  fUZAxis=0;
  fVZAxis=0;
  fUZMCAxis=0;
  fVZMCAxis=0;


  // For writing results to file
  TDirectory* tmpd = 0;
  tmpd = gDirectory;  

  FTCFile = new TFile("FTCResults.root","recreate");
  FTCTree = new TTree("FTCTree","FTCTree");

  // Header info
  FTCTree->Branch("Run",&Run,"Run/I");
  FTCTree->Branch("Snarl",&Snarl,"Snarl/I");
  FTCTree->Branch("NumFittedTracks",&NumFittedTracks,"NumFittedTracks/I");
  FTCTree->Branch("Pass",&Pass,"Pass/I");

  // Momentum-related quantities
  FTCTree->Branch("RecoQP",&RecoQP,"RecoQP/D");
  FTCTree->Branch("TrueQP",&TrueQP,"TrueQP/D");
  FTCTree->Branch("QPVtxError",&QPVtxError,"QPVtxError/D");
  FTCTree->Branch("RecoMomCurve",&RecoMomCurve,"RecoMomCurve/D");
  FTCTree->Branch("RecoMomRange",&RecoMomRange,"RecoMomRange/D");
  FTCTree->Branch("TrueMom",&TrueMom,"TrueMom/D");
  FTCTree->Branch("RecoTime",&RecoTime,"RecoTime/D");

  // For checking tracking efficency
  FTCTree->Branch("FitTrackStrips",&FitTrackStrips,"FitTrackStrips/I");
  FTCTree->Branch("TrueMuonStrips",&TrueMuonStrips,"TrueMuonStrips/I");
  FTCTree->Branch("FitAndTruthAgree",&FitAndTruthAgree,"FitAndTruthAgree/I");
  FTCTree->Branch("FitTrackLength",&FitTrackLength,"FitTrackLength/I");
  FTCTree->Branch("TrueTrackLength",&TrueTrackLength,"TrueTrackLength/I");
  FTCTree->Branch("TotalStripsInSnarl",&TotalStripsInSnarl,"TotalStripsInSnarl/I");  
  FTCTree->Branch("FDFullyContained",&FDFullyContained,"FDFullyContained/I");
  FTCTree->Branch("NTrackStrip",&NTrackStrip,"NTrackStrip/I");
  FTCTree->Branch("NTrackDigit",&NTrackDigit,"NTrackDigit/I");

  // Track fit quality
  FTCTree->Branch("Chi2",&Chi2,"Chi2/D");
  FTCTree->Branch("NDOF",&NDOF,"NDOF/I");
  FTCTree->Branch("NIterate",&NIterate,"NIterate/I");
  FTCTree->Branch("NSwimFail",&NSwimFail,"NSwimFail/I");

  // Timing info
  FTCTree->Branch("TimeSlope",&TimeSlope,"TimeSlope/D");
  FTCTree->Branch("TimeOffset",&TimeOffset,"TimeOffset/D");
  FTCTree->Branch("VtxT",&VtxT,"VtxT/D");
  FTCTree->Branch("EndT",&EndT,"EndT/D");
  FTCTree->Branch("TimeFitChi2",&TimeFitChi2,"TimeFitChi2/D");
  FTCTree->Branch("NTimeFitDigit",&NTimeFitDigit,"NTimeFitDigit/D");
  FTCTree->Branch("TimeForwardFitRMS",&TimeForwardFitRMS,"TimeForwardFitRMS/D");
  FTCTree->Branch("TimeForwardFitNDOF",&TimeForwardFitNDOF,"TimeForwardFitNDOF/I");
  FTCTree->Branch("TimeBackwardFitRMS",&TimeBackwardFitRMS,"TimeBackwardFitRMS/D");
  FTCTree->Branch("TimeBackwardFitNDOF",&TimeBackwardFitNDOF,"TimeBackwardFitNDOF/I");
  
  // Vtx properties
  FTCTree->Branch("VtxU",&VtxU,"VtxU/D");
  FTCTree->Branch("VtxV",&VtxV,"VtxV/D");
  FTCTree->Branch("VtxZ",&VtxZ,"VtxZ/D");
  FTCTree->Branch("VtxPlane",&VtxPlane,"VtxPlane/I");

  FTCTree->Branch("VtxDirCosU",&VtxDirCosU,"VtxDirCosU/D");
  FTCTree->Branch("VtxDirCosV",&VtxDirCosV,"VtxDirCosV/D");
  FTCTree->Branch("VtxDirCosZ",&VtxDirCosZ,"VtxDirCosZ/D");

  FTCTree->Branch("VtxUError",&VtxUError,"VtxUError/D");
  FTCTree->Branch("VtxVError",&VtxVError,"VtxVError/D");
  FTCTree->Branch("VtxdUError",&VtxdUError,"VtxdUError/D");
  FTCTree->Branch("VtxdVError",&VtxdVError,"VtxdVError/D");


  // End properties
  FTCTree->Branch("EndU",&EndU,"EndU/D");
  FTCTree->Branch("EndV",&EndV,"EndV/D");
  FTCTree->Branch("EndZ",&EndZ,"EndZ/D");
  FTCTree->Branch("EndPlane",&EndPlane,"EndPlane/I");
  FTCTree->Branch("EndQP",&EndQP,"EndQP/D");

  FTCTree->Branch("EndDirCosU",&EndDirCosU,"EndDirCosU/D");
  FTCTree->Branch("EndDirCosV",&EndDirCosV,"EndDirCosV/D");
  FTCTree->Branch("EndDirCosZ",&EndDirCosZ,"EndDirCosZ/D");

  FTCTree->Branch("EndUError",&EndUError,"EndUError/D");
  FTCTree->Branch("EndVError",&EndVError,"EndVError/D");
  FTCTree->Branch("EnddUError",&EnddUError,"EnddUError/D");
  FTCTree->Branch("EnddVError",&EnddVError,"EnddVError/D");
  FTCTree->Branch("EndQOError",&EndQPError,"EndQPError/D");

  // Range and dS
  FTCTree->Branch("Range",&Range,"Range/D");
  FTCTree->Branch("dS",&dS,"dS/D");


  // Traces
  FTCTree->Branch("VtxTrace",&VtxTrace,"VtxTrace/D");
  FTCTree->Branch("VtxTraceZ",&VtxTraceZ,"VtxTraceZ/D");
  FTCTree->Branch("EndTrace",&EndTrace,"EndTrace/D");
  FTCTree->Branch("EndTraceZ",&EndTraceZ,"EndTraceZ/D");

  gDirectory = tmpd;
}
////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////
FitTrackCamAnalysisModule::~FitTrackCamAnalysisModule()
{
  if(fTrackCanvas) {delete fTrackCanvas;}

  if(fUZAxis) {delete fUZAxis;}
  if(fVZAxis) {delete fVZAxis;}
  if(fUZMCAxis) {delete fUZMCAxis;} 
  if(fVZMCAxis) {delete fVZMCAxis;} 
}
////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::BeginJob()
{
}
////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::EndJob()
{
  TDirectory* tmpd = 0;
  tmpd = gDirectory;  
  FTCFile->cd();
  FTCTree->Write();
  FTCFile->Close();
  gDirectory = tmpd;
}
////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////
JobCResult FitTrackCamAnalysisModule::Ana(const MomNavigator* mom)
{
  MSG("FitTrack", Msg::kDebug) << " FitTrackCamAnalysisModule::Ana(const MomNavigator* mom) " << endl;

  // Do we care about XTalk?
  CareAboutXTalk=true;
  debug=false;

  ////////////////////////////////////////////////////////
  // Make sure we have a 'clean' start
  if ( fUZAxis ) { delete fUZAxis; fUZAxis=0; }
  if ( fVZAxis ) { delete fVZAxis; fVZAxis=0; }
  if ( fUZMCAxis ) { delete fUZMCAxis; fUZMCAxis=0; }
  if ( fVZMCAxis ) { delete fVZMCAxis; fVZMCAxis=0; }
  
  fMaxZ = -1;
  fMinZ = 50;
  fMaxUorV = -20;
  fMinUorV = 20;

  fFitEndPlane = -1;
  fFitVtxPlane = 500;
  fTrueMaxPlane = -1;
  fTrueMinPlane = 500;

  Run=-999;
  Snarl=-999;
  NumFittedTracks=-999;
  Pass=-999;

  RecoQP=-999;
  TrueQP=-999;
  QPVtxError=-999;
  RecoMomCurve=-999;
  RecoMomRange=-999;
  TrueMom=-999;
  RecoTime=-999;

  FitTrackStrips=-999;
  TrueMuonStrips=-999;
  FitAndTruthAgree=-999;
  FitTrackLength=-999;
  TrueTrackLength=-999;
  TotalStripsInSnarl=-999;
  FDFullyContained=-999;
  NTrackStrip=-999;
  NTrackDigit=-999;

  Chi2=-999;
  NDOF=-999;
  NIterate=-999;
  NSwimFail=-999;

  TimeSlope=-999;
  TimeOffset=-999;
  VtxT=-999;
  EndT=-999;
  TimeFitChi2=-999;
  NTimeFitDigit=-999;
  TimeForwardFitRMS=-999;
  TimeForwardFitNDOF=-999;
  TimeBackwardFitRMS=-999;
  TimeBackwardFitNDOF=-999;

  VtxU=-999;
  VtxV=-999;	   
  VtxZ=-999;	   
  VtxPlane=-999; 
		   
  VtxDirCosU=-999;
  VtxDirCosV=-999;
  VtxDirCosZ=-999;
  
  VtxUError=-999;
  VtxVError=-999;
  VtxdUError=-999;
  VtxdVError=-999;
		   
  EndU=-999;	   
  EndV=-999;	   
  EndZ=-999;	   
  EndPlane=-999; 
  EndQP=-999;

  EndDirCosU=-999;
  EndDirCosV=-999;
  EndDirCosZ=-999;
		   
  EndUError=-999;
  EndVError=-999;
  EnddUError=-999;
  EnddVError=-999;
  EndQPError=-999;

  Range=-999;	   
  dS=-999;	   
  
  VtxTrace=-999; 
  VtxTraceZ=-999;
  EndTrace=-999; 
  EndTraceZ=-999;
  ////////////////////////////////////////////////////////


  // Needed by methods
  ////////////////////////////////////////////////////////
  candrec = dynamic_cast<CandRecord *> (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  
  if(!candrec)
    {
      MSG("FitTrack", Msg::kWarning) << " Failed to Find CandRecord " << endl;
      return JobCResult::kFailed;
    }

  // Header info
  CandHeader* candhead = (CandHeader*)(candrec->GetCandHeader());
  Run=candhead->GetRun();
  Snarl=candhead->GetSnarl();

  cout << "Snarl: " << Snarl << endl;

  VldContext *vldc = (VldContext*)(candrec->GetVldContext());  
  ////////////////////////////////////////////////////////


  // Run methods 
  ////////////////////////////////////////////////////////
  ConfigureAxes(vldc);
  SliceSection();
  ShowerSection();
  TrackSection();
  FittedTrackSection();


  // Truth section
  if(vldc->GetSimFlag()==SimFlag::kMC) {
    isMC=1;

    Truthifier* mytruth = new Truthifier(mom);

    //Get SimSnarlRecord
    SimSnarlRecord* simrec = dynamic_cast<SimSnarlRecord *>(mom->GetFragment("SimSnarlRecord"));
    if(simrec) {TruthSection(simrec);}
    
    TruthSliceSection(mytruth);
    EfficiencySection(mytruth);

    delete mytruth;
  }

  // Write ntuple
  TDirectory* tmpd = 0;
  tmpd = gDirectory;  
  FTCFile->cd();
  FTCTree->Fill();
  gDirectory = tmpd;

  Draw();
  //  Pause();
  CleanUp();
  ////////////////////////////////////////////////////////


  return JobCResult::kPassed; // kNoDecision, kFailed, etc.
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////



///////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::ConfigureAxes(VldContext *vldc)  
{
  // Axes -  Determine for detector

  if (vldc->GetDetector()==Detector::kNear)
    {
      fUZAxis = new TH2F("UZAxis", "U view Near, Reco", 200, 0., 20., 80, -4., 4.);
      fVZAxis = new TH2F("VZAxis", "V view Near, Reco", 200, 0., 20., 80, -4., 4.);

      fUZMCAxis = new TH2F("UZMCAxis", "U view Near, Truth", 200, 0., 20., 80, -4., 4.);
      fVZMCAxis = new TH2F("VZMCAxis", "V view Near, Truth", 200, 0., 20., 80, -4., 4.);
    }
  else if (vldc->GetDetector()==Detector::kFar)
    {
      fUZAxis = new TH2F("UZAxis", "U view Far, Reco", 300, 0., 30., 100, -5., 5.);
      fVZAxis = new TH2F("VZAxis", "V view Far, Reco", 300, 0., 30., 100, -5., 5.);

      fUZMCAxis = new TH2F("UZMCAxis", "U view Far, Truth", 300, 0., 30., 100, -5., 5.);
      fVZMCAxis = new TH2F("VZMCAxis", "V view Far, Truth", 300, 0., 30., 100, -5., 5.);
    }
  else {cout << "Require detector to be near or far!!!" << endl;}

  // don't draw the Stats box
  fUZAxis->SetStats(kFALSE);
  fVZAxis->SetStats(kFALSE);
  fUZMCAxis->SetStats(kFALSE);
  fVZMCAxis->SetStats(kFALSE);

  // take away any association with a "directory" for these histograms
  fUZAxis->SetDirectory(0);
  fVZAxis->SetDirectory(0);
  fUZMCAxis->SetDirectory(0);
  fVZMCAxis->SetDirectory(0);

  // Draw empty canvas
  fUZPad->cd();
  fUZAxis->Draw();

  fVZPad->cd();
  fVZAxis->Draw();

  fUZMCPad->cd();
  fUZMCAxis->Draw();

  fVZMCPad->cd();
  fVZMCAxis->Draw();

  fTrackCanvas->cd();
}
///////////////////////////////////////////////////////////////////////



///////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::SliceSection()
{
  vector<TMarker> fThisSliceUZ;
  vector<TMarker> fThisSliceVZ;
  CandSliceListHandle* slice_list = 0;

  // Get CandSliceListHandle
  slice_list = dynamic_cast<CandSliceListHandle*>
    (candrec->FindCandHandle("CandSliceListHandle",fListInSlc.Data()));

  if(!slice_list) {MSG("FitTrack", Msg::kWarning) << " Failed to Find " << fListInSlc.Data() << endl; }

  else {
    assert(slice_list);
    if(slice_list->GetNDaughters()<1) {MSG("FitTrack", Msg::kWarning) << "SliceList was empty... " << endl; }

    // loop over the slices
    TIter SlcItr = slice_list->GetDaughterIterator();
    while(CandSliceHandle* Slc = dynamic_cast<CandSliceHandle*>(SlcItr()))
      {
	
	TIter SlcStripItr = Slc->GetDaughterIterator();
	while(CandStripHandle* SlcStrip = dynamic_cast<CandStripHandle*>(SlcStripItr()))
	  {

	    TIter digitrSlcXTalk = SlcStrip->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* SlcDigit = dynamic_cast<CandDeMuxDigitHandle*>(digitrSlcXTalk())) 
	      {
		// For U type planes
		if(int(SlcStrip->GetPlaneView())==2 && (SlcDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmUSlc(SlcStrip->GetZPos(),  SlcStrip->GetTPos(), 20);	
		  tmpmUSlc.SetMarkerColor(3);
		  tmpmUSlc.SetMarkerSize(0.8);
		  fThisSliceUZ.push_back(tmpmUSlc);
		}
		
		// For V type planes
		else if(int(SlcStrip->GetPlaneView())==3 && (SlcDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmVSlc(SlcStrip->GetZPos(),  SlcStrip->GetTPos(), 20);	
		  tmpmVSlc.SetMarkerColor(3);
		  tmpmVSlc.SetMarkerSize(0.8);
		  fThisSliceVZ.push_back(tmpmVSlc);
		}
		
		if(SlcStrip->GetZPos() > fMaxZ) fMaxZ=SlcStrip->GetZPos();
		if(SlcStrip->GetZPos() < fMinZ) fMinZ=SlcStrip->GetZPos();
		
		if(SlcStrip->GetTPos() > fMaxUorV) fMaxUorV=SlcStrip->GetTPos();
		if(SlcStrip->GetTPos() < fMinUorV) fMinUorV=SlcStrip->GetTPos();
	      }
	    digitrSlcXTalk.Reset();
	  }
	SlcStripItr.Reset();
	
	fUZSliceMarker.push_back(fThisSliceUZ);
	fVZSliceMarker.push_back(fThisSliceVZ);
      }
    SlcItr.Reset();
  }
}
///////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::ShowerSection()
{
  vector<TMarker> fThisShowerUZ;
  vector<TMarker> fThisShowerVZ;
  CandShowerListHandle* shower_list = 0;

  // Get CandShowerListHandle
  shower_list = dynamic_cast<CandShowerListHandle*>
    (candrec->FindCandHandle("CandShowerListHandle",fListInShw.Data()));

  if(!shower_list) {MSG("FitTrack", Msg::kWarning) << " Failed to Find " << fListInShw.Data() << endl; }

  else {
    assert(shower_list);
    if(shower_list->GetNDaughters()<1) {MSG("FitTrack", Msg::kWarning) << "ShowerList was empty... " << endl; }
    
    // loop over the showers
    TIter ShwItr = shower_list->GetDaughterIterator();
    while(CandShowerHandle* Shw = dynamic_cast<CandShowerHandle*>(ShwItr()))
      {
	
	TIter ShwStripItr = Shw->GetDaughterIterator();
	while(CandStripHandle* ShwStrip = dynamic_cast<CandStripHandle*>(ShwStripItr()))
	  {
	    
	    TIter digitrShwXTalk = ShwStrip->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* ShwDigit = dynamic_cast<CandDeMuxDigitHandle*>(digitrShwXTalk())) 
	      {
		// For U type planes
		if(int(ShwStrip->GetPlaneView())==2 && (ShwDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmUShw(ShwStrip->GetZPos(),  ShwStrip->GetTPos(), 24);	
		  tmpmUShw.SetMarkerColor(5);
		  fThisShowerUZ.push_back(tmpmUShw);
		}
		
		// For V type planes
		else if(int(ShwStrip->GetPlaneView())==3 && (ShwDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmVShw(ShwStrip->GetZPos(),  ShwStrip->GetTPos(), 24);	
		  tmpmVShw.SetMarkerColor(5);
		  fThisShowerVZ.push_back(tmpmVShw);
		}
		
		if(ShwStrip->GetZPos() > fMaxZ) fMaxZ=ShwStrip->GetZPos();
		if(ShwStrip->GetZPos() < fMinZ) fMinZ=ShwStrip->GetZPos();
		
		if(ShwStrip->GetTPos() > fMaxUorV) fMaxUorV=ShwStrip->GetTPos();
		if(ShwStrip->GetTPos() < fMinUorV) fMinUorV=ShwStrip->GetTPos();
		
	      }
	    digitrShwXTalk.Reset();
	    
	  }
	ShwStripItr.Reset();
	
	fUZShowerMarker.push_back(fThisShowerUZ);
	fVZShowerMarker.push_back(fThisShowerVZ);
      }
    ShwItr.Reset();
  }
}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::TrackSection()
{
  vector<TMarker> fThisTrackUZ;
  vector<TMarker> fThisTrackVZ;
  int numTrk=0;
  CandTrackListHandle* track_list = 0;

  // Get CandTrackListHandle
  track_list = dynamic_cast<CandTrackListHandle*>
    (candrec->FindCandHandle("CandTrackListHandle",fListInTrk.Data()));

  if(!track_list)    {MSG("Track", Msg::kWarning) << " Failed to Find " << fListInTrk.Data() << endl; }

  else {
    assert(track_list);
    if(track_list->GetNDaughters()<1) {MSG("Track", Msg::kWarning) << "Tracklist was empty... " << endl; }

    // loop over the simple tracks
    TIter TrkItr = track_list->GetDaughterIterator();
    while(CandTrackHandle* Trk = dynamic_cast<CandTrackHandle*>(TrkItr()))
      {
	numTrk++;


	TIter TrkStripItr = Trk->GetDaughterIterator();
	while(CandStripHandle* TrkStrip = dynamic_cast<CandStripHandle*>(TrkStripItr()))
	  {

	    TIter digitrTrkXTalk = TrkStrip->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* TrkDigit = dynamic_cast<CandDeMuxDigitHandle*>(digitrTrkXTalk())) 
	      {
		// For U type planes
		if(int(TrkStrip->GetPlaneView())==2 && (TrkDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmUTrk(TrkStrip->GetZPos(),  TrkStrip->GetTPos(), 24);	
		  tmpmUTrk.SetMarkerColor(4);
		  fThisTrackUZ.push_back(tmpmUTrk);
		}

		// For V type planes
		else if(int(TrkStrip->GetPlaneView())==3 && (TrkDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmVTrk(TrkStrip->GetZPos(), TrkStrip->GetTPos(), 24);	
		  tmpmVTrk.SetMarkerColor(4);
		  fThisTrackVZ.push_back(tmpmVTrk);
		}
	
		if(TrkStrip->GetZPos() > fMaxZ) fMaxZ=TrkStrip->GetZPos();
		if(TrkStrip->GetZPos() < fMinZ) fMinZ=TrkStrip->GetZPos();
	  
		if(TrkStrip->GetTPos() > fMaxUorV) fMaxUorV=TrkStrip->GetTPos();
		if(TrkStrip->GetTPos() < fMinUorV) fMinUorV=TrkStrip->GetTPos();

	      }
	    digitrTrkXTalk.Reset();
	    
	  }
	TrkStripItr.Reset();

	fUZTrackMarker.push_back(fThisTrackUZ);
	fVZTrackMarker.push_back(fThisTrackVZ);
      }
    TrkItr.Reset();

    if(debug) {cout << "Number of simple tracks: " << numTrk << endl;}
  }
}
////////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::FittedTrackSection()
{
  vector<TMarker> fThisFitTrackUZ;
  vector<TMarker> fThisFitTrackVZ;
  int numFitTrk=0;
  CandFitTrackListHandle* fit_track_list = 0;

  // Get CandFitTrackListHandle
  fit_track_list = dynamic_cast<CandFitTrackListHandle*>
    (candrec->FindCandHandle("CandFitTrackListHandle",fListInFitTrk.Data()));

  if(!fit_track_list) {
    MSG("FitTrack", Msg::kWarning) << " Failed to Find " << fListInFitTrk.Data() << endl;
    NumFittedTracks=0;
    FitTrackLength=0;
  }

  else {
    assert(fit_track_list);
    if(fit_track_list->GetNDaughters()<1) {MSG("FitTrack", Msg::kWarning) << "FitTracklist was empty... " << endl; }

    // loop over the fittedtracks
    TIter FitTrkItr = fit_track_list->GetDaughterIterator();
    while(CandFitTrackCamHandle* FitTrk = dynamic_cast<CandFitTrackCamHandle*>(FitTrkItr()))
      {
	numFitTrk++;

	/////////////////////////////////
	// Fully contained?
	bool EndContained=false; bool VtxContained=false;

	if( fabs(FitTrk->GetEndU())<3.5 && fabs(FitTrk->GetEndV())<3.5 
	    && fabs( pow(0.5,0.5)*(FitTrk->GetEndU()-FitTrk->GetEndV()) )<3.5 
	    && fabs( pow(0.5,0.5)*(FitTrk->GetEndU()+FitTrk->GetEndV()) )<3.5
	    
	    && fabs( pow( pow(FitTrk->GetEndU(),2) + pow(FitTrk->GetEndV(),2),0.5) )>.4
	    
	    && (FitTrk->GetTermPlane())<480 && (FitTrk->GetTermPlane())>5

	    && ( (FitTrk->GetTermPlane())>254 || (FitTrk->GetTermPlane())<243 ) )
	  
	  {EndContained=true;}
	
	if( fabs(FitTrk->GetVtxU())<3.5 && fabs(FitTrk->GetVtxV())<3.5 
	    && fabs( pow(0.5,0.5)*(FitTrk->GetVtxU()-FitTrk->GetVtxV()) )<3.5 
	    && fabs( pow(0.5,0.5)*(FitTrk->GetVtxU()+FitTrk->GetVtxV()) )<3.5
	    
	    && fabs( pow( pow(FitTrk->GetVtxU(),2) + pow(FitTrk->GetVtxV(),2),0.5) )>.4
	    
	    && (FitTrk->GetVtxPlane())<480 && (FitTrk->GetVtxPlane())>5

	    && ( (FitTrk->GetVtxPlane())>254 || (FitTrk->GetVtxPlane())<243 ) )
	  
	  {VtxContained=true;}
	
	if(EndContained==true && VtxContained==true) {FDFullyContained=1;}
	else {FDFullyContained=0;}
	/////////////////////////////////


	TIter FitTrkStripItr = FitTrk->GetDaughterIterator();
	while(CandStripHandle* FitTrkStrip = dynamic_cast<CandStripHandle*>(FitTrkStripItr()))
	  {

	    TIter digitrFitTrkXTalk = FitTrkStrip->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* FitTrkDigit = dynamic_cast<CandDeMuxDigitHandle*>(digitrFitTrkXTalk())) 
	      {
		// For U type planes
		if(int(FitTrkStrip->GetPlaneView())==2 && (FitTrkDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmUFitTrk(FitTrkStrip->GetZPos(),  FitTrkStrip->GetTPos(), 23+numFitTrk);	
		  tmpmUFitTrk.SetMarkerColor(2);
		  fThisFitTrackUZ.push_back(tmpmUFitTrk);
		}

		// For V type planes
		else if(int(FitTrkStrip->GetPlaneView())==3 && (FitTrkDigit->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmVFitTrk(FitTrkStrip->GetZPos(), FitTrkStrip->GetTPos(), 23+numFitTrk);	
		  tmpmVFitTrk.SetMarkerColor(2);
		  fThisFitTrackVZ.push_back(tmpmVFitTrk);
		}
	
		if(FitTrkStrip->GetZPos() > fMaxZ) fMaxZ=FitTrkStrip->GetZPos();
		if(FitTrkStrip->GetZPos() < fMinZ) fMinZ=FitTrkStrip->GetZPos();
	  
		if(FitTrkStrip->GetTPos() > fMaxUorV) fMaxUorV=FitTrkStrip->GetTPos();
		if(FitTrkStrip->GetTPos() < fMinUorV) fMinUorV=FitTrkStrip->GetTPos();

		if(FitTrkStrip->GetPlane() > fFitEndPlane) fFitEndPlane=FitTrkStrip->GetPlane();
		if(FitTrkStrip->GetPlane() < fFitVtxPlane) fFitVtxPlane=FitTrkStrip->GetPlane();
	      }
	    digitrFitTrkXTalk.Reset();

	  }
	FitTrkStripItr.Reset();


	// Fill tree
	///////////////////////
	if(fit_track_list->GetNDaughters()==1) {
	  Pass=FitTrk->GetPass();

	  RecoMomCurve=FitTrk->GetMomentumCurve();
	  if(FitTrk->GetMomentumCurve()!=0) {RecoQP=FitTrk->GetEMCharge()/FitTrk->GetMomentumCurve();}
	  QPVtxError=FitTrk->GetVtxQPError();
	  RecoTime=FitTrk->GetCPUTime();

	  RecoMomRange=FitTrk->GetMomentumRange();

	  NTrackStrip=FitTrk->GetNTrackStrip();
	  NTrackDigit=FitTrk->GetNTrackDigit();

	  Chi2=FitTrk->GetChi2();
	  NDOF=FitTrk->GetNDOF();
	  NIterate=FitTrk->GetNIterate();
	  NSwimFail=FitTrk->GetNSwimFail();

	  TimeSlope=FitTrk->GetTimeSlope();
	  TimeOffset=FitTrk->GetTimeOffset();
	  VtxT=FitTrk->GetVtxT();
	  EndT=FitTrk->GetEndT();
	  TimeFitChi2=FitTrk->GetTimeFitChi2();
	  NTimeFitDigit=FitTrk->GetNTimeFitDigit();
	  TimeForwardFitRMS=FitTrk->GetTimeForwardFitRMS();
	  TimeForwardFitNDOF=FitTrk->GetTimeForwardFitNDOF();
	  TimeBackwardFitRMS=FitTrk->GetTimeBackwardFitRMS();
	  TimeBackwardFitNDOF=FitTrk->GetTimeBackwardFitNDOF();

	  VtxU=FitTrk->GetVtxU();
	  VtxV=FitTrk->GetVtxV();
	  VtxZ=FitTrk->GetVtxZ();
	  VtxPlane=FitTrk->GetVtxPlane();

	  VtxDirCosU=FitTrk->GetVtxDirCosU();
	  VtxDirCosV=FitTrk->GetVtxDirCosV();
	  VtxDirCosZ=FitTrk->GetVtxDirCosZ();

	  VtxUError=FitTrk->GetVtxUError();
	  VtxVError=FitTrk->GetVtxVError();
	  VtxdUError=FitTrk->GetVtxdUError();
	  VtxdVError=FitTrk->GetVtxdVError();

	  EndU=FitTrk->GetEndU();
	  EndV=FitTrk->GetEndV();
	  EndZ=FitTrk->GetEndZ();
	  EndPlane=FitTrk->GetTermPlane();
	  EndQP=FitTrk->GetEndQP();

	  EndDirCosU=FitTrk->GetEndDirCosU();
	  EndDirCosV=FitTrk->GetEndDirCosV();
	  EndDirCosZ=FitTrk->GetEndDirCosZ();

	  EndUError=FitTrk->GetEndUError();
	  EndVError=FitTrk->GetEndVError();
	  EnddUError=FitTrk->GetEnddUError();
	  EnddVError=FitTrk->GetEnddVError();
	  EndQPError=FitTrk->GetEndQPError();

	  Range=FitTrk->GetRange();
	  dS=FitTrk->GetdS();

	  VtxTrace=FitTrk->GetVtxTrace();
	  VtxTraceZ=FitTrk->GetVtxTraceZ();
	  EndTrace=FitTrk->GetEndTrace();
	  EndTraceZ=FitTrk->GetEndTraceZ();
	  
	  FitTrackLength=fFitEndPlane-fFitVtxPlane;
  
	  cout << "Cam Fitter charge * momentum result: " << FitTrk->GetEMCharge()*FitTrk->GetMomentumCurve() << endl;
	  cout << "Cam Fitter q/p vertex error: " << FitTrk->GetVtxQPError() << endl;
	  cout << "Cam Fitter CPU time: " << FitTrk->GetCPUTime() << endl;
	}
	else {
	  cout << "Multiple tracks!" << endl;
	  cout << "Cam Fitter charge * momentum result: " << FitTrk->GetEMCharge()*FitTrk->GetMomentumCurve() << endl;
	  cout << "Cam Fitter q/p vertex error: " << FitTrk->GetVtxQPError() << endl;
	  cout << "Cam Fitter CPU time: " << FitTrk->GetCPUTime() << endl;
	}
	//////////////////////

	fUZFitTrackMarker.push_back(fThisFitTrackUZ);
	fVZFitTrackMarker.push_back(fThisFitTrackVZ);
      }
    FitTrkItr.Reset();

    if(debug) {
      cout << "Number of fitted tracks: " << numFitTrk << endl;
      cout << "Fit track length: " << FitTrackLength << endl;}
    
    NumFittedTracks=numFitTrk;
  }
} 
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::TruthSection(SimSnarlRecord* simrec)
{   
  double fEmu=0;

  TObjArray arr(simrec->GetComponents());
  TIter iter(arr.MakeIterator());
  while(TObject* tob = (TObject*)(iter()))
    {
      if(tob->GetName()==TString("REROOT_NeuKin"))
	{
	  REROOT_NeuKin* nukin = dynamic_cast<REROOT_NeuKin*>(tob);
	  fEmu = nukin->P4Mu1()[3]; // Multiple muons?
	}   
    }
    
  cout << "--- True muon momentum * charge: " << fEmu << endl;


  // Get CandFitTrackListHandle
  CandFitTrackListHandle* fit_track_list = dynamic_cast<CandFitTrackListHandle*>
    (candrec->FindCandHandle("CandFitTrackListHandle",fListInFitTrk.Data()));

    
  // Fill tree
  ////////////////////
  if(fit_track_list) {
    if(fit_track_list->GetNDaughters()==1) {
      if(fEmu!=0.) {TrueQP=1./fEmu;}
      else{TrueQP=-999;}
      TrueMom=fabs(fEmu);
    }
    else {TrueQP=-999; TrueMom=-999;}
  }
  else {TrueQP=-999; TrueMom=-999;}
  //////////////////
  

  // Display
  //////////////////
  if(fit_track_list) {
    if(fEmu!=0. && fit_track_list->GetNDaughters()==1) {
      cout << "--- (Reco - Truth) / Truth: " << (RecoMomCurve-TrueMom)/ TrueMom << endl;
    }
  } 
  //////////////////

}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::TruthSliceSection(Truthifier* mytruth)
{
  int numTrueMuonDigits=0;
  int numTrueMuonStrips=0;

  int numSliceStrips=0;

  vector<TMarker> fThisSliceUZTruth;
  vector<TMarker> fThisSliceVZTruth;

  vector<TMarker> fThisTrackUZTruth;
  vector<TMarker> fThisTrackVZTruth;

  // Get CandSliceListHandle
  CandSliceListHandle* slice_list = dynamic_cast<CandSliceListHandle*>
    (candrec->FindCandHandle("CandSliceListHandle",fListInSlc.Data()));

  if(!slice_list)    {MSG("FitTrack", Msg::kWarning) << " Failed to Find " << fListInSlc.Data() << endl;}

  else {
    assert(slice_list);
    if(slice_list->GetNDaughters()<1) {MSG("FitTrack", Msg::kWarning) << "SliceList was empty... " << endl; }     
      
    TIter SlcItrTruth = slice_list->GetDaughterIterator();
    while(CandSliceHandle* SlcTruth = dynamic_cast<CandSliceHandle*>(SlcItrTruth()))
      {
	
	TIter SlcStripItrTruth = SlcTruth->GetDaughterIterator();
	while(CandStripHandle* SlcStripTruth = dynamic_cast<CandStripHandle*>(SlcStripItrTruth()))
	  {
	    numSliceStrips++;

	    TIter digitrTruth = SlcStripTruth->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* SlcDigitTruth = dynamic_cast<CandDeMuxDigitHandle*>(digitrTruth())) 
	      {	
		// For U type planes
		if(int(SlcStripTruth->GetPlaneView())==2 && (SlcDigitTruth->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmUSlcTruth(SlcStripTruth->GetZPos(),  SlcStripTruth->GetTPos(), 20);	
		  tmpmUSlcTruth.SetMarkerColor(3);
		  tmpmUSlcTruth.SetMarkerSize(0.8);
		  fThisSliceUZTruth.push_back(tmpmUSlcTruth);
		}
		  
		// For V type planes
		else if(int(SlcStripTruth->GetPlaneView())==3 && (SlcDigitTruth->GetDeMuxDigitFlagWord()!=1 || CareAboutXTalk)) {
		  TMarker tmpmVSlcTruth(SlcStripTruth->GetZPos(),  SlcStripTruth->GetTPos(), 20);	
		  tmpmVSlcTruth.SetMarkerColor(3);
		  tmpmVSlcTruth.SetMarkerSize(0.8);
		  fThisSliceVZTruth.push_back(tmpmVSlcTruth);
		}
		  
		  
		// Highlight true track and true showers, etc.
		if ( (mytruth->IsDigitFromParticle(13,*SlcDigitTruth)
		      || mytruth->IsDigitFromParticle(-13,*SlcDigitTruth))
		     
		     && mytruth->DigitIsOnlyCrosstalk(SlcDigitTruth)==0 )
		  {
		    // count number of true muon hit strips
		    numTrueMuonDigits++;
		    
		    // For U type planes
		    if(int(SlcStripTruth->GetPlaneView())==2) {
		      TMarker tmpmUTrkTruth(SlcStripTruth->GetZPos(),  SlcStripTruth->GetTPos(), 30);	
		      tmpmUTrkTruth.SetMarkerColor(2);
		      fThisTrackUZTruth.push_back(tmpmUTrkTruth);
		    }
		    
		    // For V type planes
		    else if(int(SlcStripTruth->GetPlaneView())==3) {
		      TMarker tmpmVTrkTruth(SlcStripTruth->GetZPos(),  SlcStripTruth->GetTPos(), 30);	
		      tmpmVTrkTruth.SetMarkerColor(2);
		      fThisTrackVZTruth.push_back(tmpmVTrkTruth);
		    }	  
		    
		    if(SlcStripTruth->GetPlane() > fTrueMaxPlane) {fTrueMaxPlane=SlcStripTruth->GetPlane();}
		    if(SlcStripTruth->GetPlane() < fTrueMinPlane) {fTrueMinPlane=SlcStripTruth->GetPlane();}
		  }
	      }
	    digitrTruth.Reset();

	    if(numTrueMuonDigits>0) {numTrueMuonStrips++;}
	    numTrueMuonDigits=0; // Reset counter
	    
	  }
	SlcStripItrTruth.Reset();
	
	if(debug) {
	  cout << "Total no. of hit strips: " << numSliceStrips << endl;
	  cout << "No. of true muon hit strips: " << numTrueMuonStrips << endl;}
	

	// Fill Tree - even if multiple tracks
	////////////////////
	TotalStripsInSnarl=numSliceStrips;
	TrueMuonStrips=numTrueMuonStrips;
	if(TrueMuonStrips!=0) {TrueTrackLength=fTrueMaxPlane-fTrueMinPlane;}
	else {TrueTrackLength=0;}
	////////////////////

	if(debug) {cout << "True track length: " << TrueTrackLength << endl;}


	fUZSliceMarkerTruth.push_back(fThisSliceUZTruth);
	fVZSliceMarkerTruth.push_back(fThisSliceVZTruth);

	fUZTrackMarkerTruth.push_back(fThisTrackUZTruth);
	fVZTrackMarkerTruth.push_back(fThisTrackVZTruth);
      }
  }
}
////////////////////////////////////////////////////////////////////////


 
////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::EfficiencySection(Truthifier* mytruth)
{
  int numFitTrkStrips=0;
  int numTrueMuonDigits=0;
  int numFitTrkTruthAgree=0;
    
  // Get CandFitTrackListHandle
  CandFitTrackListHandle* fit_track_list = dynamic_cast<CandFitTrackListHandle*>(candrec->FindCandHandle("CandFitTrackListHandle",
													 fListInFitTrk.Data()));
  if(!fit_track_list) {
    MSG("FitTrack", Msg::kWarning) << " Failed to Find " << fListInFitTrk.Data() << endl;
    FitTrackStrips=0;
    FitAndTruthAgree=0;
  }
  
  else {
    assert(fit_track_list);
    if(fit_track_list->GetNDaughters()<1) {MSG("FitTrack", Msg::kWarning) << "FitTracklist was empty... " << endl; }
      
    // loop over the fittedtracks
    TIter FitTrkItr = fit_track_list->GetDaughterIterator();
    while(CandFitTrackHandle* FitTrk = dynamic_cast<CandFitTrackHandle*>(FitTrkItr()))
      {

	TIter FitTrkStripItr = FitTrk->GetDaughterIterator();
	while(CandStripHandle* FitTrkStrip = dynamic_cast<CandStripHandle*>(FitTrkStripItr()))
	  {
	    numFitTrkStrips++;
	      
	    TIter digitrFitTrkXTalk = FitTrkStrip->GetDaughterIterator();
	    while(CandDeMuxDigitHandle* FitTrkDigit = dynamic_cast<CandDeMuxDigitHandle*>(digitrFitTrkXTalk())) 
	      {
		if ( ( mytruth->IsDigitFromParticle(13,*FitTrkDigit)
		       || mytruth->IsDigitFromParticle(-13,*FitTrkDigit) )
		       
		     && mytruth->DigitIsOnlyCrosstalk(FitTrkDigit)==0 )
		  {
		    // count number of true muon hit strips
		    numTrueMuonDigits++;
		  }
	      }
	    digitrFitTrkXTalk.Reset();
	      
	    if(numTrueMuonDigits>0) {numFitTrkTruthAgree++;}
	    numTrueMuonDigits=0;
	      
	  }
	FitTrkStripItr.Reset();
	  
	if(debug) {
	  cout << "No. of fit track hit strips: " << numFitTrkStrips << endl;
	  cout << "No. of fit track hits that agree with true muon hits: " << numFitTrkTruthAgree << endl;}


	//Fill tree
	///////////////////////////////
	if(fit_track_list->GetNDaughters()==1) {
	  FitTrackStrips=numFitTrkStrips;
	  FitAndTruthAgree=numFitTrkTruthAgree;
	}
	else {
	  FitTrackStrips=-999;
	  FitAndTruthAgree=-999;
	}
	///////////////////////////////

      }
    FitTrkItr.Reset();
  }
}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::Draw()
{
  // Plot slices
  ///////////////////////////////////
  if(fUZSliceMarker.size() > 0) {
    fUZPad->cd();
    fUZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fUZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fUZSliceMarker.size(); ++j) {
      if (fUZSliceMarker[j].size() > 0) {
	for(unsigned int i=0; i<fUZSliceMarker[j].size(); ++i) {  
	  fUZSliceMarker[j][i].Draw();
	}
      }
    }  
  }

  if(fVZSliceMarker.size() > 0) {
    fVZPad->cd();
    fVZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fVZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fVZSliceMarker.size(); ++j) {
      if (fVZSliceMarker[j].size() > 0) {
	for(unsigned int i=0; i<fVZSliceMarker[j].size(); ++i) {
	  fVZSliceMarker[j][i].Draw();
	}
      }
    }
  }
  ///////////////////////////////////


  // Plot showers
  ///////////////////////////////////
  if (fUZShowerMarker.size() > 0) {  // Check to see if there are showers
    fUZPad->cd();
    fUZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fUZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fUZShowerMarker.size(); ++j) {
      if (fUZShowerMarker[j].size() > 0) {
	for(unsigned int i=0; i<fUZShowerMarker[j].size(); ++i) {  
	  fUZShowerMarker[j][i].Draw();
	}
      }
    }  
  }

  if (fVZShowerMarker.size() > 0) { 
    fVZPad->cd();
    fVZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fVZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fVZShowerMarker.size(); ++j) {
      if (fVZShowerMarker[j].size() > 0) {
	for(unsigned int i=0; i<fVZShowerMarker[j].size(); ++i) {
	  fVZShowerMarker[j][i].Draw();
	}
      }
    }
  }
  /////////////////////////////////// 


  // Plot simple tracks
  ///////////////////////////////////
  if (fUZTrackMarker.size() > 0) {  // Check to see if there are tracks
    fUZPad->cd();
    fUZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fUZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fUZTrackMarker.size(); ++j) {
      if (fUZTrackMarker[j].size() > 0) {
	for(unsigned int i=0; i<fUZTrackMarker[j].size(); ++i) {  
	  fUZTrackMarker[j][i].Draw();
	}
      }
    }
  }
 
  if (fVZTrackMarker.size() > 0) {  
    fVZPad->cd();
    fVZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fVZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fVZTrackMarker.size(); ++j) {
      if (fVZTrackMarker[j].size() > 0) {
	for(unsigned int i=0; i<fVZTrackMarker[j].size(); ++i) {  
	  fVZTrackMarker[j][i].Draw();
	}
      }
    }
  }
  /////////////////////////////////// 



  // Plot fitted tracks
  ///////////////////////////////////
  if (fUZFitTrackMarker.size() > 0) {  // Check to see if there are fitted tracks
    fUZPad->cd();
    fUZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fUZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fUZFitTrackMarker.size(); ++j) {
      if (fUZFitTrackMarker[j].size() > 0) {
	for(unsigned int i=0; i<fUZFitTrackMarker[j].size(); ++i) {  
	  fUZFitTrackMarker[j][i].Draw();
	}
      }
    }
  }

  if (fVZFitTrackMarker.size() > 0) {
    fVZPad->cd();
    fVZAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
    fVZAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
    for(unsigned int j=0; j<fVZFitTrackMarker.size(); ++j) {
      if (fVZFitTrackMarker[j].size() > 0) {
	for(unsigned int i=0; i<fVZFitTrackMarker[j].size(); ++i) {  
	  fVZFitTrackMarker[j][i].Draw();
	}
      }
    }
  }
  ///////////////////////////////////


  // Truth section plot
  ///////////////////////////////////
  if (isMC==1) {
    
    // All slice
    if(fUZSliceMarkerTruth.size() > 0) {
      fUZMCPad->cd();
      fUZMCAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
      fUZMCAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
      for(unsigned int j=0; j<fUZSliceMarkerTruth.size(); ++j) {
	if (fUZSliceMarkerTruth[j].size() > 0) {
	  for(unsigned int i=0; i<fUZSliceMarkerTruth[j].size(); ++i) {  
	    fUZSliceMarkerTruth[j][i].Draw();
	  }
	}
      }  
    }
    
    if(fVZSliceMarkerTruth.size() > 0) {
      fVZMCPad->cd();
      fVZMCAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
      fVZMCAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
      for(unsigned int j=0; j<fVZSliceMarkerTruth.size(); ++j) {
	if (fVZSliceMarkerTruth[j].size() > 0) {
	  for(unsigned int i=0; i<fVZSliceMarkerTruth[j].size(); ++i) {
	    fVZSliceMarkerTruth[j][i].Draw();
	  }
	}
      }
    }

    // True tracks... muon hits, etc
    if(fUZTrackMarkerTruth.size() > 0) {
      fUZMCPad->cd();
      fUZMCAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
      fUZMCAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
      for(unsigned int j=0; j<fUZTrackMarkerTruth.size(); ++j) {
	if (fUZTrackMarkerTruth[j].size() > 0) {
	  for(unsigned int i=0; i<fUZTrackMarkerTruth[j].size(); ++i) {  
	    fUZTrackMarkerTruth[j][i].Draw();
	  }
	}
      }  
    }
    
    if(fVZTrackMarkerTruth.size() > 0) {
      fVZMCPad->cd();
      fVZMCAxis->GetXaxis()->SetRangeUser(fMinZ-0.1, fMaxZ+0.1);
      fVZMCAxis->GetYaxis()->SetRangeUser(fMinUorV-0.4, fMaxUorV+0.4);
      for(unsigned int j=0; j<fVZTrackMarkerTruth.size(); ++j) {
	if (fVZTrackMarkerTruth[j].size() > 0) {
	  for(unsigned int i=0; i<fVZTrackMarkerTruth[j].size(); ++i) {
	    fVZTrackMarkerTruth[j][i].Draw();
	  }
	}
      }
    }
    
  }
  ///////////////////////////////////

  fTrackCanvas->cd();
  fTrackCanvas->Update();
}
////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::Pause()
{
  cout << "Press return to continue" << endl;

  int key = 0;
  while(1){
    gSystem->ProcessEvents();
    fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
    key = getchar();
    if(key=='\n') break;
    usleep(1000);
  }
}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::CleanUp()
{
  fUZSliceMarker.clear();
  fVZSliceMarker.clear();

  fUZShowerMarker.clear();
  fVZShowerMarker.clear();

  fUZTrackMarker.clear();
  fVZTrackMarker.clear();

  fUZFitTrackMarker.clear();
  fVZFitTrackMarker.clear();

  fUZSliceMarkerTruth.clear();
  fVZSliceMarkerTruth.clear();

  fUZTrackMarkerTruth.clear();
  fVZTrackMarkerTruth.clear();
}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
const Registry& FitTrackCamAnalysisModule::DefaultConfig() const
{
  //======================================================================
  // Supply the default configuration for the module
  //======================================================================
  static Registry r; // Default configuration for module

  // Set name of config
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());

  // Set values in configuration
  r.UnLockValues();
  r.Set("NameSlcListIn","CandSliceList");
  r.Set("NameShwListIn","CandShowerList");
  r.Set("NameTrkListIn","CandTrackSRList");
  r.Set("NameFitTrkListIn","CandFitTrackCamList");
  r.Set("NameFileOut","FitTrackCamAna.root");
  r.LockValues();

  return r;
}
////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////
void FitTrackCamAnalysisModule::Config(const Registry& r)
{
  //======================================================================
  // Configure the module given the Registry r
  //======================================================================
  const char* tmps;
  if (r.Get("NameSlcListIn",tmps)) { fListInSlc = tmps; }
  if (r.Get("NameShwListIn",tmps)) { fListInShw = tmps; }
  if (r.Get("NameTrkListIn",tmps)) { fListInTrk = tmps; }
  if (r.Get("NameFitTrkListIn",tmps)) { fListInFitTrk = tmps; }
  if (r.Get("NameFileOut",tmps)) { fFileName = tmps; }
}
////////////////////////////////////////////////////////////////////////