CDAnalysis.cxx

Go to the documentation of this file.

// Program name: CDAnalysis.cxx
//                                                                     
// Package: CalDetTracker   
//                                                                    
// Coded by Jeff Hartnell Jul/2003 onwards
//                                                                    
// Purpose: To make plots and analyse the Tracker*.root files
//                                                                    
// Contact: jeffrey.hartnell@physics.ox.ac.uk                         

#include <fstream>
#include <cmath>
#include <cassert>

#include "TCanvas.h"
#include "TChain.h"
#include "TError.h"
#include "TFile.h"
#include "TF1.h"
#include "TGraphErrors.h"
#include "TH2F.h"
#include "TLegend.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TStyle.h"
#include "TTree.h"
#include "TVector3.h"
#include "TClonesArray.h"

#include "CalDetPID/CalDetParticleType.h"
#include "Calibrator/Calibrator.h"
#include "Digitization/DigiSignal.h"
#include "MessageService/MsgService.h"
#include "MuELoss/MuEnergyLoss.h"
#include "Conventions/Munits.h"
#include "Conventions/StripEnd.h"
#include "Validity/VldContext.h"

#include "CalDetTracker/CDAnalysis.h"
#include "CalDetTracker/CDSimpleMC.h"
#include "CalDetTracker/CDTruthHitInfo.h"
#include "CalDetTracker/CDPIDInfo.h"
#include "CalDetTracker/CDTrackedHitInfo.h"
#include "CalDetTracker/CDTrackInfo.h"
#include "CalDetTracker/CDTrackerOptions.h"
#include "CalDetTracker/CDXTalkHitInfo.h"

using std::endl;
using std::cout;
using std::map;
using std::vector;

string CDAnalysis::fInputFileName="";

ClassImp(CDAnalysis)

CVSID("$Id: CDAnalysis.cxx,v 1.74 2007/07/03 16:01:27 hartnell Exp $");

//......................................................................

CDAnalysis::CDAnalysis()
{
  MSG("CDAnalysis",Msg::kInfo)
      <<"Running CDAnalysis Constructor..."<<endl;

  //initialise variables
  fOutFile=0;//initialise output file pointer
  fTrackerTree=0;
  fOptTree=0;
  fTrkOpt=0;//tracking options
  fPIDInfo=0;
  fTrackInfo=0;
  fTrkHitInfo=0;
  fUnTrkHitInfo=0;
  fXTalkHits=0;
  fTruthHitInfo=0;
  
  fSnarl=-1;
  fSec=-1;
  fNumDeadChips=-1;
  fTemperature=-1;
  fBeamMomentum=0;
  fSimFlag=SimFlag::kUnknown;
  fRunNumber=0;
  fSubRun=0;
  fStartSnarl=0;
  fEndSnarl=0;
  fStartTime=0;
  fEndTime=0;
  fMainParticleEnergy=0;
  fEvents=-1;

  this->InitialiseLoopVariables();
  this->InitialiseHitInfoVariables();
  this->InitialisePidVariables();

  //set a default value of 1 so it stays as sigcor
  fSigCorsPerMip=1;
  fSigCorPerMEU=1;
  fScEnDepPerMEU=1;
  fRatioScEnToBeamEn=1;
  
  fMeuVsEvLenCutM=0;
  fSigCorVsDistM=0;
  fPeakLastPlane=0;
  fPeakPlaneSigCors=0;
  fMyPiMuCounter=0;
  fPidPiMuCounter=0;
  fMyElecCounter=0;
  fPidElecCounter=0;
  fBothPiMuCounter=0;
  fBothElecCounter=0;
  fAvTemperature=0;

  fS="";//general purpose string
  fDoReCalibration=false;//don't do recalibration by default

  //all data members are initialised by this point...

  this->MakeChain();
  this->SetRootFileObjects();

  //get the main particle energy
  fMainParticleEnergy=this->GetGreatestMainParticleEnergy();
  if (fMainParticleEnergy>0){
    MSG("CDAnalysis",Msg::kInfo)
      <<"Found main energy="<<fMainParticleEnergy<<endl;
    MSG("CDAnalysis",Msg::kInfo)
      <<"Beam Momentum from file="<<fBeamMomentum<<endl;
  }

  //setup some root stuff
  //include the under and overflow counts
  gStyle->SetOptStat(1111111);
  gStyle->SetOptFit(1111);
  gStyle->SetPalette(1,(Int_t*)0);

  //do these last in the constructor
  //set the values appropriately if possible
  this->SetSigCorPerMEU();
  this->SetScEnDepPerMEU();
  this->SetRatioScEnToBeamEn();

  MSG("CDAnalysis",Msg::kInfo)
      <<"Finished CDAnalysis Constructor"<<endl;
}

//......................................................................

CDAnalysis::~CDAnalysis()
{
  MSG("CDAnalysis",Msg::kDebug)
      <<"Running CDAnalysis Destructor..."<<endl;
  
  if (fOutFile){
    fOutFile->Close();
  }

  MSG("CDAnalysis",Msg::kDebug)
      <<"Finished CDAnalysis Destructor"<<endl;
}

//......................................................................

void CDAnalysis::InitialiseLoopVariables()
{
  MSG("CDAnalysis",Msg::kDebug)<<"Initialising loop variables..."<<endl;

  fFirstPlane=69;
  fLastPlane=-1;
  fLastPlaneOdd=-1;
  fLastPlaneEven=-1;

  fNumPlanesHitAll.clear();
  fNumPlanesHit25.clear();
  fNumPlanesHitTrk.clear();
  fNumPlanesHitPeCut.clear();
  fNumPlanesHitPeCut10.clear();

  fNumHitsPerPlane=-1;
  fNumHitsPerPlane25=-1;
  fNumHitsPerPlanePeCut10=-1;
  fStripsFromCentrePeCut=-1;

  //variables to calc av strip for ps muon cut
  fAvStrip=-1;
  fStCount=0;
  fAvStrip1=-1;
  fStCount1=0;
  fAvStrip2=-1;
  fStCount2=0;

  fLowScint_Tof=1e9;
  fUpScint_Tof=-1e9;

  MSG("CDAnalysis",Msg::kDebug)<<"Initialisation complete"<<endl;
}

//......................................................................

void CDAnalysis::InitialisePidVariables()
{
  //these are the SI variables
  fTriggerPMT=-1;
  fFafErr=-1;
  fSparseErr=-1;
  fTrigSource=-1;

  fKovADC1=-1;
  fKovTimeStamp1=-1;
  fKovADC2=-1;
  fKovTimeStamp2=-1;
  fKovADC3=-1;
  fKovTimeStamp3=-1;

  fSnarlTimeFrame=-1;
  fSnarlMinTimeStamp=0;
  fSnarlMaxTimeStamp=0;

  fTofTDC0=-1;
  fTofTDC1=-1;
  fTofTDC2=-1;
  fTofADC0=-1;
  fTofADC1=-1;
  fTofADC2=-1;
  fTofADCTimeStamp0=-1;
  fTofADCTimeStamp1=-1;
  fTofADCTimeStamp2=-1;
  fTofTimeStamp=-1;//don't use this, use fTofADCTimeStamp1==TTAG

  fTickSinceLast=-1;

  //these are the PID variables
  fNoOverlap=kFALSE;
  fInCERTime=kFALSE;
  fPIDType=0;
  fNoOverlapBits=0; 
  fInCERTimeBits=0; 
  fOLChi2=0;
}

//......................................................................

void CDAnalysis::InitialiseHitInfoVariables()
{
  fTime=0;

  fPlane=-1;
  fResultOdd=-1;
  fResultEven=-1;
  fStrip=-1;
  fStripend=-1;
  fTransPos=-1;

  fO1=false;
  fO2=false;
  fE1=false;
  fE2=false;

  fChargeAdc=-1;
  fChargeMip=-1;
  fChargeSigCor=-1;
  fChargeSigLin=-1;
  fChargePe=-1;
  fGain=-1;
}

//......................................................................

void CDAnalysis::WriteOutHistos() const
{
  //write out the histos to the file, if it's open
  if (fOutFile){
    if (fOutFile->IsWritable()){
      fOutFile->cd();

      //create a tree and set branches      
      TTree runInfo("runInfo","runInfo");
      //have to create local variables here
      //I think it's something to do with the fact that they are
      //read in on other trees in this class as well???
      //No, actually not because fSigCorsPerMip is not in a tree
      //don't understand this crazyness!
      Int_t lSimFlag=fSimFlag;
      runInfo.Branch("SimFlag",&lSimFlag,"SimFlag/I");
      Float_t lBeamMomentum=fBeamMomentum;
      runInfo.Branch("BeamMomentum",&lBeamMomentum,"BeamMomentum/F");
      Int_t lRunNumber=fRunNumber;
      runInfo.Branch("RunNumber",&lRunNumber,"RunNumber/I");
      Int_t lSubRun=fSubRun;
      runInfo.Branch("SubRun",&lSubRun,"SubRun/I");
      Int_t lRunPeriod=this->RunNumber2RunPeriod(fRunNumber);
      runInfo.Branch("RunPeriod",&lRunPeriod,"RunPeriod/I");
      Int_t lStartTime=fStartTime;
      runInfo.Branch("StartTime",&lStartTime,"StartTime/I");
      Int_t lEndTime=fEndTime;
      runInfo.Branch("EndTime",&lEndTime,"EndTime/I");
      Int_t lStartSnarl=fStartSnarl;
      runInfo.Branch("StartSnarl",&lStartSnarl,"StartSnarl/I");
      Int_t lEndSnarl=fEndSnarl;
      runInfo.Branch("EndSnarl",&lEndSnarl,"EndSnarl/I");
      Float_t lAvTemperature=fAvTemperature;
      runInfo.Branch("AvTemperature",&lAvTemperature,"AvTemperature/F");

      Float_t lSigCorsPerMip=fSigCorsPerMip;
      runInfo.Branch("SigCorsPerMip",&lSigCorsPerMip,"SigCorsPerMip/F");
      Float_t lScEnDepPerMEU=fScEnDepPerMEU;
      runInfo.Branch("ScEnDepPerMEU",&lScEnDepPerMEU,"ScEnDepPerMEU/F");
      Float_t lRatioScEnToBeamEn=fRatioScEnToBeamEn;
      runInfo.Branch("RatioScEnToBeamEn",&lRatioScEnToBeamEn,
                     "RatioScEnToBeamEn/F");
      Float_t lPeakLastPlane=fPeakLastPlane;
      runInfo.Branch("PeakLastPlane",&lPeakLastPlane,
                     "PeakLastPlane/F");
      Float_t lPeakPlaneSigCors=fPeakPlaneSigCors;
      runInfo.Branch("PeakPlaneSigCors",&lPeakPlaneSigCors,
                     "PeakPlaneSigCors/F");
      Float_t lSigCorVsDistM=fSigCorVsDistM;
      runInfo.Branch("SigCorVsDistM",&lSigCorVsDistM,
                     "SigCorVsDistM/F");
      Float_t lMeuVsEvLenCutM=fMeuVsEvLenCutM;
      runInfo.Branch("MeuVsEvLenCutM",&lMeuVsEvLenCutM,
                     "MeuVsEvLenCutM/F");
      Int_t lEvLenCutMin=-1;
      Int_t lEvLenCutMax=-1;
      this->GetEvLenMinMax(lEvLenCutMin,lEvLenCutMax);
      runInfo.Branch("EvLenCutMin",&lEvLenCutMin,"EvLenCutMin/I");
      runInfo.Branch("EvLenCutMax",&lEvLenCutMax,"EvLenCutMax/I");

      //pid counters
      Int_t lMyPiMuCounter=fMyPiMuCounter;
      runInfo.Branch("MyPiMuCounter",&lMyPiMuCounter,"MyPiMuCounter/I");
      Int_t lPidPiMuCounter=fPidPiMuCounter;
      runInfo.Branch("PidPiMuCounter",&lPidPiMuCounter,
                     "PidPiMuCounter/I");
      Int_t lMyElecCounter=fMyElecCounter;
      runInfo.Branch("MyElecCounter",&lMyElecCounter,"MyElecCounter/I");
      Int_t lPidElecCounter=fPidElecCounter;
      runInfo.Branch("PidElecCounter",&lPidElecCounter,
                     "PidElecCounter/I");
      Int_t lBothPiMuCounter=fBothPiMuCounter;
      runInfo.Branch("BothPiMuCounter",&lBothPiMuCounter,
                     "BothPiMuCounter/I");
      Int_t lBothElecCounter=fBothElecCounter;
      runInfo.Branch("BothElecCounter",&lBothElecCounter,
                     "BothElecCounter/I");

      //fill and write      
      runInfo.Fill();
      runInfo.Write();

      MSG("CDAnalysis",Msg::kInfo)
        <<"Writing histos to: "<<fOutFile->GetName()<<" ..."<<endl;
      fOutFile->Write();
      //fOutFile->Close();//this makes histos disappear from
      //the canvases for some strange reason!
    }
    else {
      MSG("CDAnalysis",Msg::kWarning)
        <<"File not writable!"<<endl;
    }
  }
}

//......................................................................

void CDAnalysis::InputFileName(string f)
{
  MSG("CDAnalysis",Msg::kInfo)
    <<"Running with input file name="<<f<<endl;
  fInputFileName=f;
}

//......................................................................

vector<string> CDAnalysis::MakeFileList()
{

  vector<string> fileList;
  
  if (fInputFileName!=""){
    ifstream inputFile(fInputFileName.c_str());

    //check if file exists
    if (inputFile){
      //variables to hold input from file
      string file="";
   
      //read in from the text file and fill objects
      while(inputFile>>file) {
        MSG("CDAnalysis",Msg::kDebug)
          <<"Found input file name="<<file<<endl;
        fileList.push_back(file);
      }
      MSG("CDAnalysis",Msg::kDebug)
        <<"Files names found in txt file="<<fileList.size()<<endl;
    }
    else{
      MSG("CDAnalysis",Msg::kFatal)
        <<endl<<endl
        <<"***********************************************************"
        <<endl<<"Input txt file of file names does not exist!"<<endl
        <<"InputFileName="<<fInputFileName<<endl
        <<"***********************************************************"
        <<endl<<endl<<"Program will exit here"<<endl;
      exit(0);
    }
  }
  //return the fileList if files were found
  if (fileList.size()>0) return fileList;
  
  //Check the env variable to find files
  char* envVariable=getenv("CDDATA");
  if (envVariable==NULL){
    MSG("CDAnalysis",Msg::kFatal)
      <<endl<<endl
      <<"*************************************************************"
      <<endl<<"Environmental variable CDDATA not set!"<<endl
      <<"Please set CDDATA to the directory containing the"
      <<" Tracker*.root files"<<endl
      <<"Note: If more than one file is found they will be"
      <<" concatenated and treated as one"<<endl
      <<"*************************************************************"
      <<endl<<endl<<"Program will exit here"<<endl;
    exit(0);
  }
  string sEnv=envVariable;
  MSG("CDAnalysis",Msg::kInfo)
    <<"Looking for Tracker*.root files using the env variable"<<endl
    <<"CDDATA="<<sEnv<<endl;
  sEnv+="/Tracker*.root";
  fileList.push_back(sEnv);

  return fileList;
}

//......................................................................

void CDAnalysis::MakeChain()
{
  //get the files to open
  vector<string> fileList=this->MakeFileList();

  //create a chain with TrackerTree
  fTrackerTree=new TChain("TrackerTree");
  fOptTree=new TChain("TrackerOptions");

  Int_t nf=0;
  //add the files to the chain
  for (vector<string>::iterator file=fileList.begin();
       file!=fileList.end();++file){
    
    //test if file already exists
    ifstream openOk((*file).c_str()); 

    //check if a wildcard was used because ifstream can't open wildcards
    Int_t stars=(*file).find("*");
    Int_t quest=(*file).find("?");

    //check if file existed
    if (!openOk && !(quest>=0 || stars>=0)){
      MSG("CDAnalysis",Msg::kInfo)
        <<endl<<endl
        <<"***********************************************************"
        <<endl<<"Can't find file="<<*file<<endl
        <<"Note: you can't use '~/'. It has to be the full path"<<endl
        <<"***********************************************************"
        <<endl<<endl
        <<"Exiting here!"<<endl;
      exit(0);
    }
    
    MSG("CDAnalysis",Msg::kInfo)<<"Adding file="<<*file<<endl;
    nf+=fTrackerTree->Add((*file).c_str());
    fOptTree->Add((*file).c_str());
  }

  if(nf==0){
    MSG("CDAnalysis",Msg::kFatal)
      <<endl<<endl
      <<"*************************************************************"
      <<endl<<"No Tracker*.root files found"<<endl
      <<"Please set CDDATA to the directory containing the"
      <<" Tracker*.root files"<<endl
      <<"Or give the txt file containing the files to be input"<<endl
      <<"Note: If more than one file is found they will be"
      <<" concatenated in a TChain and treated as one"<<endl
      <<"*************************************************************"
      <<endl<<endl<<"Program will exit here"<<endl;
    exit(0);
  }
    
  MSG("CDAnalysis",Msg::kInfo) 
    <<"Tracker Tree information:"<<endl;
  fTrackerTree->Show(0);
  MSG("CDAnalysis",Msg::kInfo) 
    <<"Options Tree information:"<<endl;
  fOptTree->Show(0);
  //fTrackerTree->Print()
  
  MSG("CDAnalysis",Msg::kInfo)
    <<endl<<"Analysing "<<nf<<" file(s). Reading from disk..."<<endl;
}

//......................................................................

void CDAnalysis::SetRootFileObjects()
{
  MSG("CDAnalysis",Msg::kDebug)
    <<"Running the SetRootFileObjects method..."<<endl;

  //tracker options tree
  fOptTree->SetBranchAddress("SimFlag",&fSimFlag);
  fOptTree->SetBranchAddress("Run",&fRunNumber);
  fOptTree->SetBranchAddress("SubRun",&fSubRun);
  fOptTree->SetBranchAddress("TrackerOptions",fTrkOpt);
  fOptTree->SetBranchAddress("StartTime",&fStartTime);
  fOptTree->SetBranchAddress("EndTime",&fEndTime);
  fOptTree->SetBranchAddress("StartSnarl",&fStartSnarl);
  fOptTree->SetBranchAddress("EndSnarl",&fEndSnarl);
  fOptTree->SetBranchAddress("BeamMomentum",&fBeamMomentum);

  //set the number of events in the tree
  Int_t events=static_cast<Int_t>(fOptTree->GetEntries());
  MSG("CDAnalysis",Msg::kDebug)
    <<"OptTree has "<<events<<" events"<<endl;
  if (events>0){
    //get the snarl/event
    fOptTree->GetEvent(0); 
    MSG("CDAnalysis",Msg::kInfo)
      <<"File has run="<<fRunNumber<<", subrun="<<fSubRun
      <<", SimFlag="<<SimFlag::AsString(fSimFlag)
      <<", beam momentum="<<fBeamMomentum<<endl
      <<"Time="<<fStartTime<<"->"<<fEndTime
      <<", snarl="<<fStartSnarl<<"->"<<fEndSnarl<<endl; 
  }

  //set the branch to point at the track info object and pid
  fTrackerTree->SetBranchAddress("TrackInfo",&fTrackInfo);
  fTrackerTree->SetBranchAddress("Snarl",&fSnarl);
  fTrackerTree->SetBranchAddress("NumDeadChips",&fNumDeadChips);
  fTrackerTree->SetBranchAddress("Sec",&fSec);
  fTrackerTree->SetBranchAddress("Temperature",&fTemperature);

  //check and set pid info branch
  if (fTrackerTree->GetBranchStatus("PIDInfo")){
    fTrackerTree->SetBranchAddress("PIDInfo",&fPIDInfo);
  }
  else{
    MSG("CDAnalysis",Msg::kInfo)
      <<"PIDInfo branch does not exist, not setting tree address"<<endl;
  }

  //create the TClonesArrays
  fTrkHitInfo=new TClonesArray("CDTrackedHitInfo",1000);
  fUnTrkHitInfo=new TClonesArray("CDTrackedHitInfo",1000);
  fXTalkHits=new TClonesArray("CDXTalkHitInfo",1000);

  //set the branches to point to the tclonesarrays
  fTrackerTree->SetBranchAddress("StraightTrackedHitInfo",
                                 &fTrkHitInfo);
  fTrackerTree->SetBranchAddress("UnTrackedHitInfo",
                                 &fUnTrkHitInfo);
  fTrackerTree->SetBranchAddress("XTalkHitInfo",&fXTalkHits);

  //check and set truth hit info branch
  if (fTrackerTree->GetBranchStatus("TruthHitInfo")){
    fTruthHitInfo=new TClonesArray("CDTruthHitInfo",1000);
    fTrackerTree->SetBranchAddress("TruthHitInfo",&fTruthHitInfo);
  }
  else{
    MSG("CDAnalysis",Msg::kInfo)
      <<"TruthHitInfo branch does not exist"
      <<", not setting tree address"<<endl;
  }

  //set the number of events in the tree
  fEvents=static_cast<Int_t>(fTrackerTree->GetEntries());

  //get the first snarl/event
  if (fTrackerTree) fTrackerTree->GetEvent(0); 
  MSG("CDAnalysis",Msg::kInfo)
    <<"First snarl="<<fSnarl<<" (sec="<<fSec<<")"<<endl;

  //this is a really ugly, ugly, ugly place to do this...
  Calibrator& cal=Calibrator::Instance();  
  if (fRunNumber>=70000 && fRunNumber<80000){
    cout<<"Setting DriftCalibrator=PulserDriftCalScheme"<<endl;
    cal.Set("DriftCalibrator=PulserDriftCalScheme");
    cal.GetDriftCalibrator().Set("VATemperatureCalibration=on");
    cal.PrintConfig(cout);
  }
  else{//no tables for 2002 for using PulserDriftCalScheme
    cout<<"Setting DriftCalibrator=PulserSigLinCalScheme"<<endl;
    cal.Set("DriftCalibrator=PulserSigLinCalScheme");
    cal.GetDriftCalibrator().Set("VATemperatureCalibration=on");
    cal.PrintConfig(cout);
  }

  MSG("CDAnalysis",Msg::kDebug)
      <<"Finished the SetRootFileObjects method"<<endl;
}
//......................................................................

Int_t CDAnalysis::RunNumber2RunPeriod(Int_t run) const
{
  //Key to Run Periods (as defined by CBS)
  //1   T11 2002 Near-Far        (30000s)
  //2   T11 2002 Far-Far         (40000s)
  //3   T11 2002 Far-Far   15deg (late 40000s)
  //4   T7  2002 Far-Far         (50000s)
  //5   T7  2003 Near-Far        (70000s)
  //6   T7  2003 Near Only 3m    (80000s)
  //7   T7  2003 Near Only 1m    (90000s)
  //8   T11 2003 Near Only norm  (100000s)
  //9   T11 2003 Near Only 45deg (101000s)
  //10  T11 2003 Near Only 30deg (late 101000s)
  //11  T11 2003 Near Only 15deg (102000s)

  Int_t runPeriod=0;
  if (run>=30000 && run<40000){
    runPeriod=1;
  }
  if (run>=40000 && run<50000){
    runPeriod=2;
  }
  else if (run>=50000 && run<60000){
    runPeriod=4;
  }
  else if (run>=60000 && run<70000){
    runPeriod=-1;//this is not defined
  }
  else if (run>=70000 && run<80000){
    runPeriod=5;
  }
  else if (run>=80000 && run<90000){
    runPeriod=6;
  }
  else if (run>=90000 && run<100000){
    runPeriod=7;
  }
  else if (run>=100000 && run<101000){
    runPeriod=8;
  }
  else if (run>=101000 && run<102000){
    runPeriod=9;//or 10, need run number
  }
  else if (run>=102000 && run<120000){
    runPeriod=11;
  }
  
  return runPeriod;
}

//......................................................................

void CDAnalysis::SetSigCorPerMEU()
{
  if (fSimFlag==SimFlag::kData){
    if (fRunNumber>70000 && fRunNumber<80000){
      fSigCorPerMEU=591.6;
    }
    else if (fRunNumber==100161){
      fSigCorPerMEU=377.2;
    }
    else{
      MSG("CDAnalysis",Msg::kWarning) 
        <<"no run number for sigcor per meu"<<endl;
    }
  }
  else if(fSimFlag==SimFlag::kMC){
    fSigCorPerMEU=667.104;
  }
  else{
    MSG("CDAnalysis",Msg::kWarning) 
      <<"SetSigCorPerMEU: SimFlag not set"<<endl;
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Using sigcor per MEU="<<fSigCorPerMEU<<endl;
}

//......................................................................

void CDAnalysis::SetScEnDepPerMEU()
{
  //using same selection of tracks as in data
  fScEnDepPerMEU=0.00195253*Munits::gigaelectronvolt;//new MK dEdx
  //fScEnDepPerMEU=0.00194761*Munits::gigaelectronvolt;//new MK dEdx
  //fScEnDepPerMEU=0.0296718*Munits::gigaelectronvolt;//orig number

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Using ScEnDep per MEU="<<fScEnDepPerMEU<<endl;
}

//......................................................................

void CDAnalysis::SetRatioScEnToBeamEn()
{
  //using same selection of tracks as in data
  fRatioScEnToBeamEn=0.056064;//with new MK dEdx
  //fRatioScEnToBeamEn=0.0559147;//with new MK dEdx
  //fRatioScEnToBeamEn=0.05638;//orig number
  
  MSG("CDAnalysis",Msg::kInfo) 
    <<"Using Ratio ScEn/BeamEn="<<fRatioScEnToBeamEn<<endl;
}

//......................................................................

TFile* CDAnalysis::OpenFile(Int_t runNumber,std::string prefix)
{
  //create the tfile pointer to be returned
  TFile* outputFile=0;
  
  //get the environmental variable
  char *anaDir=getenv("CDANA_DIR");
  
  //use a string to hold env instead 
  string sAnaDir="";
  
  if (anaDir!=NULL) {
    sAnaDir=anaDir;
  }
  else {
    MSG("CDAnalysis",Msg::kInfo) 
      <<"Environmental variable $CDANA_DIR not set." 
      <<" Writing file(s) to current directory"<<endl;
    sAnaDir=".";
  }
  
  //convert variables to string
  string sRunNumber=Form("%d",runNumber);
  string sDetector="C";
  string sPrefix="h";//default
  if (prefix!="") sPrefix+=prefix;
  //start all filenames with an h
  string sBase=sAnaDir+"/"+sPrefix+sDetector+sRunNumber;
  string sFileName=sBase+".root";
  
  //test if file already exists
  ifstream Test(sFileName.c_str());
  
  //open the appropriate file
  if(!Test){
    outputFile=new TFile(sFileName.c_str(),"RECREATE");
  }
  else {
    //Need new filename
    Int_t fred=1;
    while(Test) {
      Test.close();
      string sAppendage=Form("%d",fred);
      sFileName=sBase+"_"+sAppendage+".root";
      Test.open(sFileName.c_str());
      fred++;
    }
    outputFile=new TFile(sFileName.c_str(),"NEW");
    outputFile->SetCompressionLevel(9);
  }
  
  string sTmp="No File!";
  if (outputFile) sTmp=outputFile->GetName();

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Output file opened: "<<sTmp<<endl;
  return outputFile;
}

//......................................................................

ofstream* CDAnalysis::OpenTxtFile(Int_t runNumber,std::string prefix)
{
  //create the tfile pointer to be returned
  ofstream* outputFile=0;
  
  //convert variables to string
  string sRunNumber=Form("%d",runNumber);
  string sDetector="C";
  string sPrefix="";//default
  string sAnaDir=".";
  if (prefix!="") sPrefix+=prefix;
  string sBase=sAnaDir+"/"+sPrefix+sDetector+sRunNumber;
  string sFileName=sBase+".txt";

  outputFile=new ofstream(sFileName.c_str());
  
  if (outputFile){
    MSG("CDAnalysis",Msg::kInfo) 
      <<"Output txt file opened: "<<sFileName<<endl;
  }
  else{
    MSG("CDAnalysis",Msg::kInfo)
      <<"Txt file NOT opened: "<<sFileName<<endl;
  }

  return outputFile;
}

//......................................................................

TGraph* CDAnalysis::TGraphVect(const std::vector<Double_t>& vX,
                               const std::vector<Double_t>& vY) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running TGraphVect method... **"<<endl;

  TGraph* g=new TGraph(vX.size());

  for (UInt_t i=0;i<vX.size();i++){
    g->SetPoint(i,vX[i],vY[i]);
  }

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished TGraphVect method **"<<endl;
  return g;
}
//......................................................................

void CDAnalysis::TGraphMinMax(vector<TGraph*>& v) const
{
  Float_t max=-1e200;
  Float_t min=+1e200;

  for (vector<TGraph*>::iterator vIt=v.begin();vIt!=v.end();++vIt){
    for (Int_t i=0;i<(*vIt)->GetN();i++){
      Double_t x=0;
      Double_t y=0;
      (*vIt)->GetPoint(i,x,y);

      //find the min and max
      if (y>max) max=y;
      if (y<min) min=y;
    }
  }

  MSG("CDAnalysis",Msg::kDebug)
    <<"Found min="<<min<<", max="<<max<<endl;

  //now set the min and max for 10% above and below size of range
  for (vector<TGraph*>::iterator vIt=v.begin();vIt!=v.end();++vIt){
    (*vIt)->SetMinimum(min-0.1*(max-min));
    (*vIt)->SetMaximum(max+0.1*(max-min));
  }
}

//......................................................................

TGraph* CDAnalysis::TGraphMap(const std::map<Int_t,Float_t>& m) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running TGraphMap method... **"<<endl;

  TGraph* g=new TGraph(m.size());

  map<Int_t,Float_t>::const_iterator mIter=m.begin();

  Int_t i=0;

  while (mIter!=m.end()){
    g->SetPoint(i,mIter->first,mIter->second);

    i++;
    mIter++;
  }

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished TGraphMap method **"<<endl;
  return g;
}

//......................................................................

Int_t CDAnalysis::SumMapValues(const std::map<Int_t,Int_t>& mapIn) const
{
  Int_t sum=0;
  
  //loop and sum the values stored in the map
  for (map<Int_t,Int_t>::const_iterator it=mapIn.begin();
       it!=mapIn.end();++it){
    sum+=it->second;
  }
  
  return sum;
}

//......................................................................

void CDAnalysis::NormaliseVector(std::vector<Double_t>& v,
                                 Int_t mode) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running NormaliseVector method... **"<<endl;
  
  if (v.size()>0){

    if (mode==1){//simple average
      //find average
      Double_t average=0;
      for (UInt_t i=0;i<v.size();i++) average+=v[i];
      average/=v.size();
      
      MSG("CDAnalysis",Msg::kVerbose)<<"Average="<<average<<endl; 
      
      //normalise
      for (UInt_t i=0;i<v.size();i++) v[i]/=average;
    }
    else if (mode==2){//fit the function to remove effect of outliers
      
      Double_t vMax=-9e50;
      Double_t vMin=9e50;

      //work out mins and maxs
      for (UInt_t i=0;i<v.size();i++){
        if (v[i]>vMax) vMax=v[i];
        if (v[i]<vMin) vMin=v[i];
      }
      
      //limit the number of bins
      Int_t numBins=300;
      if (4*v.size()<10000) numBins=4*v.size();

      MSG("LIAnalysis",Msg::kInfo)
        <<"vMax="<<vMax <<", vMin="<<vMin<<", numBins="<<numBins<<endl;

      //create the histo
      TH1F* h=new TH1F("h","h",numBins,vMin-abs(0.1*vMin),
                       vMax+abs(0.1*vMin));
      h->SetBit(TH1::kCanRebin);

      Double_t average=0;
      for (UInt_t i=0;i<v.size();i++){
        //find average
        average+=v[i];

        //fill the histo
        h->Fill(v[i]);
      }
      average/=v.size();

      //fit but use 0 (zero!) otherwise it stamps on the current canvas!
      h->Fit("gaus","q0");
      TF1* func=h->GetFunction("gaus");
      Double_t p1=func->GetParameter(1);
      Double_t p2=func->GetParameter(2);

      //don't use the fit if it is screwed up
      Double_t avToNormWith=p1;
      if (p1<vMin || p1>vMax) avToNormWith=average;

      MSG("LIAnalysis",Msg::kInfo)
        <<"Fitted mean="<<p1
        <<" (average="<<average
        <<") fitted rms="<<p2
        <<", using avToNormWith="<<avToNormWith<<endl;

      //normalise
      for (UInt_t i=0;i<v.size();i++) v[i]/=avToNormWith;

      delete h;
    }
  }

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished NormaliseVector method **"<<endl;
}

//......................................................................

void CDAnalysis::SetLoopVariables(Int_t event)
{
  Float_t fract=ceil(fEvents/20.);
  
  if (ceil(((Float_t)event)/fract)==((Float_t)event)/fract){
    MSG("CDAnalysis",Msg::kInfo) 
      <<"Fraction of loop complete: "<<event 
      <<"/"<<fEvents<<"  ("
      <<(Int_t)(100.*event/fEvents)<<"%)"<<endl;
  }

  //get the snarl/event
  fTrackerTree->GetEvent(event); 

  //initialise snarl level variables
  this->InitialiseLoopVariables();

  this->InitialisePidVariables();

  //get the pid info
  if (fPIDInfo){
    fTriggerPMT=fPIDInfo->GetTriggerPMT();
    fFafErr=fPIDInfo->GetFafErr() ;
    fSparseErr=fPIDInfo->GetSparseErr();
    fTrigSource=fPIDInfo->GetTrigSource();
    fKovADC1=fPIDInfo->GetKovADC1() ;
    fKovTimeStamp1=fPIDInfo->GetKovTimeStamp1();
    fKovADC2=fPIDInfo->GetKovADC2();
    fKovTimeStamp2=fPIDInfo->GetKovTimeStamp2();
    fKovADC3=fPIDInfo->GetKovADC3();
    fKovTimeStamp3=fPIDInfo->GetKovTimeStamp3(); 
    fSnarlTimeFrame=fPIDInfo->GetSnarlTimeFrame();
    fSnarlMinTimeStamp=fPIDInfo->GetSnarlMinTimeStamp();
    fSnarlMaxTimeStamp=fPIDInfo->GetSnarlMaxTimeStamp();
    fTofTDC0=fPIDInfo->GetTofTDC0();//actual time of flight
    fTofTDC1=fPIDInfo->GetTofTDC1();
    fTofTDC2=fPIDInfo->GetTofTDC2();
    fTofADC0=fPIDInfo->GetTofADC0();
    fTofADC1=fPIDInfo->GetTofADC1();
    fTofADC2=fPIDInfo->GetTofADC2();
    /*
      kTofADCChannel0=ph.GetSpecialChannelContains("TADC0");
      kTofADCChannel1=ph.GetSpecialChannelContains("TTAG");
      if(kTofADCChannel1==0){
         kTofADCChannel1=ph.GetSpecialChannelContains("TADC1");
      }
      kTofADCChannel2=ph.GetSpecialChannelContains("TimingFid");
      if(kTofADCChannel2==0){
         kTofADCChannel2=ph.GetSpecialChannelContains("TADC2");
      }
      kTofTimeStampChannel=ph.GetSpecialChannelContains("TTIME");
    */
    fTofADCTimeStamp0=fPIDInfo->GetTofADCTimeStamp0();//TADC0
    fTofADCTimeStamp1=fPIDInfo->GetTofADCTimeStamp1();//TTAG || TADC1
    fTofADCTimeStamp2=fPIDInfo->GetTofADCTimeStamp2();//TimingFid |TADC2
    //TofTimeStamp=fPIDInfo->GetTofTimeStamp();//don't use
    fTickSinceLast=fPIDInfo->GetTickSinceLast();
    
    //these are the PID variables
    fNoOverlap=fPIDInfo->GetNoOverlap();
    fInCERTime=fPIDInfo->GetInCERTime();
    fPIDType=fPIDInfo->GetPIDType();
    fNoOverlapBits=fPIDInfo->GetNoOverlapBits();
    fInCERTimeBits=fPIDInfo->GetInCERTimeBits();
    fOLChi2=fPIDInfo->GetOLChi2();
  }
}  

//......................................................................

void CDAnalysis::PrintBasicInfo(std::string s) const
{
  MSG("CDAnalysis",Msg::kInfo)
    <<s<<"(Pl,St,End)=("<<fPlane<<","<<fStrip<<","<<fStripend<<")"
    <<", adc="<<fChargeAdc
    <<", sigL="<<fChargeSigLin
    <<", sigC="<<fChargeSigCor
    <<", mip="<<fChargeMip
    <<", pe="<<fChargePe
    <<endl;
}

//......................................................................

void CDAnalysis::PrintEvent(Int_t event)
{
  if (event>=fEvents) {
    MSG("CDAnalysis",Msg::kFatal)
      <<"No such event in tree="<<event<<", fEvents="<<fEvents<<endl;
    return;
  }

  MSG("CDAnalysis",Msg::kInfo)
    <<"Printing for event="<<event<<", fEvents="<<fEvents<<endl;

  //get the snarl/event
  fTrackerTree->GetEvent(event); 

  //get tclones arrays for this snarl
  TClonesArray &cTrk=*fTrkHitInfo;
  Int_t numTrkHits=fTrkHitInfo->GetEntries();
  TClonesArray &cUnTrk = *fUnTrkHitInfo;
  Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
  TClonesArray &cXTalk = *fXTalkHits;
  Int_t numXTalkHits=fXTalkHits->GetEntries();
  
  //loop over the untracked hits in the snarl
  MSG("CDAnalysis",Msg::kInfo)<<"Untracked hits..."<<endl;
  for (Int_t hit=0;hit<numUnTrkHits;hit++){
    //cast the tclonesarray up to a trackedhitinfo object
    CDTrackedHitInfo *hitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);
    
    this->ReadInHitInfo(hitInfo);
    
    this->PrintBasicInfo();
  }
  
  //loop over xtalk hits in the snarl
  MSG("CDAnalysis",Msg::kInfo)<<"XTalk hits..."<<endl;
  for (Int_t hit=0;hit<numXTalkHits;hit++){
    CDXTalkHitInfo *hitInfo=
      dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);
    
    this->ReadInHitInfo(hitInfo);

    this->PrintBasicInfo();
  }

  //loop over the tracked hits
  MSG("CDAnalysis",Msg::kInfo)<<"Tracked hits..."<<endl;
  for (Int_t hit=0;hit<numTrkHits;hit++){
    CDTrackedHitInfo* hitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);

    this->ReadInHitInfo(hitInfo);
    
    this->PrintBasicInfo();
  }
}

//......................................................................

void CDAnalysis::CalcNumPlanesHit(Int_t plane,Float_t pe)
{
  //calc the num planes hit
  fNumPlanesHitAll[plane]++;

  //calc number of planes hit in first 25
  if (plane<25) fNumPlanesHit25[plane]++;

  //calc if pe cut satisfied
  if (pe>1.5) {
    fNumPlanesHitPeCut[plane]++;

    //only calc planes hit in first 10 planes
    if (plane<10) fNumPlanesHitPeCut10[plane]++;
  }
}

//......................................................................

void CDAnalysis::CalcNumPlanesHitTrk(Int_t plane)
{
  //calc the num planes hit
  fNumPlanesHitTrk[plane]++;
}

//......................................................................

void CDAnalysis::CalcAvStripForPSMuonCut(Int_t plane,Int_t strip,
                                         Int_t end)
{
  if (plane<4){
    //calc weighted average strip
    fAvStrip=fAvStrip*(fStCount/(fStCount+1))+strip*(1/(fStCount+1));
    fStCount++;
    MAXMSG("CDAnalysis",Msg::kVerbose,1000)
      <<"  strip="<<strip<<", plane="<<plane
      <<", fEnd="<<fStripend<<", fAvStrip="<<fAvStrip
      <<", fStCount="<<fStCount<<endl;

    //now do each end separately
    if (end==1 && plane>0) {
      fAvStrip1=fAvStrip1*(fStCount1/(fStCount1+1))+
        strip*(1/(fStCount1+1));
      fStCount1++;
    }
    else if (end==2 && plane>0) {
      fAvStrip2=fAvStrip2*(fStCount2/(fStCount2+1))+
        strip*(1/(fStCount2+1));
      fStCount2++;
    }
  }
}

//......................................................................

void CDAnalysis::CalcLowUpScint_TofDiff(Double_t time)
{
  Double_t tickInNs=25./16;//ns, va clock tick
  Float_t timeDiff=(time*1e9)-(fTofADCTimeStamp1*tickInNs);//ns

  if (fTofADCTimeStamp1<1 || fTofADCTimeStamp1>1e9/tickInNs){
    MAXMSG("CDAnalysis",Msg::kWarning,10)
      <<"Bad Tof (TTAG) time="<<fTofADCTimeStamp1
      <<" ticks, ("<<fTofADCTimeStamp1*tickInNs<<" ns)"<<endl;
  }

  if (timeDiff>1000 || timeDiff<-1000){
    MAXMSG("CDAnalysis",Msg::kWarning,10)
      <<"Bad Scint-Tof (TTAG) time difference="<<timeDiff<<" ns"
      <<", time="<<time<<", tof time="<<fTofADCTimeStamp1
      <<" ticks, ("<<fTofADCTimeStamp1*tickInNs<<" ns)"<<endl;
  }

  //calc highest and lowest scint tof time diff.
  if (timeDiff>fUpScint_Tof) fUpScint_Tof=timeDiff;
  if (timeDiff<fLowScint_Tof) fLowScint_Tof=timeDiff;
}

//......................................................................

void CDAnalysis::CalcFirstLastPlane(Int_t plane)
{
  if (plane<fFirstPlane) fFirstPlane=plane;
  if (plane>fLastPlane) fLastPlane=plane;
  if (plane>fLastPlaneOdd && plane%2!=0) fLastPlaneOdd=plane;
  if (plane>fLastPlaneEven && plane%2==0) fLastPlaneEven=plane;
}

//......................................................................

Int_t CDAnalysis::CalcLastPlaneTruth() const
{  
  if (!fTruthHitInfo) return 0;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();

  Int_t lastPlane=0;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();

    //check either side
    Int_t sumTruth=pmtTruth1|pmtTruth2;

    //check if genuine
    if ((sumTruth & DigiSignal::kGenuine)==DigiSignal::kGenuine){
      //see if bigger
      if (plane>lastPlane) lastPlane=plane;
    }
    MSG("CDAnalysis",Msg::kVerbose)
      <<"sumTruth="<<sumTruth<<endl;
  }

  MSG("CDAnalysis",Msg::kVerbose)
    <<"CalcLastPlaneTruth: LastPlane="<<lastPlane
    <<", fLastPlane="<<fLastPlane<<endl; 

  return lastPlane;
}

//......................................................................

void CDAnalysis::CalcLastPlaneOnTrk()
{

  TClonesArray &cTrk=*fTrkHitInfo;
  Int_t numTrkHits=fTrkHitInfo->GetEntries();

  //loop over the tracked hits
  for (Int_t hit=0;hit<numTrkHits;hit++){
    CDTrackedHitInfo *trackedHitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
    
    this->ReadInHitInfo(trackedHitInfo);
    
    //cut out the bad channels
    if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;
    
    //check the channel's sanity
    this->StandardSanityChecks();
    
    //calculate the first and last planes
    this->CalcFirstLastPlane(fPlane);
    
  }
  //end of loop over the tracked hits
  
  MSG("CDAnalysis",Msg::kVerbose)
    <<"CalcLastPlaneOnTrk: fLastPlane="<<fLastPlane<<endl; 
}

//......................................................................

Int_t CDAnalysis::CalcLastPlaneOnTrkNoXTalk() const
{
  //get tclones arrays for this snarl
  TClonesArray &cTrk=*fTrkHitInfo;
  Int_t numTrkHits=fTrkHitInfo->GetEntries();
  TClonesArray &cUnTrk = *fUnTrkHitInfo;
  Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
  TClonesArray &cXTalk = *fXTalkHits;
  Int_t numXTalkHits=fXTalkHits->GetEntries();
  
  map<Int_t,Float_t> planeGreatestPe;
  Int_t lastPlane=0;  

  //the untracked and xtalk hits are just used to find the greatest
  //pe in each plane; they are not included in the last plane 
  //directly

  //loop over the untracked hits in the snarl
  for (Int_t hit=0;hit<numUnTrkHits;hit++){
    //cast the tclonesarray up to a trackedhitinfo object
    CDTrackedHitInfo *hitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);
    
    //get the variables
    Int_t plane=hitInfo->GetPlane();
    Int_t strip=hitInfo->GetStrip();
    Int_t stripend=hitInfo->GetEnd();
    Float_t chargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);

    //cut out the bad channels
    if (this->CutOnBadPedestals(plane,strip,stripend)) continue;
    
    if (chargePe>planeGreatestPe[fPlane]) planeGreatestPe[plane]=
                                            chargePe;
  }
  
  //loop over xtalk hits in the snarl
  for (Int_t hit=0;hit<numXTalkHits;hit++){
    CDXTalkHitInfo *hitInfo=
      dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);
    
    //get the variables
    Int_t plane=hitInfo->GetPlane();
    Int_t strip=hitInfo->GetStrip();
    Int_t stripend=hitInfo->GetEnd();
    Float_t chargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);

    //cut out the bad channels
    if (this->CutOnBadPedestals(plane,strip,stripend)) continue;
    
    if (chargePe>planeGreatestPe[fPlane]) planeGreatestPe[plane]=
                                            chargePe;
  }

  //loop over the tracked hits
  for (Int_t hit=0;hit<numTrkHits;hit++){
    CDTrackedHitInfo* hitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
    
    //get the variables
    Int_t plane=hitInfo->GetPlane();
    Int_t strip=hitInfo->GetStrip();
    Int_t stripend=hitInfo->GetEnd();
    Float_t chargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);

    if (plane>lastPlane) lastPlane=plane;

    //cut out the bad channels
    if (this->CutOnBadPedestals(plane,strip,stripend)) continue;
    
    if (chargePe>planeGreatestPe[fPlane]) planeGreatestPe[plane]=
                                            chargePe;
  }
  //end of loop over the tracked hits

  Int_t newLastPlane=lastPlane;
  Double_t xtalkLevel=1.7;

  if (fLastPlane>=3){//make sure track is at least 4 planes
    if (planeGreatestPe[lastPlane]>xtalkLevel){
      //do nothing
    }
    else if (planeGreatestPe[lastPlane-1]>xtalkLevel){
      newLastPlane=lastPlane-1;
    }
    else if (planeGreatestPe[lastPlane-2]>xtalkLevel){
      newLastPlane=lastPlane-2;
    }
    else{
      if (planeGreatestPe[lastPlane-3]<xtalkLevel){
        MSG("CDAnalysis",Msg::kDebug)
          <<"4th plane with low pe hit"
          <<", pe0="<<planeGreatestPe[lastPlane-0]
          <<", pe1="<<planeGreatestPe[lastPlane-1]
          <<", pe2="<<planeGreatestPe[lastPlane-2]
          <<", pe3="<<planeGreatestPe[lastPlane-3]
          <<endl;
      }
      newLastPlane=lastPlane-3;
    }
  }
  
  MSG("CDAnalysis",Msg::kVerbose)
    <<"CalcLastPlaneOnTrkNoXTalk: lastPlane="<<lastPlane
    <<", newLastPlane="<<newLastPlane<<endl; 
  
  return newLastPlane;
}

//......................................................................

void CDAnalysis::ReadInHitInfo(CDTrackedHitInfo* hitInfo)
{
  //initialise variables to be on the safe side
  this->InitialiseHitInfoVariables();

  fTime=hitInfo->GetTime();

  //get the variables
  fPlane=hitInfo->GetPlane();
  fStrip=hitInfo->GetStrip();
  fStripend=hitInfo->GetEnd();
  fTransPos=hitInfo->GetTransPos();
  
  //decide which stripend is which; odd, even, 1 or 2.
  fO1=(fStripend==1 && fPlane%2==1);
  fO2=(fStripend==2 && fPlane%2==1);
  fE1=(fStripend==1 && fPlane%2==0);
  fE2=(fStripend==2 && fPlane%2==0);

  //look at the calorimetry info
  fChargeAdc=hitInfo->GetCharge(CDTrackedHitInfo::kAdc);
  fChargeMip=hitInfo->GetCharge(CDTrackedHitInfo::kMip);
  fChargeSigCor=hitInfo->GetCharge(CDTrackedHitInfo::kSigCorr);
  fChargeSigLin=hitInfo->GetCharge(CDTrackedHitInfo::kSigLin);
  fChargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);
  if (fChargePe!=0) fGain=fChargeSigLin/fChargePe;
  else fGain=-1;

  static Bool_t firstTime=true;
  if (fChargeMip>0 && fChargeSigCor>0 && firstTime){
    firstTime=false;
    fSigCorsPerMip=fChargeSigCor/fChargeMip;
    MAXMSG("CDAnalysis",Msg::kVerbose,100)
      <<"fSigCorsPerMip="<<fSigCorsPerMip<<endl;
  }

  //get the tracker evaluation of the event
  fResultEven=fTrackInfo->GetResult(0);
  fResultOdd=fTrackInfo->GetResult(1);
}

//......................................................................

void CDAnalysis::ReadInHitInfo(CDXTalkHitInfo* hitInfo)
{
  //initialise variables to be on the safe side
  this->InitialiseHitInfoVariables();

  fTime=hitInfo->GetTime();

  //get the variables
  fPlane=hitInfo->GetPlane();
  fStrip=hitInfo->GetStrip();
  fStripend=hitInfo->GetEnd();
  //fTransPos=hitInfo->GetTransPos();
  fTransPos=-1;//npt possible to calculate for xtalk

  //decide which stripend is which; odd, even, 1 or 2.
  fO1=(fStripend==1 && fPlane%2==1);
  fO2=(fStripend==2 && fPlane%2==1);
  fE1=(fStripend==1 && fPlane%2==0);
  fE2=(fStripend==2 && fPlane%2==0);

  //look at the calorimetry info
  fChargeAdc=hitInfo->GetCharge(CDTrackedHitInfo::kAdc);
  fChargeMip=hitInfo->GetCharge(CDTrackedHitInfo::kMip);
  fChargeSigCor=hitInfo->GetCharge(CDTrackedHitInfo::kSigCorr);
  fChargeSigLin=hitInfo->GetCharge(CDTrackedHitInfo::kSigLin);
  fChargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);
  if (fChargePe!=0) fGain=fChargeSigLin/fChargePe;
  else fGain=-1;
}

//......................................................................

Float_t CDAnalysis::CalcPathLengthCorection(const TVector3& end1,
                                            const TVector3& end2) const
{
  //calc pathlength between two points
  Float_t x=end1.X()-end2.X();
  Float_t y=end1.Y()-end2.Y();
  Float_t z=end1.Z()-end2.Z();
  Float_t pathLength=sqrt(pow(x,2)+pow(y,2)+pow(z,2));
  //calc path length correction
  Float_t pathLengthCor=-1;
  if (z!=0) pathLengthCor=pathLength/fabs(z);
  else cout<<"pathlength cor problem: z="<<z
           <<", x="<<x<<", y="<<y<<endl;
  return pathLengthCor;
}

//......................................................................

void CDAnalysis::CalcXorYandZ(Int_t strip,Int_t plane,
                              Float_t& x,Float_t& y,Float_t& z) const
{
  Float_t planePitch=5.94*Munits::cm;
  Float_t stripWidth=4.1*Munits::cm;
  Float_t stripsFromCentre=strip-11.5;//middle 2 strips 11&12 are 0.5 st
  Float_t distFromCentre=stripsFromCentre*stripWidth;
  
  //calc z
  z=plane*planePitch;

  if (plane%2==0){//even, v-view (measure v and y), horizontal strips
    x=-1;
    y=distFromCentre;
  }
  else if (plane%2==1){//odd, u-view (measure u and x), vertical strips
    x=distFromCentre;;
    y=-1;
  }
}

//......................................................................

void CDAnalysis::TrueHighLowEn(Float_t& highEn,Float_t& lowEn) const
{
  if (!fTruthHitInfo) return;

  //initialise
  lowEn=999999;
  highEn=-1;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Double_t energy=hitInfo->GetMainPartEn();
    Int_t particle=hitInfo->GetMainParticle();
    Int_t muon=13;
    
    if (abs(particle)==muon) {
      if (energy>highEn) highEn=energy;
      if (energy<lowEn) lowEn=energy; 
    }
  }

  //reset to -1 if not found to be consistent with highEn
  if (lowEn==999999) lowEn=-1;
}

//......................................................................

void CDAnalysis::TruePLCor(std::map<Int_t,Float_t>& mPLCor,
                           Int_t event) const
{
  Int_t lastPlane=this->GetEventLength();
  if (lastPlane<0) return;
  Float_t lastPLCor=-1;
  Float_t lastPL=-1;

  for (Int_t pl=0;pl<=lastPlane;pl++){
    Float_t pathLen=this->TrueMainPL(pl,event);
    //get a zero if no dsh in a plane
    //also know that PL must be at least 0.95 cm
    if (pathLen<0.95*Munits::cm) {
      if (lastPL>=0.95*Munits::cm) pathLen=lastPL;
      else pathLen=0.95*Munits::cm;
    }
    //record the last PL
    lastPL=pathLen;

    Float_t pathLengthCor=pathLen/(0.95*Munits::cm);
    if (pathLengthCor<0.999) {
      MAXMSG("CDAnalysis",Msg::kWarning,500)
        <<"bad PLCor="<<pathLengthCor<<endl;
      if (lastPLCor>=1) pathLengthCor=lastPLCor;
      else pathLengthCor=1;
    }
    else if (pathLengthCor>0.999 && pathLengthCor<1){
      MAXMSG("CDAnalysis",Msg::kVerbose,500)
        <<"fractionally wrong PLCor="<<pathLengthCor<<endl;
      pathLengthCor=1;
    }

    //insert the value into the map
    mPLCor[pl]=pathLengthCor;

    //record the last PLCor
    lastPLCor=pathLengthCor;
  }
}

//......................................................................

Bool_t CDAnalysis::CalcPLCor(const std::map<Int_t,TVector3>& mPlPos,
                             std::map<Int_t,Float_t>& mPLCor) const
{
  map<Int_t,TVector3>::const_iterator plPosEndIt=mPlPos.end();

  //Int_t lastPlaneNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();
  Int_t lastPlane=this->GetEventLength();
  Float_t initValue=-999;
 
  for (Int_t pl=0;pl<=lastPlane;pl++){
    Int_t plVtxSide=pl-2;
    Int_t plStopSide=pl+2;
    
    //protect against going outside allowed ranges
    if (plVtxSide<0) plVtxSide=0;
    if (plStopSide>lastPlane) plStopSide=lastPlane;

    MAXMSG("CDAnalysis",Msg::kDebug,500)
      <<"pl="<<pl<<", plStopSide="<<plStopSide
      <<", plVtxSide="<<plVtxSide<<endl;

    //fit track position
    TGraph gx_z(3);//min of 3 points
    TGraph gy_z(3);
    Int_t tmpPl=plStopSide;
    Int_t tmpPlVtxSide=plVtxSide+1;
    Bool_t posDir=true;//always forward going in caldet
    if (posDir) tmpPlVtxSide=plVtxSide-1;
    Int_t i=0;
    //loop over planes to fit
    while (tmpPl!=tmpPlVtxSide){
      map<Int_t,TVector3>::const_iterator plPosIt=mPlPos.find(tmpPl);
      if (plPosIt!=plPosEndIt){
        Float_t x=(plPosIt->second).x();
        Float_t y=(plPosIt->second).y();
        Float_t z=(plPosIt->second).z();
        gx_z.SetPoint(i,z,x);
        gy_z.SetPoint(i,z,y);
        MAXMSG("CDAnalysis",Msg::kVerbose,500)
          <<"Adding point: x="<<x<<", y="<<y<<", z="<<z<<endl;
        //count the number of points added
        i++;
      }
      //increment the plane
      if (posDir) tmpPl--;
      else tmpPl++;
    }
  
    Float_t newPLCor=initValue;
    if (i>=3){
      gx_z.Fit("pol1","q");
      gy_z.Fit("pol1","q");
      Float_t mx_z=gx_z.GetFunction("pol1")->GetParameter(1);
      Float_t my_z=gy_z.GetFunction("pol1")->GetParameter(1);
      //Float_t mx_zErr=gx_z.GetFunction("pol1")->GetParError(1);
      //Float_t my_zErr=gy_z.GetFunction("pol1")->GetParError(1);
      newPLCor=sqrt(pow(mx_z,2)+pow(my_z,2)+1);
      MAXMSG("CDAnalysis",Msg::kDebug,500)
        <<"pl="<<pl<<", found plcor="<<newPLCor<<endl;
    }
    else {
      MSG("CDAnalysis",kWarning)
        <<"Less than 3 points, can't do local grad. fit"<<endl;
      return false;
    }

    if (newPLCor!=initValue) mPLCor[pl]=newPLCor;
    else MSG("CDAnalysis",kInfo)<<"Bad PLCor"<<endl;

  } 

  return true;
}

//......................................................................

Bool_t CDAnalysis::CalcXYZ(std::map<Int_t,TVector3>& mPlPos) const
{
  //get tclones arrays for this snarl
  TClonesArray &cTrk=*fTrkHitInfo;
  Int_t numTrkHits=fTrkHitInfo->GetEntries();
  
  if (numTrkHits<2){
    MAXMSG("CDAnalysis",Msg::kWarning,100)
      <<"CalcXYZ::numTrkHits is bad="<<numTrkHits<<endl;
    return false;
  }

  //Int_t lastPlaneNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();
  Int_t lastPlane=this->GetEventLength();
  if (lastPlane<2 || lastPlane>59){
    MAXMSG("CDAnalysis",Msg::kWarning,100)
      <<"CalcXYZ::last plane is bad="<<lastPlane<<endl;
    return false;
  }

  Bool_t foundFirstFew=false;
  Bool_t unFilledGap=false;
  Float_t initValue=-999;
  vector<TVector3> plPosition(60);
  for (Int_t pl=0;pl<60;pl++){
    plPosition[pl]=TVector3(initValue,initValue,initValue);
  }

  //loop over the tracked hits
  for (Int_t hit=0;hit<numTrkHits;hit++){
    CDTrackedHitInfo* hitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
    
    //get the variables
    Int_t plane=hitInfo->GetPlane();
    Int_t strip=hitInfo->GetStrip();
    Int_t stripend=hitInfo->GetEnd();
    //Float_t chargePe=hitInfo->GetCharge(CDTrackedHitInfo::kPe);

    //cut out the bad channels
    if (this->CutOnBadPedestals(plane,strip,stripend)) continue;

    Float_t x=initValue;
    Float_t y=initValue;
    Float_t z=initValue;
    this->CalcXorYandZ(strip,plane,x,y,z);

    plPosition[plane]=TVector3(x,y,z);

  }
  //end of loop over the tracked hits

  //calc the x and y of the first two planes
  //loop and look at more planes if can't find any hits in first few
  for (Int_t np=2;np<=5;np++){
    //look at first few even planes
    Float_t yAvFirstFew=0;
    Float_t yAvFirstFewCounter=0;
    for (Int_t pl=0;pl<np*2;pl+=2){//even measures v or y
      if (plPosition[pl].y()!=initValue){
        yAvFirstFew+=plPosition[pl].y();
        yAvFirstFewCounter++;
      }
    }
    if (yAvFirstFewCounter>0) yAvFirstFew/=yAvFirstFewCounter;
    else yAvFirstFew=initValue;
    
    //look at first few odd planes
    Float_t xAvFirstFew=0;
    Float_t xAvFirstFewCounter=0;
    for (Int_t pl=1;pl<np*2;pl+=2){//odd measures u or x
      if (plPosition[pl].x()!=initValue){
        xAvFirstFew+=plPosition[pl].x();
        xAvFirstFewCounter++;
      }
    }
    if (xAvFirstFewCounter>0) xAvFirstFew/=xAvFirstFewCounter;
    else xAvFirstFew=initValue;
    
    MAXMSG("CDAnalysis",Msg::kDebug,1000)
      <<"num planes="<<np
      <<", avX="<<xAvFirstFew<<" ("<<xAvFirstFewCounter<<")"
      <<", avY="<<yAvFirstFew<<" ("<<yAvFirstFewCounter<<")"<<endl;

    //now set the TVectors if an average was obtained
    if (xAvFirstFew==initValue || yAvFirstFew==initValue){
      MAXMSG("CDAnalysis",Msg::kVerbose,100)
        <<endl<<"Not found tracked hits with num planes="<<np
        <<", looping again..."<<endl<<endl;
    }
    else{
      //set the first 2 planes (what is not measured by that plane)
      plPosition[0].SetX(xAvFirstFew);
      plPosition[1].SetY(yAvFirstFew);
      
      //sometimes have to set what should have been measured if 
      //it is missing
      if (plPosition[0].Y()==initValue || plPosition[1].X()==initValue){
        MAXMSG("CDAnalysis",Msg::kDebug,100)
          <<endl<<"Having to manually set x or y in first few planes"
          <<endl<<endl;
        //plPosition[0].Print();
        //plPosition[1].Print();
      }
      if (plPosition[0].Y()==initValue) plPosition[0].SetY(yAvFirstFew);
      if (plPosition[1].X()==initValue) plPosition[1].SetX(xAvFirstFew);
      foundFirstFew=true;
      break;
    }
  }

  if (!foundFirstFew){
    MAXMSG("CDAnalysis",Msg::kDebug,100)
      <<endl<<"Not found hits in first few planes ignoring this event"
      <<endl<<endl;
    return false;
  }

  //probably best to do the +/- 2 planes first to fill the gaps
  //then do the interpolation into the planes that don't measure
  //what is needed.

  //loop and fill the gaps
  for (Int_t pl=2;pl<=lastPlane;pl++){

    Bool_t foundGap=false;
    
    //check for gaps
    if (pl%2==0){//even planes, measures v and y
      if (plPosition[pl].Y()==initValue) foundGap=true;
    }
    else if (pl%2==1){//odd planes, measures u and x
      if (plPosition[pl].X()==initValue) foundGap=true;
    }

    if (foundGap) {
      Int_t plPrev=pl-2;
      Int_t plNext=pl+2;
      Int_t plPrev4=pl-4;
      Int_t plNext4=pl+4;
      Float_t posPrev=initValue;
      Float_t posNext=initValue;
      Float_t pos=initValue;
      Float_t posPrev4=initValue;
      Float_t posNext4=initValue;
      Float_t pos4=initValue;

      //protect against going outside allowed ranges
      if (plPrev<0) {
        if (abs(plPrev%2)==0) plPrev=0;//even
        else if (abs(plPrev%2)==1) plPrev=1;//odd
      }
      if (plNext>59){
        if (plNext%2==0) plNext=58;//even
        else if (plNext%2==1) plNext=59;//odd
      }
      if (plPrev4<0) {
        if (abs(plPrev4%2)==0) plPrev4=0;//even
        else if (abs(plPrev4%2)==1) plPrev4=1;//odd
      }
      if (plNext4>59){
        if (plNext4%2==0) plNext4=58;//even
        else if (plNext4%2==1) plNext4=59;//odd
      }
      
      if (pl%2==0){//even planes, measures v and y
        //get position
        posPrev=plPosition[plPrev].Y();
        posNext=plPosition[plNext].Y();
        posPrev4=plPosition[plPrev4].Y();
        posNext4=plPosition[plNext4].Y();
      }
      else if (pl%2==1){//odd planes, measures u and x
        //get position
        posPrev=plPosition[plPrev].X();
        posNext=plPosition[plNext].X();
        posPrev4=plPosition[plPrev4].X();
        posNext4=plPosition[plNext4].X();
      }
      
      if (posPrev==initValue || posNext==initValue){
        MAXMSG("CDAnalysis",Msg::kDebug,500)
          <<"pl="<<pl<<", not found position"
          <<", prev="<<posPrev<<", next="<<posNext
          <<endl;
      }
      else{
        //calc the new position
        pos=(posPrev+posNext)*0.5;
        //MAXMSG("CDAnalysis",Msg::kDebug,1000)
        //<<"pl="<<pl
        //<<", found positions, prev="<<posPrev<<", next="<<posNext
        //<<", pos="<<pos<<endl;
      }

      if (posPrev4==initValue || posNext4==initValue){
        MAXMSG("CDAnalysis",Msg::kDebug,500)
          <<"pl="<<pl<<", not found position"
          <<", prev4="<<posPrev4<<", next4="<<posNext
          <<endl;
      }
      else{
        //calc the new position
        pos4=(posPrev4+posNext4)*0.5;
        //MAXMSG("CDAnalysis",Msg::kDebug,1000)
        //<<"pl="<<pl
        //<<", found positions, prev4="<<posPrev4<<", next4="<<posNext4
        //<<", pos4="<<pos4<<endl;
      }
    
      Float_t posToUse=pos;
      if (posToUse==initValue) posToUse=pos4;

      if (posToUse!=initValue){
        if (pl%2==0){//even planes, measures v and y
          //set position
          //MAXMSG("CDAnalysis",Msg::kDebug,1000)
          //<<"pl="<<pl<<", setting pos="<<posToUse
          //<<", y was="<<plPosition[pl].Y()<<endl;
          plPosition[pl].SetY(posToUse);
        }
        else if (pl%2==1){//odd planes, measures u and x
          //set position
          //MAXMSG("CDAnalysis",Msg::kDebug,1000)
          //<<"pl="<<pl<<", setting pos="<<posToUse
          //<<", x was="<<plPosition[pl].X()<<endl;
          plPosition[pl].SetX(posToUse);
        }
      }
      else{
        MAXMSG("CDAnalysis",Msg::kDebug,3000)
          <<"pl="<<pl<<", fLastPlane="<<fLastPlane
          <<", lastPl="<<lastPlane
          <<", not managed to fill gap with first method"<<endl;
        unFilledGap=true;
      }
    }
    else{
      MAXMSG("CDAnalysis",Msg::kDebug,3000)
        <<"pl="<<pl<<", no gap"<<endl;
    }
  }

  //fill any gaps that failed to get filled above
  //simple algorithm to just use the previous x/y value in the track
  Float_t lastX=initValue;
  Float_t lastY=initValue;
  if (unFilledGap){
    for (Int_t pl=0;pl<=lastPlane;pl++){
      if (pl%2==0){//even planes, measures v and y
        if (plPosition[pl].Y()==initValue){
          plPosition[pl].SetY(lastY);
          //MAXMSG("CDAnalysis",Msg::kVerbose,1000)
          //<<"pl="<<pl<<", fLastPlane="<<fLastPlane
          //<<", lastPl="<<lastPlane
          //<<", filled gap (y="<<lastY<<")"<<endl;
        }
        //get last position in track
        lastY=plPosition[pl].Y();
      }
      else if (pl%2==1){//odd planes, measures u and x
        if (plPosition[pl].X()==initValue){
          plPosition[pl].SetX(lastX);
          //MAXMSG("CDAnalysis",Msg::kVerbose,1000)
          //<<"pl="<<pl<<", fLastPlane="<<fLastPlane
          //<<", lastPl="<<lastPlane
          //<<", filled gap (x="<<lastX<<")"<<endl;
        }
        //get last position in track
        lastX=plPosition[pl].X();
      }
    }
  }
  
  //loop and just do the simple calculations 
  //+/- 1 plane to calc what is not measured
  for (Int_t pl=2;pl<=lastPlane;pl++){
    Int_t plPrev=pl-1;
    Int_t plNext=pl+1;
    Float_t posPrev=initValue;
    Float_t posNext=initValue;
    Float_t pos=initValue;
    
    //protect against going outside allowed ranges
    if (plPrev<0) {
      if (abs(plPrev%2)==0) plPrev=0;//even
      else if (abs(plPrev%2)==1) plPrev=1;//odd
    }
    if (plNext>59){
      if (plNext%2==0) plNext=58;//even
      else if (plNext%2==1) plNext=59;//odd
    }
    
    if (pl%2==0){//even planes, measures v and y
      //get position
      posPrev=plPosition[plPrev].X();
      posNext=plPosition[plNext].X();
    }
    else if (pl%2==1){//odd planes, measures u and x
      //get position
      posPrev=plPosition[plPrev].Y();
      posNext=plPosition[plNext].Y();
    }
    
    if (posPrev==initValue || posNext==initValue){
      MAXMSG("CDAnalysis",Msg::kDebug,500)
        <<"pl="<<pl<<", fLastPlane="<<fLastPlane
        <<", lastPl="<<lastPlane
        <<", not found position"
        <<", prev="<<posPrev<<", next="<<posNext
        <<endl;
    }
    else{
      //calc the new position
      pos=(posPrev+posNext)*0.5;
      MAXMSG("CDAnalysis",Msg::kDebug,1000)
        <<"pl="<<pl
        <<", found positions, prev="<<posPrev<<", next="<<posNext
        <<", pos="<<pos<<endl;
    }
    
    if (pl%2==0){//even planes, measures v and y
      //set position
      plPosition[pl].SetX(pos);
    }
    else if (pl%2==1){//odd planes, measures u and x
      //set position
      plPosition[pl].SetY(pos);
    }
  }
  
  //need to do a 3D vector type correction to work out the last plane
  //but hack for now - use same x/y as previous plane
  Int_t pl=lastPlane;
  if (pl%2==0){//even planes, measures v and y
    //set position
    Float_t lastPlX=plPosition[pl-1].X();
    plPosition[pl].SetX(lastPlX);
  }
  else if (pl%2==1){//odd planes, measures u and x
    //set position
    Float_t lastPlY=plPosition[pl-1].Y();
    plPosition[pl].SetY(lastPlY);
  }
  
  //MAXMSG("CDAnalysis",Msg::kInfo,200)
  //<<"fLastPlane="<<fLastPlane
  //<<", lastPl="<<lastPlane
  //<<endl;
  //loop and print positions
  //for (Int_t pl=0;pl<60;pl++){
  //MAXMSG("CDAnalysis",Msg::kInfo,5000)
  //  <<"pl="<<pl<<" (x,y,z)=("<<plPosition[pl].X()
  //  <<","<<plPosition[pl].Y()
  //  <<","<<plPosition[pl].Z()<<")"<<endl;
  //}
  
  //make map to return (not nice)
  for (Int_t pl=0;pl<60;pl++){
    mPlPos[pl]=plPosition[pl];
  }
  
  return true;
}

//......................................................................

Float_t CDAnalysis::CalcDistToPlaneCentre(Int_t strip,
                                          Float_t transPos) const
{
  Float_t stripSize=0.041*Munits::m;
  Float_t distToPlaneCentre=-1;
  //note that strips are numbered from 0  

  //cutting on transPos==0 is ugly since it's an allowed value
  //but this is what it is initialised to and it 
  //should only cut real values rarely
  if (strip<0 || strip>23 || transPos<0 || transPos==0 || 
      transPos>23) return distToPlaneCentre;

  Float_t dist1=-1;
  Float_t dist2=-1;
  Float_t stripsFromCentre1=-1;
  Float_t transPosFromCentre1=-1;

  //get distances measured from plane centre in each view
  if (strip<=11) stripsFromCentre1=11-strip;
  else if (strip>11) stripsFromCentre1=strip-12;
  if (transPos<=11) transPosFromCentre1=11-transPos;
  else if (transPos>11) transPosFromCentre1=transPos-11;

  //calc real distances
  dist1=stripsFromCentre1*stripSize;
  dist2=transPosFromCentre1*stripSize;
  
  //move it to the middle of a strip so 
  //you know which strip it's actually in
  dist1+=stripSize*0.5;
  //transPos is not quantised so don't worry about it here

  //simple bit of trig
  if (dist1>0 && dist2>0){
    distToPlaneCentre=sqrt(pow(dist1,2)+pow(dist2,2));
  }
  
  return distToPlaneCentre;
}

//......................................................................

Float_t CDAnalysis::TrueDistToPlaneCentre(Int_t strip,
                                          Float_t x) const
{
  Float_t stripSize=0.041*Munits::m;
  Float_t distToPlaneCentre=-1;
  //note that strips are numbered from 0  

  if (strip<0 || strip>23 || x>0.5 || x<-0.5) return distToPlaneCentre;

  Float_t dist1=-1;
  Float_t dist2=-1;
  Float_t stripsFromCentre1=-1;

  //get distances measured from plane centre in each view
  if (strip<=11) stripsFromCentre1=11-strip;
  else if (strip>11) stripsFromCentre1=strip-12;
  if (x<0) x=x-2*x;//convert to positive for later check

  //calc real distances
  dist1=stripsFromCentre1*stripSize;
  dist2=x;//don't need to do it for x  

  //move it to the middle of a strip so 
  //you know which strip it's actually in
  dist1+=stripSize*0.5;

  //simple bit of trig
  if (dist1>0 && dist2>0){
    distToPlaneCentre=sqrt(pow(dist1,2)+pow(dist2,2));
  }
  
  return distToPlaneCentre;
}

//......................................................................

void CDAnalysis::StandardSanityChecks() const
{
  //new check to not allow any capid errors
  if (fChargeAdc<1){
    MSG("CDAnalysis",Msg::kFatal)
      <<"Run has bad adcs!"<<endl
      <<"adc="<<fChargeAdc<<" ("<<fPlane<<":"<<fStrip<<":"<<fStripend
      <<")"<<endl;
    assert(false);
  }
}

//......................................................................

void CDAnalysis::ScaleVector(std::vector<Double_t>& v,
                             Double_t scaleFactor) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running ScaleVector method... **"<<endl;

  for (UInt_t i=0;i<v.size();i++) v[i]*=scaleFactor;

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished ScaleVector method **"<<endl;
}

//......................................................................

void CDAnalysis::FlipVector(std::vector<Double_t>& v) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running FlipVector method... **"<<endl;

  vector<Double_t> tempV=v;

  for (UInt_t i=0;i<v.size();i++) v[i]=tempV[v.size()-1-i];

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished FlipVector method **"<<endl;
}

//......................................................................

Int_t CDAnalysis::Rnd(Double_t x) const
{
  Double_t xi=0;

  Double_t floatPart=modf(x,&xi); 

  //round up if necessary
  if (floatPart>0.5) xi++;

  return static_cast<Int_t>(xi);
}

//......................................................................

void CDAnalysis::ScaleMap(std::map<Int_t,Float_t>& m,
                          const std::map<Int_t,Float_t>& scaleFactor) const
{
  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Running ScaleMap method... **"<<endl;

  if (m.size()==scaleFactor.size()){
    
    map<Int_t,Float_t>::iterator mIter=m.begin();
    map<Int_t,Float_t>::const_iterator scale=scaleFactor.begin();

    //loop over map and scale it
    while (mIter!=m.end()){

      //divide by the scale factor
      if (scale->second!=0){
        MSG("CDAnalysis",Msg::kVerbose)
          <<"mIter="<<mIter->second<<", scale="<<scale->second<<endl;
        mIter->second/=scale->second;
      }
      else MSG("CDAnalysis",Msg::kWarning)<<"Scale factor zero!"<<endl;

      mIter++;
      scale++;
    }
  }
  else{
    MSG("CDAnalysis",Msg::kWarning)
      <<"Not scaling map, vectors are different sizes!"<<endl;
  }

  MSG("CDAnalysis",Msg::kDebug) 
    <<" ** Finished ScaleMap method **"<<endl;
}

//......................................................................

Bool_t CDAnalysis::CutOnFiducialVolume() const
{
  Bool_t cutThisOne=false;

  Int_t stripsFromCentreCut=10;

  if (fStripsFromCentrePeCut>=stripsFromCentreCut) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on fiducial volume:"<<endl
      <<" stripsFromCentre<"<<stripsFromCentreCut
      <<" (fStripsFromCentrePeCut="<<fStripsFromCentrePeCut<<")"
      <<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnNumHitsPerPlane() const
{
  Bool_t cutThisOne=false;

  Float_t hitsPerPlLowCut=1.7;
  Float_t hitsPerPlCut=2.9;

  if (fNumHitsPerPlane<hitsPerPlLowCut ||
      fNumHitsPerPlane>hitsPerPlCut) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on hits per plane:"
      <<" numHitsPerPlane<"<<hitsPerPlCut<<" and >"<<hitsPerPlLowCut
      <<" (fNumHitsPerPlane="<<fNumHitsPerPlane<<")"<<endl
      <<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnNumHitsPerPlane10() const
{
  Bool_t cutThisOne=false;

  Float_t hitsPerPlPeCut10LowCut=1.1;
  Float_t hitsPerPlPeCut10Cut=2.7;

  if (fNumHitsPerPlanePeCut10<hitsPerPlPeCut10LowCut ||
      fNumHitsPerPlanePeCut10>hitsPerPlPeCut10Cut) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on hits per plane:"
      <<" numHitsPerPlanePeCut10<"<<hitsPerPlPeCut10Cut
      <<" and >"<<hitsPerPlPeCut10LowCut
      <<" (fNumHitsPerPlanePeCut10="<<fNumHitsPerPlanePeCut10<<")"
      <<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnDeadChips() const
{
  Bool_t cutThisOne=false;

  //check if dead chips
  if (fNumDeadChips>0) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on dead chips:"
      <<" numDeadChips="<<fNumDeadChips<<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnBadPedestals(Int_t plane,Int_t strip,
                                     Int_t end) const
{
  //only have bad channels in real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  Bool_t cutThisOne=false;

  //cut out the strips with bad pedestals
  //not sure exactly for which run number the problem was fixed
  //had gone away by 71266
  if (fRunNumber>=70000 && fRunNumber<=70888){
    if ((plane==21 || plane==41) && strip==19) cutThisOne=true;
  }
  else if (fRunNumber>40000 && fRunNumber<60000){
    //cut out the strips with bad pedestals
    if ((plane==21 || plane==41) && strip==19 && end==1){
      cutThisOne=true;
    }
    if ((plane==20 || plane==40) && strip==4 && end==2){
      cutThisOne=true;
    }
  }    
  
  //not sure about this, MK reported it bad
  //in the 30000s and 40000s (i.e. T11) 38,10,2 was bad
  
  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,6)
      <<"Applying cut to bad pedestal channel:"
      <<" (pl="<<plane<<", str="<<strip<<", end="<<end<<")"<<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnBadCalorimetry(Int_t plane,Int_t strip,
                                       Int_t end) const
{
  //only have bad channels in real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  Bool_t cutThisOne=false;

  //cut out the strips with bad calorimetry
  //do this for all run periods to be consistent
  if (fPlane==0 || fPlane==35) cutThisOne=true;
  
  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,6)
      <<"Applying cut to bad calorimetry:"
      <<" (pl="<<plane<<", str="<<strip<<", end="<<end<<")"<<endl;
  }
  
  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnTrackQuality(Bool_t requireGoodTrack) const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //look if a good first plane was found
  //this is a good indication of tracking success
  Bool_t goodFirstPlane=(fFirstPlane>=0 && fFirstPlane<59);
  if (requireGoodTrack){
    if (!goodFirstPlane) cutThisOne=true;
  }

  //don't do this as not necessary for MEU calibration
  //cut on the trackers opinion of what's a good track
  //Bool_t goodInBothViews=(fResultEven==1 && fResultOdd==1);
  //if (requireGoodTrack){
  //  if (!goodInBothViews) cutThisOne=true;
  //}

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut to track quality"<<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnOverlap() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  //if (!fNoOverlap){ //not no overlap=overlap
  //cutThisOne=true;
  //}
  Float_t olChi2Threshold=1.1;
  if (fOLChi2>olChi2Threshold) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on overlap, OLChi2<"<<olChi2Threshold
      <<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnOverlapForElec() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  Float_t olChi2Threshold=1.1;
  if (fOLChi2>olChi2Threshold) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on overlap for elec, OLChi2<"<<olChi2Threshold
      <<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnPidForElec() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  if (fPIDType!=CalDetParticleType::kElectron){ 
    cutThisOne=true;
  }
  if (!fInCERTime){ 
    cutThisOne=true;
  }

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on pid to pass only electrons"<<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutByHandOnPidForElec() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  string particleSelection="for electrons";
  MAXMSG("CDAnalysis",Msg::kInfo,1)
    <<"Applying cut: "<<particleSelection<<endl;

  Bool_t elecKovADC1=false;
  Bool_t elecKovADC3=false;
  Bool_t goodTof=false;
  Bool_t elecInTime=false;

  if (fRunNumber==70579){//a 1 GeV run

    if (fTofTDC2-fTofTDC0>340 && fTofTDC2-fTofTDC0<500) goodTof=true;

    //don't analyse if not a elec
    if (!elecKovADC1) cutThisOne=true;
    if (!elecKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
  }
  else if (fRunNumber==70709){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut: "<<particleSelection<<endl;

    if (fKovADC3>2000 && fKovADC3<3500) elecKovADC3=true;//elec ADC
    if (fKovADC1>1000 && fKovADC1<2500) elecKovADC1=true;
    if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<450) goodTof=true;
    //Tof in time with elec triggering kov
    if ((fTofADCTimeStamp1-fKovTimeStamp3)<-80 &&
        (fTofADCTimeStamp1-fKovTimeStamp3)>-85 &&
        (fTofADCTimeStamp1-fKovTimeStamp1)<-30 &&
        (fTofADCTimeStamp1-fKovTimeStamp1)>-40) elecInTime=true;
    
    //don't analyse if not a elec
    if (!elecKovADC1) cutThisOne=true;
    if (!elecKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
    
    //don't analyse if tof not in time with kov set to elecs
    if (!elecInTime) cutThisOne=true;

  }
  else if (fRunNumber==71266){

  }
  else if (fRunNumber==100131){

  }
  else if (fRunNumber==100161){

    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut: "<<particleSelection<<endl;

    if (fKovADC3>1600 && fKovADC3<2100) elecKovADC3=true;//elec ADC
    if (fKovADC1>1100 && fKovADC1<3100) elecKovADC1=true;
    if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<470) goodTof=true;
    //Tof in time with elec triggering kov
    if ((fTofADCTimeStamp1-fKovTimeStamp3)<-20 &&
        (fTofADCTimeStamp1-fKovTimeStamp3)>-30 &&
        (fTofADCTimeStamp1-fKovTimeStamp1)<-50 &&
        (fTofADCTimeStamp1-fKovTimeStamp1)>-62) elecInTime=true;
    
    //don't analyse if not a elec
    if (!elecKovADC1) cutThisOne=true;
    if (!elecKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
    
    //don't analyse if tof not in time with kov set to elecs
    if (!elecInTime) cutThisOne=true;


  }
  else if (fRunNumber==100243){

    
  }
  else if (fRunNumber==100270){

  }
  
  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying 'by hand' cut on pid to pass only electrons"<<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnPid() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  Bool_t muonOrPion=fPIDType & (CalDetParticleType::kMuon |
                                CalDetParticleType::kPion);

  if (!muonOrPion){ 
    cutThisOne=true;
  }
  if (!fInCERTime){ 
    cutThisOne=true;
  }

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying cut on pid to pass only pions and muons"<<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutByHandOnPid() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //only have pid for real data so return if not data
  if (fSimFlag!=SimFlag::kData) return false;

  Bool_t muonKovADC1=false;
  Bool_t muonKovADC3=false;
  Bool_t goodTof=false;
  Bool_t muonInTime=false;

  if (fRunNumber==70579){//a 1 GeV run
    if (fKovADC3<500) muonKovADC3=true;
    if (fKovADC1<300) muonKovADC1=true;//not an electron ADC
    if (fTofTDC2-fTofTDC0>340 && fTofTDC2-fTofTDC0<500) goodTof=true;

    //don't analyse if not a muon
    if (!muonKovADC1) cutThisOne=true;
    if (!muonKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
  }
  else if (fRunNumber==70709){
    //string particleSelection="muons";
    string particleSelection="notElectrons";
    //string particleSelection="notElectronsNoCkv";

    if (particleSelection=="muons"){
      MAXMSG("CDAnalysis",Msg::kWarning,1)
        <<"Applying cut: "<<particleSelection<<endl;
      
      if (fKovADC3<1400 && fKovADC3>0) muonKovADC3=true;//muon ADC
      if (fKovADC1<500) muonKovADC1=true;//not an electron ADC
      if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<450) goodTof=true;
      //Tof in time with muon triggering kov
      if ((fTofADCTimeStamp1-fKovTimeStamp3)<-78 &&
          (fTofADCTimeStamp1-fKovTimeStamp3)>-96) muonInTime=true;
      
      //don't analyse if not a muon
      if (!muonKovADC1) cutThisOne=true;
      if (!muonKovADC3) cutThisOne=true;
      
      //don't analyse if bad tof
      if (!goodTof) cutThisOne=true;
      
      //don't analyse if tof not in time with kov set to muons
      if (!muonInTime) cutThisOne=true;
    }
    else if (particleSelection=="notElectrons"){
      MAXMSG("CDAnalysis",Msg::kWarning,1)
        <<"Applying cut: "<<particleSelection<<endl;
      
      if (fKovADC3<1400) muonKovADC3=true;//not an electron ADC
      if (fKovADC1<500) muonKovADC1=true;//not an electron ADC
      if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<450) goodTof=true;
      
      //don't analyse if not a muon
      if (!muonKovADC1) cutThisOne=true;
      if (!muonKovADC3) cutThisOne=true;
      
      //don't analyse if bad tof
      if (!goodTof) cutThisOne=true;

      //don't want the muon in time cut
    }
  }
  else if (fRunNumber==71266){
    if (fKovADC3<1400) muonKovADC3=true;//not an electron ADC
    if (fKovADC1<1000) muonKovADC1=true;//not an electron ADC
    if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<450) goodTof=true;

    //don't analyse if not a muon
    if (!muonKovADC1) cutThisOne=true;
    if (!muonKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
  }
  else if (fRunNumber==100131){
    if (fKovADC3<1000) muonKovADC3=true;
    if (fKovADC1<500) muonKovADC1=true;//not an electron ADC
    if (fTofTDC2-fTofTDC0>370 && fTofTDC2-fTofTDC0<525) goodTof=true;

    //don't analyse if not a muon
    if (!muonKovADC1) cutThisOne=true;
    if (!muonKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
  }
  else if (fRunNumber==100161){

    //string particleSelection="muons";
    string particleSelection="notElectrons";
    //string particleSelection="notElectronsNoCkv";

    if (particleSelection=="muons"){
      MAXMSG("CDAnalysis",Msg::kWarning,1)
        <<"Applying cut: "<<particleSelection<<endl;

      if (fKovADC3<850 && fKovADC3>0) muonKovADC3=true;
      if (fKovADC1<400) muonKovADC1=true;//not an electron ADC
      if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<490) goodTof=true;
      //Tof in time with muon triggering kov
      if ((fTofADCTimeStamp1-fKovTimeStamp3)<-24 &&
          (fTofADCTimeStamp1-fKovTimeStamp3)>-45) muonInTime=true;
      
      //don't analyse if not a muon
      if (!muonKovADC1) cutThisOne=true;
      if (!muonKovADC3) cutThisOne=true;
      
      //don't analyse if bad tof
      if (!goodTof) cutThisOne=true;
      
      //don't analyse if tof not in time with kov set to muons
      if (!muonInTime) cutThisOne=true;
    }
    else if (particleSelection=="notElectrons"){
      MAXMSG("CDAnalysis",Msg::kWarning,1)
        <<"Applying cut: "<<particleSelection<<endl;

      if (fKovADC3<850) muonKovADC3=true;
      if (fKovADC1<400) muonKovADC1=true;//not an electron ADC
      if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<490) goodTof=true;

      //don't analyse if not a muon
      if (!muonKovADC1) cutThisOne=true;
      if (!muonKovADC3) cutThisOne=true;
      
      //don't analyse if bad tof
      if (!goodTof) cutThisOne=true;

      //don't want the muon in time cut
    }
    else if (particleSelection=="notElectronsNoCkv"){
      MAXMSG("CDAnalysis",Msg::kWarning,1)
        <<"Applying cut: "<<particleSelection<<endl;

      if (fKovADC3<100) muonKovADC3=true;
      if (fKovADC1<100) muonKovADC1=true;//not an electron ADC
      if (fTofTDC2-fTofTDC0>385 && fTofTDC2-fTofTDC0<490) goodTof=true;

      //don't analyse if not a muon
      if (!muonKovADC1) cutThisOne=true;
      if (!muonKovADC3) cutThisOne=true;
      
      //don't analyse if bad tof
      if (!goodTof) cutThisOne=true;

      //don't want the muon in time cut
    }
  }
  else if (fRunNumber==100243){
    if (fKovADC3<900) muonKovADC3=true;
    if (fKovADC1<1000) muonKovADC1=true;//not an electron ADC
    if (fTofTDC2-fTofTDC0>350 && fTofTDC2-fTofTDC0<490) goodTof=true;

    //don't analyse if not a muon
    if (!muonKovADC1) cutThisOne=true;
    if (!muonKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;
    
  }
  else if (fRunNumber==100270){
    if (fKovADC3<1100) muonKovADC3=true;
    if (fKovADC1<500) muonKovADC1=true;//not an electron ADC
    if (fTofTDC2-fTofTDC0>360 && fTofTDC2-fTofTDC0<525) goodTof=true;

    //don't analyse if not a muon
    if (!muonKovADC1) cutThisOne=true;
    if (!muonKovADC3) cutThisOne=true;
    
    //don't analyse if bad tof
    if (!goodTof) cutThisOne=true;    
  }

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Applying 'by hand' cut on pid"<<endl;
  }

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnScint_TofDiff() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  Float_t lowTime=-1000000;
  Float_t upTime=1000000;
  
  this->GetLowUpTimeCuts(lowTime,upTime);
  
  if (fLowScint_Tof<lowTime || fUpScint_Tof>upTime) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,10)
      <<"Using TOF-scint diff. cut: "
      <<lowTime<<" -> "<<upTime<<" ns"
      <<" (t="<<fLowScint_Tof<<" -> "<<fUpScint_Tof<<" ns)"
      <<endl;
  }

  return cutThisOne;
}

//......................................................................

void CDAnalysis::GetLowUpTimeCuts(Float_t& lowTime,
                                  Float_t& upTime) const
{
  //this works in ns rather naughtily!
  lowTime=-1000000;
  upTime=1000000;

  Int_t run=fRunNumber;

  //set the time gate here so that you get the same for each run 
  //period
  Int_t lowTimeLimit=35;
  Int_t upTimeLimit=295;
  Int_t peak=-1;
  
  //only have timing issues for real data
  if (fSimFlag==SimFlag::kData) {
    if (run>=40000 && run<50000){
      //just for interest: the peak is 180 ns into the 600 ns varc gate
      peak=-125;//ns
      lowTime=peak-lowTimeLimit;//was -175;
      upTime=peak+upTimeLimit;//was 135;
    }
    else if (run>=50000 && run<60000){
      //just for interest: the peak is 280 ns into the 600 ns varc gate
      peak=30;//ns
      lowTime=peak-lowTimeLimit;
      upTime=peak+upTimeLimit;
    }
    else if (run>=70000 && run<80000){
      //just for interest: the peak is 220 ns into the 600 ns varc gate
      peak=5;//ns
      lowTime=peak-lowTimeLimit;//-30;//-50;
      upTime=peak+upTimeLimit;//300;//260;
    }
    else{
      MAXMSG("CDAnalysis",Msg::kInfo,10)
        <<"No time cuts cut for this run="<<fRunNumber<<endl;
    }
  }
  else{
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"MC data so no sensible timing cuts to set"<<endl;
  }

  MAXMSG("CDAnalysis",Msg::kInfo,1)
    <<"Set time cuts:  low="<<lowTime<<" ns, upper="<<upTime<<" ns"
    <<endl;
}

//......................................................................

Bool_t CDAnalysis::CutOnEventLengthForElec() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  //Int_t minPlane=0;
  Int_t maxPlane=20;

  //old cut
  //if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;

  //new cut - number of planes hit allows for a noise hit in the
  //back of the detector but will cut out muons sucessfully
  Int_t numPlanes=fNumPlanesHitAll.size();
  if (numPlanes>maxPlane) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Using event length cuts for electrons: "
      <<"Num hit planes<="<<maxPlane<<endl;
  }

  return cutThisOne;
}

//......................................................................

void CDAnalysis::GetEvLenMinMax(Int_t& minPlane,Int_t& maxPlane) const
{
  //I don't understand abs. Sometimes it just returns an int!!
  //e.g. in a root macro
  Float_t aBeamP=fabs(fBeamMomentum);
  
  //new cuts are now inclusive so it's 31<=Pl<=45

  if (fabs(fBeamMomentum)>1.3 && fabs(fBeamMomentum)<1.5){
    minPlane=31;//minPlane=35;
    maxPlane=45;//maxPlane=44;
  }
  else if (fabs(fBeamMomentum)>1.5 && fabs(fBeamMomentum)<1.7){
    minPlane=35;//minPlane=40;
    maxPlane=51;//maxPlane=49;
  }
  else if (fabs(fBeamMomentum)>1.7 && fabs(fBeamMomentum)<1.9){
    minPlane=39;//minPlane=42;
    maxPlane=56;//maxPlane=57;
  }
  else if (fabs(fBeamMomentum)>1.9){
    minPlane=44;//minPlane=44;
    maxPlane=57;//maxPlane=58;
  }
  else{
    MAXMSG("CDAnalysis",Msg::kInfo,10)
      <<"No event length cut for this particle energy="
      <<fBeamMomentum<<endl;
    assert(false);
  }
  MAXMSG("CDAnalysis",Msg::kInfo,1)
    <<"Set Ev. Len min="<<minPlane<<", max="<<maxPlane
    <<", aBeamP="<<aBeamP<<endl;
}

//......................................................................

Bool_t CDAnalysis::CutOnNumPlanesHit(Int_t planesHit) const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  Int_t minPlane=0;
  Int_t maxPlane=60;

  this->GetEvLenMinMax(minPlane,maxPlane);

  //new cuts are now inclusive so it's 31<=Pl<=45
  if (planesHit<minPlane || planesHit>maxPlane) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Using num planes hit cut to pass muons: "
      <<minPlane<<"<=Plane<="<<maxPlane
      <<", fBeamMomentum="<<fBeamMomentum<<endl;
  }

  MSG("CDAnalysis",Msg::kDebug)
    <<"fLastPlane="<<fLastPlane<<", cut this one="<<cutThisOne<<endl;

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutOnPSMuons() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  if (fAvStrip<9|| fAvStrip>13){
    cutThisOne=true;
  }

  return cutThisOne;
}

//......................................................................

Int_t CDAnalysis::GetEventLength() const
{
  Int_t lastPlane=fLastPlane;
  
  //if there was no track then a last plane is not found
  //in this case use the number of planes hit
  //this will be fairly rare for muons
  if (lastPlane==-1) {
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"GetEventLength::Using num planes hit in event length:"
      <<" fLastPlane="<<fLastPlane
      <<", numPlanesHit="<<fNumPlanesHitAll.size()<<endl;
    lastPlane=fNumPlanesHitAll.size();
  }
  
  return lastPlane;
}

//......................................................................

Bool_t CDAnalysis::CutOnEventLength() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  Int_t lastPlane=this->GetEventLength();
  
  Int_t minPlane=0;
  Int_t maxPlane=60;
  this->GetEvLenMinMax(minPlane,maxPlane);

  //new cuts are now inclusive so it's 31<=Pl<=45
  if (lastPlane<minPlane || lastPlane>maxPlane) cutThisOne=true;

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Using event length cuts to pass muons: "
      <<minPlane<<"<=Plane<="<<maxPlane
      <<" (lastPlane="<<lastPlane<<")"
      <<", fBeamMomentum="<<fBeamMomentum<<endl;
  }

  MSG("CDAnalysis",Msg::kDebug)
    <<"fLastPlane="<<fLastPlane<<", cut this one="<<cutThisOne<<endl;

  return cutThisOne;
}

//......................................................................

Bool_t CDAnalysis::CutByHandOnEventLength() const
{
  //set default to not cut
  Bool_t cutThisOne=false;

  Int_t minPlane=0;
  Int_t maxPlane=60;

  if (fSimFlag==SimFlag::kData){
    
    //might want to tighten these up to boost the signal to noise ratio
    
    if (fRunNumber==70709 ||
        fRunNumber==71266 ||
        fRunNumber==100161 ||
        fRunNumber==100270){//1.8
      //cut out through going muons, no 58,59
      minPlane=42;
      maxPlane=57;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fRunNumber==100243){//1.6
      minPlane=40;
      maxPlane=49;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fRunNumber==100131){//1.4
      minPlane=35;
      maxPlane=44;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fRunNumber==70579){//1.0 GeV run
      //hack - these are 1.8 cuts
      if (fLastPlane<42 || fLastPlane>57) cutThisOne=true;
    }
  }
  else if (fSimFlag==SimFlag::kMC){
    
    if (fMainParticleEnergy>1.3 && fMainParticleEnergy<1.5){
      minPlane=35;
      maxPlane=44;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fMainParticleEnergy>1.5 && fMainParticleEnergy<1.7){
      minPlane=40;
      maxPlane=49;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fMainParticleEnergy>1.7 && fMainParticleEnergy<1.9){
      minPlane=42;
      maxPlane=57;
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else if (fMainParticleEnergy>1.9){
      minPlane=44;
      maxPlane=58;//last but one, so didn't exit
      if (fLastPlane<minPlane || fLastPlane>maxPlane) cutThisOne=true;
    }
    else{
      MAXMSG("CDAnalysis",Msg::kInfo,10)
        <<"No event length cut for this particle energy="
        <<fMainParticleEnergy<<endl;
    }
  }

  if (cutThisOne){
    MAXMSG("CDAnalysis",Msg::kInfo,1)
      <<"Using 'by hand' event length cuts to pass muons: "
      <<minPlane<<"<Plane<"<<maxPlane
      <<", fBeamMomentum="<<fBeamMomentum<<endl;
  }

  MSG("CDAnalysis",Msg::kDebug)
    <<"fLastPlane="<<fLastPlane<<", cut this one="<<cutThisOne<<endl;

  return cutThisOne;
}

//......................................................................

void CDAnalysis::FillProfHisto(TProfile* prof,
                               std::map<Int_t,Float_t>& counter,
                               const std::map<Int_t,Float_t>& addMe,
                               Int_t offset) const
{
  if (prof){
    for (map<Int_t,Float_t>::const_iterator it=addMe.begin();
         it!=addMe.end();++it){
      Int_t key=it->first;
      if (offset!=0) key=offset-(it->first);

      prof->Fill(key,it->second);
      counter[key]++;
    }
  }
  else{
    MSG("CDAnalysis",Msg::kWarning)
      <<"TProfile not initialised"<<endl;
  }
}

//......................................................................

Bool_t CDAnalysis::IsPlaneXTalkOnly(Int_t inplane) const
{
  if (!fTruthHitInfo) return false;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Int_t sumTruth=DigiSignal::kUnknown;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();

    if (plane!=inplane) continue;

    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();

    //add up the bits
    sumTruth|=pmtTruth1;
    sumTruth|=pmtTruth2;

    MSG("CDAnalysis",Msg::kVerbose)
      <<"sumTruth="<<sumTruth<<endl;
  }

  //check if genuine or not
  Bool_t genuineBit=((sumTruth & DigiSignal::kGenuine)==
                     DigiSignal::kGenuine);
  Bool_t optXTalkBit=((sumTruth & DigiSignal::kCrosstalkOptical)==
                      DigiSignal::kCrosstalkOptical);
  Bool_t xTalkBit=((sumTruth & DigiSignal::kCrosstalk)==
                   DigiSignal::kCrosstalk);
  
  if (genuineBit || sumTruth==0) return false;
  else if (optXTalkBit) return true;
  else if (xTalkBit) return true;
  else return false;
}

//......................................................................

Bool_t CDAnalysis::IsPlaneGenuine(Int_t inplane) const
{
  if (!fTruthHitInfo) return true;

  MAXMSG("CDAnalysis",Msg::kInfo,1)
    <<"Running IsPlaneGenuine(), fTruthHitInfo="<<fTruthHitInfo<<endl;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Int_t sumTruth=DigiSignal::kUnknown;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();

    if (plane!=inplane) continue;

    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();

    //add up the bits
    sumTruth|=pmtTruth1;
    sumTruth|=pmtTruth2;

    MSG("CDAnalysis",Msg::kVerbose)
      <<"sumTruth="<<sumTruth<<endl;
  }

  //check if genuine or not
  Bool_t genuineBit=((sumTruth & DigiSignal::kGenuine)==
                     DigiSignal::kGenuine);
  
  if (genuineBit) return true;
  else return false;
}

//......................................................................

Bool_t CDAnalysis::IsSharedPmtHit(Int_t inplane) const
{
  if (!fTruthHitInfo) return true;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Bool_t sharedPmtHit=false;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    
    if (plane!=inplane) continue;
    
    Int_t vaChip1=hitInfo->GetVaChip1();
    Int_t vaChip2=hitInfo->GetVaChip2();

    if (vaChip1==1 || vaChip2==1) sharedPmtHit=true;

    MSG("CDAnalysis",Msg::kVerbose)
      <<"sharedPmtHit="<<sharedPmtHit<<endl;
  }

  return sharedPmtHit;
}

//......................................................................

Bool_t CDAnalysis::IsPlaneSideHit(Int_t inplane,Int_t stripEnd) const
{
  if (!fTruthHitInfo) return true;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Bool_t planeSideHit=false;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    
    if (plane!=inplane) continue;

    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();
    

    if (pmtTruth1 && stripEnd==StripEnd::kEast){
      planeSideHit=true;
      break;//only need the one hit
    }
    if (pmtTruth2 && stripEnd==StripEnd::kWest){
      planeSideHit=true;
      break;//only need the one hit
    }
  }

  MSG("CDAnalysis",Msg::kVerbose)
    <<"planeSideHit="<<planeSideHit<<endl;

  return planeSideHit;
}

//......................................................................

Bool_t CDAnalysis::IsDoubleEnded(Int_t inplane) const
{
  if (!fTruthHitInfo) return true;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Bool_t doubleEnded=false;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    
    if (plane!=inplane) continue;
    
    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();

    if (pmtTruth1 && pmtTruth2) doubleEnded=true;

    MSG("CDAnalysis",Msg::kVerbose)
      <<"doubleEnded="<<doubleEnded<<endl;
  }

  return doubleEnded;
}

//......................................................................

Bool_t CDAnalysis::IsGenuineOrXTalk(Int_t inplane) const
{
  if (!fTruthHitInfo) return true;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Int_t sumTruth=DigiSignal::kUnknown;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    
    if (plane!=inplane) continue;
    
    Int_t pmtTruth1=hitInfo->GetPmtTruth1();
    Int_t pmtTruth2=hitInfo->GetPmtTruth2();

    //add up the bits
    sumTruth|=pmtTruth1;
    sumTruth|=pmtTruth2;
  }
  
  MSG("CDAnalysis",Msg::kVerbose)
    <<"sumTruth(GenOrXTalk)="<<sumTruth<<endl;

  Bool_t genuineBit=((sumTruth & DigiSignal::kGenuine)==
                     DigiSignal::kGenuine);
  Bool_t optXTalkBit=((sumTruth & DigiSignal::kCrosstalkOptical)==
                      DigiSignal::kCrosstalkOptical);
  Bool_t xTalkBit=((sumTruth & DigiSignal::kCrosstalk)==
                   DigiSignal::kCrosstalk);

  if (genuineBit || optXTalkBit) return true;
  else if (xTalkBit){
    MSG("CDAnalysis",Msg::kDebug)
      <<" **** Only non-optXTalk, sumTruth="<<sumTruth<<endl;
    return false;
  }
  else{
    MSG("CDAnalysis",Msg::kDebug)
      <<"Not genuine or xtalk, sumTruth="<<sumTruth<<endl;
    return false;
  }
}

//......................................................................

Bool_t CDAnalysis::StraightTrack_Radius(Double_t radiusCut) const
{
  //check if positive
  if (radiusCut<0) radiusCut=radiusCut-2*radiusCut;
  
  //set default return value to true
  Bool_t straight=true;

  //get tclones arrays for this snarl
  TClonesArray &cTrk=*fTrkHitInfo;
  Int_t numTrkHits=fTrkHitInfo->GetEntries();
  
  for (Int_t hit=0;hit<numTrkHits;hit++){
    CDTrackedHitInfo *trackedHitInfo=
      dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
    
    Int_t strip=trackedHitInfo->GetStrip();
    Double_t transPos=trackedHitInfo->GetTransPos();

    //calc dist to plane centre
    Float_t radius=this->CalcDistToPlaneCentre(strip,transPos);

    //test for straight tracks
    if (radius>radiusCut){
      straight=false;
      break;
    } 
  }

  //return result
  return straight;
}

//......................................................................

Bool_t CDAnalysis::IsStraightTrack_Radius(Double_t radiusCut) const
{
  if (!fTruthHitInfo) return true;

  //this method will get called once per event so use event to satisfy
  //the TrueXInStripFrame method used below
  //bit of a hack but it should work fine
  static Int_t event=0;
  event++;

  //check if positive
  if (radiusCut<0) radiusCut=radiusCut-2*radiusCut;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  //set default return value to true
  Bool_t straight=true;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t mainParticle=hitInfo->GetMainParticle();
    Int_t plane=hitInfo->GetPlane();
    Int_t strip=hitInfo->GetStrip();
    Int_t muon=13;

    if (abs(mainParticle)!=muon) continue;

    Float_t trueX=this->TrueXInStripFrame(plane,strip,event);   
    Float_t radiusTrue=this->TrueDistToPlaneCentre(strip,trueX);
    MAXMSG("CDAnalysis",Msg::kVerbose,300)
      <<"trueX="<<trueX<<", trueRadius="<<radiusTrue
      <<", striaght="<<straight<<", radiusCut="<<radiusCut<<endl;

    //test for straight tracks
    if (radiusTrue>radiusCut){
      straight=false;
      break;
    }
  }

  MAXMSG("CDAnalysis",Msg::kVerbose,100)
    <<"Returning straight="<<straight<<endl;

  //return result
  return straight;
}

//......................................................................

Bool_t CDAnalysis::IsStraightTrack(Double_t mainX1Cut) const
{
  if (!fTruthHitInfo) return true;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  //set default return value to true
  Bool_t straight=true;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t mainParticle=hitInfo->GetMainParticle();
    Double_t mainX1=hitInfo->GetMainX1();
    Int_t muon=13;

    //test for straight tracks
    if (abs(mainParticle)==muon && 
        (mainX1>mainX1Cut || mainX1<-1*mainX1Cut)){
      straight=false;
      break;
    }
  }

  //return result
  return straight;
}

//......................................................................

Int_t CDAnalysis::TrueMuonHunter(Int_t event)
{
  if (!fTruthHitInfo) return -1;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  Bool_t foundFirstMuon=false;
  Int_t firstMuonPlane=-1;

  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Int_t plane=hitInfo->GetPlane();
    Double_t enDep=hitInfo->GetTotalEnDep();
    //Double_t earliestT1=hitInfo->GetEarliestT1();
    Int_t mainParticle=hitInfo->GetMainParticle();
    Double_t mainPartEn=hitInfo->GetMainPartEn();
    Int_t muon=13;

    if (abs(mainParticle)==muon){
      
      if (!foundFirstMuon){
        MSG("CDAnalysis",Msg::kInfo)
          <<"Event="<<event<<": First plane with muon="<<plane<<endl;
        firstMuonPlane=plane;
        foundFirstMuon=true;
      }

      if (plane>32){
        MSG("CDAnalysis",Msg::kInfo)
          <<"Plane="<<plane<<", enDep="<<enDep
          <<", muon energy="<<mainPartEn<<endl;
      }
    }

  }

  return firstMuonPlane;
}

//......................................................................

Float_t CDAnalysis::TrueXInStripFrame(Int_t plane,Int_t strip,
                                      Int_t event) const
{
  if (!fTruthHitInfo) return -1;

  static Int_t lastEvent=-1;
  static map<Int_t,Double_t> trueX;
  static map<Int_t,Int_t> counter;
  Int_t inStripKey=500*plane+strip;

  //if a new event then have to rebuild the map of x
  //as a function of globalstrip key
  if (event!=lastEvent){
    //set the lastevent
    lastEvent=event;

    //clear the map
    trueX.clear();
    counter.clear();

    //now build the new map for this event

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t pmtTruth1=hitInfo->GetPmtTruth1();
      Int_t pmtTruth2=hitInfo->GetPmtTruth2();
      Int_t sumTruth=0;
      
      //add up the bits
      sumTruth|=pmtTruth1;
      sumTruth|=pmtTruth2;

      //check if genuine bit is set
      Bool_t genuineBit=((sumTruth & DigiSignal::kGenuine)==
                         DigiSignal::kGenuine);

      //if not genuine then skip this strip
      if (!genuineBit) {
        continue;
      }

      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();
      Int_t stripKey=500*plane+strip;

      Double_t mainX1=hitInfo->GetMainX1();
      Double_t mainX2=hitInfo->GetMainX2();
      Double_t avX=(mainX1+mainX2)*0.5;

      if (avX==0){
        MSG("CDAnalysis",Msg::kDebug)
          <<"CDAnalysis::TrueXInStripFrame::average x="<<avX
          <<", enDep="<<hitInfo->GetTotalEnDep()<<endl;
      }

      trueX[stripKey]=avX;
      counter[stripKey]++;
    }
  }

  if (counter[inStripKey]>0) return trueX[inStripKey];
  else return -1;
}

//......................................................................

Double_t CDAnalysis::TrueEnDep(Int_t inplane,Int_t event) const
{
  if (!fTruthHitInfo) return 0;

  static Int_t lastEvent=-1;
  static map<Int_t,Double_t> plEnDep;

  //if a new event then have to rebuild the map of energy dep
  //as a function of plane
  if (event!=lastEvent){
    //set the lastevent
    lastEvent=event;

    //clear the map
    plEnDep.clear();

    //now build the new map for this event

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Double_t enDep=hitInfo->GetTotalEnDep();
      //Double_t earliestT1=hitInfo->GetEarliestT1();

      //cut out the decay electron
      //if (earliestT1>15e-9) continue;

      plEnDep[plane]+=enDep;
    }
  }

  return plEnDep[inplane];
}

//......................................................................

Double_t CDAnalysis::TrueMainPL(Int_t inplane,Int_t event) const
{
  if (!fTruthHitInfo) return 0;

  static Int_t lastEvent=-1;
  static map<Int_t,Double_t> plPL;
  //static map<Int_t,Int_t> plStrip;

  //if a new event then have to rebuild the map of energy dep
  //as a function of plane
  if (event!=lastEvent){
    MAXMSG("CDAnalysis",Msg::kDebug,50)
      <<"Building map..."<<endl;
    //set the lastevent
    lastEvent=event;

    //clear the map
    plPL.clear();
    //plStrip.clear();

    //now build the new map for this event

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();
      Double_t pathLen=hitInfo->GetMainPathLength();
      Int_t particle=hitInfo->GetMainParticle();
      Int_t muon=13;

      if (abs(particle)!=muon) {
        MAXMSG("CDAnalysis",Msg::kDebug,100)
          <<"Not a muon so ignoring..."<<endl;
        continue;
      }

      MAXMSG("CDAnalysis",Msg::kDebug,500)
        <<"plane="<<plane//<<", lastSt="<<plStrip[plane]
        <<" (currSt="<<strip<<")"<<", lastPL="<<plPL[plane]*100
        <<", currentPL="<<pathLen*100<<endl;
      plPL[plane]+=pathLen;
      //plStrip[plane]=strip;
    }
    MAXMSG("CDAnalysis",Msg::kDebug,50)
      <<"Finished building map"<<endl;
  }

  return plPL[inplane];
}

//......................................................................

Double_t CDAnalysis::GetMainParticleEnergy() const
{
  if (!fTruthHitInfo) return 0;

  Double_t mainEnergy=0;

  TClonesArray &cTruth = *fTruthHitInfo;
  Int_t numTruthHits=fTruthHitInfo->GetEntries();
  
  //loop over the truth hits
  for (Int_t hit=0;hit<numTruthHits;hit++){
    //cast the tclonesarray up to a truthhitinfo object
    CDTruthHitInfo *hitInfo=
      dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
    Double_t en=hitInfo->GetMainPartEn();

    MSG("CDAnalysis",Msg::kDebug)
      <<"en="<<en<<endl;

    //find the greatest energy
    if (en>mainEnergy) {
      mainEnergy=en;
      MSG("CDAnalysis",Msg::kDebug)
        <<"mainEnergy="<<mainEnergy<<endl;
    }
  }
 
  return mainEnergy;
}

//......................................................................

Double_t CDAnalysis::GetGreatestMainParticleEnergy(Int_t nEvents) const
{
  Double_t mainEnergy=0;

  if (nEvents>fEvents) nEvents=fEvents;

  for(Int_t event=0;event<nEvents;event++){
    
    //get the snarl/event
    fTrackerTree->GetEvent(event); 
    
    Double_t mEn=this->GetMainParticleEnergy();
    
    //select the greatest one
    if (mEn>mainEnergy) mainEnergy=mEn;
  }

  return mainEnergy;
}

//......................................................................

Double_t CDAnalysis::CalcMeuPLCorrected(std::map<Int_t,Float_t> plEnDep,
                                        std::map<Int_t,Float_t> plPLCor,
                                        Int_t event,
                                        Float_t* GeVPerMeu
                                        ) const
{
  if (plEnDep.size()==0 || plPLCor.size()==0){
    MAXMSG("CDAnalysis",Msg::kWarning,10000)
      <<"Can't CalcMeuPLCorrected, map has size zero"<<endl;
    return -1;
  }

  Float_t local14_16=0;
  Float_t localSigCor=0;//for calc meu without fractions of planes
  Float_t localEnDep=0;//for calc meu without fractions of planes
  Int_t plCounter=0;
  Float_t initValue=-999;
  Float_t materialFromTrkEnd=0;
  Float_t materialInWindow=0;
  const Float_t material01Pl=(2.5+1)*Munits::cm;
  const Float_t material16Pl=16*material01Pl;
  const Float_t material14Pl=14*material01Pl;
  MAXMSG("CDAnalysis",Msg::kInfo,1)
    <<"Using 14 pls material="<<material14Pl
    <<", 16 plns="<<material16Pl
    <<", 1 plns="<<material01Pl<<endl;

  Int_t endPlane=this->GetEventLength();

  //calculate energy deposition in the window
  if (endPlane>=0){
    MAXMSG("CDAnalysis",Msg::kDebug,100)
      <<"Analysing track window, vtxPl=0"
      <<", endPl="<<endPlane<<endl;
    
    //loop over the track
    Int_t pl=endPlane;
    while (pl!=0){
      
      Float_t pathLengthCor=initValue;
      pathLengthCor=plPLCor[pl];
      if (pathLengthCor<1){
        MAXMSG("CDAnalysis",Msg::kWarning,1000)
          <<"pl="<<pl<<", endPlane="<<endPlane
          <<", path len cor wrong="<<pathLengthCor<<endl;
        //set default to 1
        pathLengthCor=1;
      }

      //sum up energy in window
      if ((materialFromTrkEnd+
           pathLengthCor*material01Pl)>material16Pl && 
          //check if window starts within or before this plane
          //&& that don't already have whole window of material
          materialInWindow<material14Pl){

        //alternatively start window after the plane in which 
        //the window should officially start part way through
        //if (materialFromTrkEnd>material16Pl && 
        //materialInWindow<material14Pl){
        
        //work out meu without using a fraction of a plane
        Float_t plCorEnDep=0;
        if (pathLengthCor) plCorEnDep=plEnDep[pl]/pathLengthCor;
        localSigCor+=plCorEnDep;
        plCounter++;
        //do it for the true en dep as well
        Float_t trueEnDep=this->TrueEnDep(pl,event);
        MAXMSG("CDAnalysis",Msg::kInfo,100)
          <<"trueEnDep="<<trueEnDep
          <<", PLCor="<<pathLengthCor
          <<", sum="<<localEnDep<<endl;
        if (pathLengthCor) trueEnDep/=pathLengthCor;
        localEnDep+=trueEnDep;

        //check if adding this much energy takes you over
        //the required amount of material
        if (materialInWindow+pathLengthCor*material01Pl>material14Pl){

          Float_t materialNeeded=material14Pl-materialInWindow;
          //calc the fraction of material/energy needed from this plane
          Float_t fractNeeded=materialNeeded/
            (pathLengthCor*material01Pl);
          
          MAXMSG("CDAnalysis",Msg::kDebug,100)
            <<"Last Chunk: matNeed="<<materialNeeded
            <<", matPl="<<pathLengthCor*material01Pl
            <<", 14Pl="<<material14Pl
            <<", matWin="<<materialInWindow
            <<", matTrk="<<materialFromTrkEnd<<endl
            <<"fractNeeded="<<fractNeeded<<", en in plane="<<plEnDep[pl]
            <<", en used="<<fractNeeded*plEnDep[pl]<<endl;

          //increment the material in window
          materialInWindow+=fractNeeded*(pathLengthCor*material01Pl);

          //add the required fraction of energy in this plane to
          //the total
          local14_16+=fractNeeded*plEnDep[pl];
        }
        else{
          //add the energy in this plane to the total
          materialInWindow+=pathLengthCor*material01Pl;

          MAXMSG("CDAnalysis",Msg::kDebug,500)
            <<"Window:p="<<pl
            <<", matPl="<<pathLengthCor*material01Pl
            <<", matWin="<<materialInWindow
            <<", matTrk="<<materialFromTrkEnd
            <<", plEn="<<plEnDep[pl]
            <<endl;

          //increment the energy deposited
          local14_16+=plEnDep[pl];
        }
      }

      MAXMSG("CDAnalysis",Msg::kDebug,1000)
        <<"local: matPl="<<pathLengthCor*material01Pl
        <<", matTrk="<<materialFromTrkEnd
        <<", matWin="<<materialInWindow<<", sumEnDep="<<local14_16
        <<"PLCor="<<pathLengthCor
        <<endl;

      //sum up material traversed
      if (pathLengthCor>0) materialFromTrkEnd+=pathLengthCor*
                             material01Pl;
      else {
        MAXMSG("CDAnalysis",Msg::kInfo,1000)
          <<"Ahhh path len cor wrong="<<pathLengthCor<<endl;
      }

      //increment the plane
      pl--;
    }
  }

  Float_t winSigCor=0;
  if (plCounter){
    winSigCor=localSigCor/plCounter;
    localEnDep/=plCounter;
    //set the output variable
    if (GeVPerMeu) *GeVPerMeu=localEnDep;
  }

  //meu from fraction of last plane in window
  local14_16/=14;

  //decide which to use
  Float_t meu=local14_16;
  Bool_t useNoFraction=true;
  if (useNoFraction) meu=winSigCor;

  //calc fraction of material in window actually obtained
  Float_t fractWin=materialInWindow/material14Pl;
  
  MAXMSG("CDAnalysis",Msg::kInfo,500)
    <<"14_16="<<local14_16<<", winSigCor="<<winSigCor
    <<", plCounter="<<plCounter<<", fractWin="<<fractWin<<endl;

  //don't return meu when only a fraction of window was obtained
  if (fractWin<1) meu=-1;

  return meu;
}

//......................................................................

void CDAnalysis::FillEnVsDist(std::map<Int_t,Float_t> plEnDep,
                              std::map<Int_t,Float_t> plPLCor,
                              Int_t event) const
{
  if (plEnDep.size()==0 || plPLCor.size()==0){
    MAXMSG("CDAnalysis",Msg::kWarning,10000)
      <<"Can't FillEnVsDist, map has size zero"<<endl;
    return;
  }

  Float_t materialFromTrkEnd=0;
  Float_t trueMaterialFromTrkEnd=0;
  Int_t planesFromTrkEnd=0;
  const Float_t material01Pl=(5.94)*Munits::cm;//including air gap
  Float_t initValue=-999;
  
  
  //static Int_t event=-999;
  map<Int_t,Float_t> truePLCor;
  this->TruePLCor(truePLCor,event);
  //event++;

  static TProfile* pEnVsDist=0;
  static TProfile* pEnVsDistAll=0;
  static TProfile* pEnVsDistAll2=0;
  static TProfile* pEnVsDist0=0;
  static TProfile* pTrueEnVsDist0=0;
  static TProfile* pTrueEnPLCVsDist0=0;
  static TProfile* pTrueEnPLCVsDist0270=0;
  static TProfile* pTrueEnPLCVsDist0290=0;
  static TProfile* pTrueEnPLCVsDist0310=0;
  static TProfile* pEnVsPlane0=0;
  static TProfile* pTrueEnVsPlane0=0;
  static TProfile* pEnVsDistNoEnd=0;
  static TProfile* pEnVsDistNoEnd4951=0;
  static TProfile* pEnVsDistNoEnd40=0;
  static TProfile* pEnVsDistNoEnd250=0;
  static TProfile* pEnVsDistNoEnd270=0;
  static TProfile* pEnVsDistNoEnd290=0;
  static TProfile* pEnVsDistNoEnd290a=0;
  static TProfile* pEnVsDistNoEnd290b=0;
  static TProfile* pEnVsDistNoEnd310=0;
  static TProfile* pEnVsDistNoEndTrue=0;
  static TProfile* pEnVsDistNoEndTrue2=0;
  static TProfile* pPLCorVsPlane290=0;
  static TProfile* pPLCorVsPlaneTrue=0;
  static TH1F* hMatFromTrkEnd=0;
  static TH1F* hMatFromTrkEndTrue=0;
  static TH1F* hSigCorPLC=0;

  static vector<TH1F*> meuSigCorNoPLCorHistos(60);
  static vector<TH1F*> meuSigCorPLCorHistos(60);
  static vector<TH1F*> meuSigCorNoPLCorPerpHistos(60);
  static vector<TH1F*> meuSigCorPLCorPerpHistos(60);
  static vector<TH1F*> meuSigCorNoPLCorZerosHistos(60);
  static vector<TH1F*> meuSigCorPLCorZerosHistos(60);

  if (pEnVsDist==0) {
    pEnVsDist=new TProfile("pEnVsDist","pEnVsDist",60,0,
                           (60*material01Pl)/Munits::cm);
    pEnVsDistAll=new TProfile("pEnVsDistAll","pEnVsDistAll",60,0,
                              (60*material01Pl)/Munits::cm);
    pEnVsDistAll2=new TProfile("pEnVsDistAll2","pEnVsDistAll2",60,0,
                               (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd=new TProfile("pEnVsDistNoEnd","pEnVsDistNoEnd",60,0,
                                (60*material01Pl)/Munits::cm);
    pEnVsDist0=new TProfile("pEnVsDist0","pEnVsDist0",60,0,
                            (60*material01Pl)/Munits::cm);
    pEnVsPlane0=new TProfile("pEnVsPlane0","pEnVsPlane0",60,0,60);
    pTrueEnVsDist0=new TProfile("pTrueEnVsDist0","pTrueEnVsDist0",60,0,
                                (60*material01Pl)/Munits::cm);
    pTrueEnPLCVsDist0=new TProfile("pTrueEnPLCVsDist0",
                                   "pTrueEnPLCVsDist0",
                                   60,0,(60*material01Pl)/Munits::cm);
    pTrueEnPLCVsDist0270=new TProfile("pTrueEnPLCVsDist0270",
                                   "pTrueEnPLCVsDist0270",
                                   60,0,(60*material01Pl)/Munits::cm);
    pTrueEnPLCVsDist0290=new TProfile("pTrueEnPLCVsDist0290",
                                   "pTrueEnPLCVsDist0290",
                                   60,0,(60*material01Pl)/Munits::cm);
    pTrueEnPLCVsDist0310=new TProfile("pTrueEnPLCVsDist0310",
                                   "pTrueEnPLCVsDist0310",
                                   60,0,(60*material01Pl)/Munits::cm);
    pTrueEnVsPlane0=new TProfile("pTrueEnVsPlane0","pTrueEnVsPlane0",
                                 60,0,60);
    pEnVsDistNoEnd4951=new TProfile("pEnVsDistNoEnd4951",
                                    "pEnVsDistNoEnd4951",60,0,
                                    (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd40=new TProfile("pEnVsDistNoEnd40",
                                  "pEnVsDistNoEnd40",60,0,
                                  (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd250=new TProfile("pEnVsDistNoEnd250",
                                   "pEnVsDistNoEnd250",60,0,
                                   (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd270=new TProfile("pEnVsDistNoEnd270",
                                   "pEnVsDistNoEnd270",60,0,
                                   (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd290=new TProfile("pEnVsDistNoEnd290",
                                   "pEnVsDistNoEnd290",60,0,
                                   (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd290a=new TProfile("pEnVsDistNoEnd290a",
                                   "pEnVsDistNoEnd290a",60,0,
                                  (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd290b=new TProfile("pEnVsDistNoEnd290b",
                                   "pEnVsDistNoEnd290b",60,0,
                                  (60*material01Pl)/Munits::cm);
    pEnVsDistNoEnd310=new TProfile("pEnVsDistNoEnd310",
                                   "pEnVsDistNoEnd310",60,0,
                                   (60*material01Pl)/Munits::cm);
    pEnVsDistNoEndTrue=new TProfile("pEnVsDistNoEndTrue",
                                    "pEnVsDistNoEndTrue",60,0,
                                    (60*material01Pl)/Munits::cm);
    pEnVsDistNoEndTrue2=new TProfile("pEnVsDistNoEndTrue2",
                                     "pEnVsDistNoEndTrue2",60,0,
                                     (60*material01Pl)/Munits::cm);
    hMatFromTrkEnd=new TH1F("hMatFromTrkEnd","hMatFromTrkEnd",200,0,4);
    hMatFromTrkEndTrue=new TH1F("hMatFromTrkEndTrue",
                                "hMatFromTrkEndTrue",200,0,4);
    hSigCorPLC=new TH1F("hSigCorPLC","hSigCorPLC",5000,-100,20000);
    pPLCorVsPlane290=new TProfile("pPLCorVsPlane290",
                                  "pPLCorVsPlane290",60,0,60);
    pPLCorVsPlaneTrue=new TProfile("pPLCorVsPlaneTrue",
                                   "pPLCorVsPlaneTrue",60,0,60);

    for (Int_t i=0;i<60;i++){
      string sNameSigCorNoPLCor="hMeuSigCorNoPLCorPlane";
      string sNameSigCorPLCor="hMeuSigCorPLCorPlane";
      string sNameSigCorNoPLCorPerp="hMeuSigCorNoPLCorPerpPlane";
      string sNameSigCorPLCorPerp="hMeuSigCorPLCorPerpPlane";
      string sNameSigCorNoPLCorZeros="hMeuSigCorNoPLCorZerosPlane";
      string sNameSigCorPLCorZeros="hMeuSigCorPLCorZerosPlane";
      //string sNameAdc="hAdcNoPLCorPlane";
      string sNum=Form("%d",i);
      sNameSigCorNoPLCor+=sNum;
      sNameSigCorPLCor+=sNum;
      sNameSigCorNoPLCorPerp+=sNum;
      sNameSigCorPLCorPerp+=sNum;
      sNameSigCorNoPLCorZeros+=sNum;
      sNameSigCorPLCorZeros+=sNum;
      
      meuSigCorNoPLCorHistos[i]=new TH1F
        (sNameSigCorNoPLCor.c_str(),sNameSigCorNoPLCor.c_str(),
         300,-2,3000);
      meuSigCorPLCorHistos[i]=new TH1F
        (sNameSigCorPLCor.c_str(),sNameSigCorPLCor.c_str(),
         300,-2,3000);

      meuSigCorNoPLCorPerpHistos[i]=new TH1F
        (sNameSigCorNoPLCorPerp.c_str(),sNameSigCorNoPLCorPerp.c_str(),
         300,-2,3000);
      meuSigCorPLCorPerpHistos[i]=new TH1F
        (sNameSigCorPLCorPerp.c_str(),sNameSigCorPLCorPerp.c_str(),
         300,-2,3000);
      
      meuSigCorNoPLCorZerosHistos[i]=new TH1F
        (sNameSigCorNoPLCorZeros.c_str(),
         sNameSigCorNoPLCorZeros.c_str(),
         300,-2,3000);
      meuSigCorPLCorZerosHistos[i]=new TH1F
        (sNameSigCorPLCorZeros.c_str(),
         sNameSigCorPLCorZeros.c_str(),
         300,-2,3000);
    }

    MSG("CDAnalysis",Msg::kInfo)
      <<"Creating TProfile, pEnVsDist, max bin="
      <<(60*material01Pl)/Munits::cm<<endl;
  }

  //Int_t endPlane=this->GetEventLength();
  Int_t endPlane=this->CalcLastPlaneOnTrkNoXTalk();
  Int_t planeToStopBefore=0;//have to change length cuts too!!!

  //calculate energy deposition in the window
  if (endPlane>=0){
    MAXMSG("CDAnalysis",Msg::kInfo,100)
      <<"Filling histo, vtxPl=0"
      <<", endPl="<<endPlane<<endl;
    
    //loop over the track
    Int_t pl=endPlane;
    while (pl!=planeToStopBefore){//cut out the first x planes (en dep is low, !d-ray)
      
      Float_t pathLengthCor=initValue;
      pathLengthCor=plPLCor[pl];
      Float_t truePathLengthCor=truePLCor[pl];
      //might be beyond plane end so use reco PLCor
      if (truePathLengthCor<1) truePathLengthCor=pathLengthCor;
      if (pl==endPlane){
        //cap the very last plane
        if (truePathLengthCor>3) {
          MAXMSG("CDAnalysis",Msg::kWarning,1000)
            <<"Capping the last plane PLCor"<<endl;
          truePathLengthCor=3;
        }
      }

      if (pathLengthCor<1){
        MAXMSG("CDAnalysis",Msg::kWarning,1000)
          <<"pl="<<pl<<", endPlane="<<endPlane
          <<", path len cor wrong="<<pathLengthCor<<endl;
        //set default to 1
        pathLengthCor=1;
      }

      Float_t meuSigCor=0;
      if (pathLengthCor) meuSigCor=plEnDep[pl]/pathLengthCor;
      Float_t meuSigCorTrue=0;
      if (truePathLengthCor) meuSigCorTrue=plEnDep[pl]/
                               truePathLengthCor;
      Float_t plMaterial=pathLengthCor*material01Pl;
      Float_t truePlMaterial=truePathLengthCor*material01Pl;

      //plot the value half way through the range of dE/dx it 
      //effectively integrates over
      Float_t toPlotMaterial=plMaterial*0.5+materialFromTrkEnd;
      Float_t trueToPlotMaterial=truePlMaterial*0.5+
        trueMaterialFromTrkEnd;

      Float_t trueEnDep=this->TrueEnDep(pl,event);
      Float_t trueEnDepPLC=-1;
      if (truePathLengthCor) {
        trueEnDepPLC=trueEnDep/truePathLengthCor;
      }
      
      //fill the histograms for each individual plane
      if (pl<60 && pl>=0) {
        //fill both with and without the pathlength correction
        //fill as a function of planes from track end point
        meuSigCorNoPLCorHistos[planesFromTrkEnd]->Fill(plEnDep[pl]);
        meuSigCorPLCorHistos[planesFromTrkEnd]->Fill(meuSigCor);

        //fill as a function of distance from track end point
        //distance in units of "perpendicular planes"
        Int_t planesFromTrkEndPerp=
          static_cast<Int_t>(materialFromTrkEnd/material01Pl);
        MAXMSG("CDAnalysis",Msg::kInfo,1000)
          <<"pl="<<pl<<", endPlane="<<endPlane
          <<", plFrTrkEnd="<<planesFromTrkEnd
          <<", plFrTrkEndPerp="<<planesFromTrkEndPerp
          <<", matFrTrkEnd="<<materialFromTrkEnd
          <<", material01Pl="<<material01Pl<<endl;
        if (planesFromTrkEndPerp<60 && planesFromTrkEndPerp>=0) {
          meuSigCorNoPLCorPerpHistos[planesFromTrkEndPerp]->
            Fill(plEnDep[pl]);
          meuSigCorPLCorPerpHistos[planesFromTrkEndPerp]->
            Fill(meuSigCor);
        }
        else cout<<"ahhh, planesFromTrkEndPerp="
                 <<planesFromTrkEndPerp<<endl;

        //fill as a function of plane number
        meuSigCorNoPLCorZerosHistos[pl]->Fill(plEnDep[pl]);
        meuSigCorPLCorZerosHistos[pl]->Fill(meuSigCor);
      }
      else cout<<"ahhh, pl="<<pl<<endl;

      //fill plot of PLC energy deposition
      hSigCorPLC->Fill(meuSigCor);
      pEnVsDistAll->Fill((materialFromTrkEnd/Munits::cm),meuSigCor);
      if (meuSigCor<7000) pEnVsDistAll2->Fill
                            ((materialFromTrkEnd/Munits::cm),meuSigCor);

      //put a check on the crazy brems
      //can get high landau-tail events in individual planes
      if (meuSigCor<5000){
        pEnVsDist->Fill((toPlotMaterial/Munits::cm),meuSigCor);
        
        //fill using 0 for the first pl, 
        //don't try and get an average position
        pEnVsDist0->Fill((materialFromTrkEnd/Munits::cm),meuSigCor);
        pEnVsPlane0->Fill(pl,meuSigCor);
        pTrueEnVsDist0->Fill((materialFromTrkEnd/Munits::cm),trueEnDep);
        pTrueEnPLCVsDist0->Fill((materialFromTrkEnd/Munits::cm),
                                trueEnDepPLC);
        pTrueEnVsPlane0->Fill(pl,trueEnDep);
        
        if (pl!=endPlane) {
          pEnVsDistNoEnd->Fill((toPlotMaterial/Munits::cm),meuSigCor);
          if (truePLCor.size()>0){
            pEnVsDistNoEndTrue->Fill((trueToPlotMaterial/Munits::cm),
                                     meuSigCorTrue);
            //make one with same positions as reco but true enDep
            pEnVsDistNoEndTrue2->Fill((toPlotMaterial/Munits::cm),
                                      meuSigCorTrue);
          }
        }
      }

      if (meuSigCor<5000 && endPlane>=49 && endPlane<=51){
        if (pl!=endPlane) {
          pEnVsDistNoEnd4951->Fill((toPlotMaterial/Munits::cm),
                                   meuSigCor);
        }
      }

      if (meuSigCor<5000 && endPlane>40){
        if (pl!=endPlane) {
          pEnVsDistNoEnd40->Fill((toPlotMaterial/Munits::cm),
                                 meuSigCor);
        }
      }

      //sum up material traversed
      materialFromTrkEnd+=plMaterial;
      trueMaterialFromTrkEnd+=truePlMaterial;
      planesFromTrkEnd++;

      MAXMSG("CDAnalysis",Msg::kInfo,500)
        <<"Window:p="<<pl
        <<", matPl="<<pathLengthCor*material01Pl
        <<", matTrk="<<materialFromTrkEnd
        <<", plEn="<<plEnDep[pl]
        <<endl;

      //increment the plane
      pl--;
    }
    hMatFromTrkEnd->Fill(materialFromTrkEnd);
    hMatFromTrkEndTrue->Fill(trueMaterialFromTrkEnd);
    Float_t totalMaterial=materialFromTrkEnd;
    materialFromTrkEnd=0;
    trueMaterialFromTrkEnd=0;
    
    //2nd loop over the track
    pl=endPlane;
    while (pl!=planeToStopBefore){//cut out the first x planes (en dep is low, !d-ray)
      
      Float_t pathLengthCor=initValue;
      pathLengthCor=plPLCor[pl];
      Float_t truePathLengthCor=truePLCor[pl];
      //might be beyond plane end so use reco PLCor
      if (truePathLengthCor<1) truePathLengthCor=pathLengthCor;
      if (pl==endPlane){
        //cap the very last plane
        if (truePathLengthCor>3) {
          MAXMSG("CDAnalysis",Msg::kWarning,1000)
            <<"Capping the last plane PLCor"<<endl;
          truePathLengthCor=3;
        }
      }

      if (pathLengthCor<1){
        MAXMSG("CDAnalysis",Msg::kWarning,1000)
          <<"pl="<<pl<<", endPlane="<<endPlane
          <<", path len cor wrong="<<pathLengthCor<<endl;
        //set default to 1
        pathLengthCor=1;
      }

      Float_t meuSigCor=0;
      if (pathLengthCor) meuSigCor=plEnDep[pl]/pathLengthCor;
      Float_t meuSigCorTrue=0;
      if (truePathLengthCor) meuSigCorTrue=plEnDep[pl]/
                               truePathLengthCor;
      Float_t plMaterial=pathLengthCor*material01Pl;
      Float_t truePlMaterial=truePathLengthCor*material01Pl;

      //plot the value half way through the range of dE/dx it 
      //effectively integrates over
      Float_t toPlotMaterial=plMaterial*0.5+materialFromTrkEnd;
      //Float_t trueToPlotMaterial=truePlMaterial*0.5+
      //trueMaterialFromTrkEnd;

      Float_t trueEnDep=this->TrueEnDep(pl,event);
      Float_t trueEnDepPLC=-1;
      if (truePathLengthCor) {
        trueEnDepPLC=trueEnDep/truePathLengthCor;
      }

      //put a check on the crazy brems and cut out the really steep ones
      //can also get high landau-tail events in individual planes
      if (meuSigCor<5000 && totalMaterial>2.49 && totalMaterial<2.61){
        if (pl!=endPlane) {
          pEnVsDistNoEnd250->Fill((toPlotMaterial/Munits::cm),
                                  meuSigCor);
        }
      }
      if (meuSigCor<5000 && totalMaterial>2.7 && totalMaterial<2.9){
        if (pl!=endPlane) {
          pEnVsDistNoEnd270->Fill((toPlotMaterial/Munits::cm),
                                  meuSigCor);
          pTrueEnPLCVsDist0270->Fill((materialFromTrkEnd/Munits::cm),
                                     trueEnDepPLC);
        }
      }
      //was 2.8->3.0 when pl!=1
      if (meuSigCor<5000 && totalMaterial>2.9 && totalMaterial<3.1){
        if (pl!=endPlane) {
          pPLCorVsPlane290->Fill(pl,pathLengthCor);
          pTrueEnPLCVsDist0290->Fill((materialFromTrkEnd/Munits::cm),
                                     trueEnDepPLC);
          pPLCorVsPlaneTrue->Fill(pl,truePathLengthCor);
          pEnVsDistNoEnd290->Fill((toPlotMaterial/Munits::cm),
                                  meuSigCor);
        }
      }
      if (meuSigCor<5000 && totalMaterial>3.1 && totalMaterial<3.3){
        if (pl!=endPlane) {
          pEnVsDistNoEnd310->Fill((toPlotMaterial/Munits::cm),
                                  meuSigCor);
          pTrueEnPLCVsDist0310->Fill((materialFromTrkEnd/Munits::cm),
                                     trueEnDepPLC);
        }
      }

      if (meuSigCor<5000 && totalMaterial>2.95 && totalMaterial<3.05){
        if (pl!=endPlane) {
          pEnVsDistNoEnd290a->Fill((toPlotMaterial/Munits::cm),
                                   meuSigCor);
        }
      }


      if (meuSigCor<5000 && totalMaterial>2.96 && totalMaterial<3.03){
        if (pl!=endPlane) {
          pEnVsDistNoEnd290b->Fill((toPlotMaterial/Munits::cm),
                                  meuSigCor);
        }
      }

      //sum up material traversed
      materialFromTrkEnd+=plMaterial;
      trueMaterialFromTrkEnd+=truePlMaterial;

      //increment the plane
      pl--;
    }
  }
}

//......................................................................

Double_t CDAnalysis::TrueEnDepNotSc(Int_t inplane,Int_t event) const
{
  if (!fTruthHitInfo) return 0;

  static Int_t lastEvent=-1;
  static map<Int_t,Double_t> plEnDep;
  static map<Int_t,Double_t> plMainPartEn;
  static Double_t totalEnDep=0;

  //if a new event then have to rebuild the map of energy dep
  //as a function of plane
  if (event!=lastEvent){

    MSG("CDAnalysis",Msg::kVerbose) 
      <<"Clearing the maps..."<<endl;

    //set the lastevent
    lastEvent=event;

    //clear the map
    plEnDep.clear();
    plMainPartEn.clear();
    totalEnDep=0;

    //now build the new map for this event

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Int_t mainParticle=hitInfo->GetMainParticle();
      Double_t enDep=hitInfo->GetTotalEnDep();
      Double_t mainPartEn=hitInfo->GetMainPartEn();
      //Double_t earliestT1=hitInfo->GetEarliestT1();
      Int_t muon=13;

      //cut out the decay electron
      //if (earliestT1>15e-9) continue;

      plEnDep[plane]+=enDep;
      //select the biggest mainPartEn
      if (mainPartEn>plMainPartEn[plane] && abs(mainParticle)==muon){
        plMainPartEn[plane]=mainPartEn;      
      }
    }
  }

  Double_t plEnDepNotSc=0;
    
  if (!(plMainPartEn[inplane]==0 || plMainPartEn[inplane+1]==0)) {
    plEnDepNotSc=plMainPartEn[inplane]-plEnDep[inplane]-
      plMainPartEn[inplane+1];
    totalEnDep+=plEnDep[inplane]+plEnDepNotSc;
  }

  MSG("CDAnalysis",Msg::kVerbose) 
    <<"pl="<<inplane<<", pEn="<<plMainPartEn[inplane]
    <<", pEn+1="<<plMainPartEn[inplane+1]
    <<", eDep="<<1000*plEnDep[inplane]
    <<", eDepNotSc="<<1000*plEnDepNotSc
    <<", tE="<<totalEnDep
    <<endl;

  return plEnDepNotSc;
}

//......................................................................

Int_t CDAnalysis::TrueNumDigiScintHits(Int_t inplane,
                                          Int_t event) const
{
  if (!fTruthHitInfo) return 0;

  static Int_t lastEvent=-1;
  static map<Int_t,Int_t> numHits;

  //if a new event then have to rebuild the map of hits
  //as a function of plane
  if (event!=lastEvent){
    //set the lastevent
    lastEvent=event;

    //clear the map
    numHits.clear();

    //now build the new map for this event

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Int_t numDsh=hitInfo->GetNumDigiScintHits();
      //Double_t earliestT1=hitInfo->GetEarliestT1();

      //cut out the decay electron
      //if (earliestT1>15e-9) continue;

      numHits[plane]+=numDsh;
    }
  }

  return numHits[inplane];
}

//......................................................................

void CDAnalysis::TruthEnDepFe()
{
  map<Int_t,Double_t> plEnDep;
  map<Int_t,Double_t> plMainPartEn;
  Double_t totalEnDep=0;
  vector<TH1F*> hEnDepFe;

  for (Int_t pl=0;pl<60;pl++){
    fS="Energy Deposition in Iron, plane=";
    string sPl=Form("%d",pl);
    fS+=sPl;
    hEnDepFe.push_back(new TH1F(fS.c_str(),fS.c_str(),600,-2,200));
  }

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);
    
    //clear the map
    plEnDep.clear();
    plMainPartEn.clear();
    totalEnDep=0;
    
    //now build the new map for this event

    if (!fTruthHitInfo) break;

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Int_t mainParticle=hitInfo->GetMainParticle();
      Double_t enDep=hitInfo->GetTotalEnDep();
      Double_t mainPartEn=hitInfo->GetMainPartEn();
      Double_t earliestT1=hitInfo->GetEarliestT1();
      Int_t muon=13;

      //cut out the decay electron
      if (earliestT1>15e-9) continue;
      cout<<"Cutting out the decay electron"<<endl;

      plEnDep[plane]+=enDep;
      //select the biggest mainPartEn
      if (mainPartEn>plMainPartEn[plane] && abs(mainParticle)==muon){
        plMainPartEn[plane]=mainPartEn;      
      }
    }

    
    //vector<Double_t> plEnDepFe(60);

    //loop 60-1 planes
    for (Int_t p=0;p<59;p++){

      Double_t plEnDepFe=plMainPartEn[p]-plEnDep[p]-
        plMainPartEn[p+1];
      totalEnDep+=plEnDep[p]+plEnDepFe;
      
      //fill the histo
      hEnDepFe[p]->Fill(1000*plEnDepFe);
      
      MSG("CDAnalysis",Msg::kVerbose) 
        <<"pl="<<p<<", pEn="<<plMainPartEn[p]
        <<", pEn+1="<<plMainPartEn[p+1]
        <<", eDep="<<1000*plEnDep[p]
        <<", eDepFe="<<1000*plEnDepFe
        <<", tE="<<totalEnDep
        <<endl;
      
    }
  }//end of for

  TCanvas *cEnDep=new TCanvas("cEnDep","EnDep",0,0,1200,800);
  cEnDep->SetFillColor(0);
  cEnDep->Divide(2,3);
  cEnDep->cd(1);
  hEnDepFe[0]->Draw();
  cEnDep->cd(2);
  hEnDepFe[1]->Draw();
  cEnDep->cd(3);
  hEnDepFe[2]->Draw();
  cEnDep->cd(4);
  hEnDepFe[3]->Draw();
  cEnDep->cd(5);
  hEnDepFe[4]->Draw();
  cEnDep->cd(6);
  hEnDepFe[5]->Draw();

}

//......................................................................

void CDAnalysis::TruthEventLength()
{
  //only have pid for real data so return if not data
  //if (fSimFlag!=SimFlag::kData) abort(true);

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"EvLen");

  TH1F *hEventLength=new TH1F("hEventLength","EventLength hit",
                              77,-2,75);
  hEventLength->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hEventLength2=new TH1F("hEventLength2","EventLength",77,-2,75);
  hEventLength2->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength2->GetXaxis()->CenterTitle();
  hEventLength2->GetYaxis()->SetTitle("");
  hEventLength2->GetYaxis()->CenterTitle();
  hEventLength2->SetFillColor(0);
  hEventLength2->SetBit(TH1::kCanRebin);

  TH1F *hEventLength3=new TH1F("hEventLength3","EventLength",77,-2,75);
  hEventLength3->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength3->GetXaxis()->CenterTitle();
  hEventLength3->GetYaxis()->SetTitle("");
  hEventLength3->GetYaxis()->CenterTitle();
  hEventLength3->SetFillColor(0);
  hEventLength3->SetBit(TH1::kCanRebin);

  TH1F *hEventLength4=new TH1F("hEventLength4","EventLength",77,-2,75);
  hEventLength4->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength4->GetXaxis()->CenterTitle();
  hEventLength4->GetYaxis()->SetTitle("");
  hEventLength4->GetYaxis()->CenterTitle();
  hEventLength4->SetFillColor(0);
  hEventLength4->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);
    
    Int_t overallLastPlane=0;
    Int_t notNoiseLastPlane=0;
    Int_t particleLastPlane=0;
    //Int_t inTimeLastPlane=0;
    Int_t muonLastPlane=0;
    
    if (!fTruthHitInfo) break;
    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();

    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
    
      Int_t plane=hitInfo->GetPlane();
      Int_t mainParticle=hitInfo->GetMainParticle();
      Int_t pmtTruth1=hitInfo->GetPmtTruth1();
      Int_t pmtTruth2=hitInfo->GetPmtTruth2();
      Double_t earliestT1=hitInfo->GetEarliestT1();
      Int_t muon=13;

      if (plane>overallLastPlane) overallLastPlane=plane;

      Int_t sumTruth=pmtTruth1 | pmtTruth2;
      Bool_t genuine=(sumTruth & DigiSignal::kGenuine)==
        DigiSignal::kGenuine;
      Bool_t fibreLight=(sumTruth & DigiSignal::kFibreLight)==
        DigiSignal::kFibreLight;
      Bool_t darkNoise=(sumTruth & DigiSignal::kDarkNoise)==
        DigiSignal::kDarkNoise;

      if (!genuine && (fibreLight || darkNoise)) continue;
      
      if (plane>notNoiseLastPlane) notNoiseLastPlane=plane;

      if (!genuine) continue;

      //cut out the late decay electron, ND is alive for ~400 ns
      if (earliestT1>500e-9) continue;
      
      if (plane>particleLastPlane) particleLastPlane=plane;

      //in time but not necessarily a muon
      //if (plane>inTimeLastPlane) inTimeLastPlane=plane;

      //only look at muons
      if (abs(mainParticle)!=muon) continue;      

      if (plane>muonLastPlane) muonLastPlane=plane;
    }

    hEventLength->Fill(overallLastPlane+1);
    hEventLength2->Fill(notNoiseLastPlane+1);
    hEventLength3->Fill(particleLastPlane+1);
    //hEventLength3->Fill(inTimeLastPlane+1);
    hEventLength4->Fill(muonLastPlane+1);

  }//end of for

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,3);
  cGeom->cd(1);
  hEventLength->Draw();
  cGeom->cd(2);
  hEventLength2->Draw();
  hEventLength2->SetLineColor(2);
  cGeom->cd(3);
  hEventLength3->Draw();
  hEventLength3->SetLineColor(3);
  cGeom->cd(4);
  hEventLength4->Draw();
  hEventLength->SetLineColor(4);
  cGeom->cd(5);
  hEventLength4->Draw();
  hEventLength2->Draw("sames");
  cGeom->cd(6);
  hEventLength4->Draw();
  hEventLength3->Draw("sames");
  hEventLength2->Draw("sames");
  hEventLength->Draw("sames");
}

//......................................................................

void CDAnalysis::MuonResponse()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonResponse method... **"<<endl;

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"MuonRes");

  TH2F *hPeVsRange=new TH2F("hPeVsRange","PeVsRange",
                            20,40,60,50,0,10);
  hPeVsRange->GetXaxis()->SetTitle("Last Plane");
  hPeVsRange->GetXaxis()->CenterTitle();
  hPeVsRange->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRange->GetYaxis()->CenterTitle();
  hPeVsRange->SetFillColor(0);
  //hPeVsRange->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeGen=new TH2F("hPeVsRangeGen","PeVsRangeGen",
                            20,40,60,50,0,10);
  hPeVsRangeGen->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeGen->GetXaxis()->CenterTitle();
  hPeVsRangeGen->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeGen->GetYaxis()->CenterTitle();
  hPeVsRangeGen->SetFillColor(0);
  //hPeVsRangeGen->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeGen2=new TH2F("hPeVsRangeGen2","PeVsRangeGen2",
                            20,40,60,50,0,10);
  hPeVsRangeGen2->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeGen2->GetXaxis()->CenterTitle();
  hPeVsRangeGen2->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeGen2->GetYaxis()->CenterTitle();
  hPeVsRangeGen2->SetFillColor(0);
  //hPeVsRangeGen2->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeGen3=new TH2F("hPeVsRangeGen3","PeVsRangeGen3",
                            20,40,60,50,0,10);
  hPeVsRangeGen3->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeGen3->GetXaxis()->CenterTitle();
  hPeVsRangeGen3->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeGen3->GetYaxis()->CenterTitle();
  hPeVsRangeGen3->SetFillColor(0);
  //hPeVsRangeGen3->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeXTalk=new TH2F("hPeVsRangeXTalk","PeVsRangeXTalk",
                            20,40,60,50,0,10);
  hPeVsRangeXTalk->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeXTalk->GetXaxis()->CenterTitle();
  hPeVsRangeXTalk->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeXTalk->GetYaxis()->CenterTitle();
  hPeVsRangeXTalk->SetFillColor(0);
  //hPeVsRangeXTalk->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeXTalk2=new TH2F("hPeVsRangeXTalk2","PeVsRangeXTalk2",
                            20,40,60,50,0,10);
  hPeVsRangeXTalk2->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeXTalk2->GetXaxis()->CenterTitle();
  hPeVsRangeXTalk2->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeXTalk2->GetYaxis()->CenterTitle();
  hPeVsRangeXTalk2->SetFillColor(0);
  //hPeVsRangeXTalk2->SetBit(TH1::kCanRebin);

  TH2F *hPeVsRangeXTalk3=new TH2F("hPeVsRangeXTalk3","PeVsRangeXTalk3",
                            20,40,60,50,0,10);
  hPeVsRangeXTalk3->GetXaxis()->SetTitle("Last Plane");
  hPeVsRangeXTalk3->GetXaxis()->CenterTitle();
  hPeVsRangeXTalk3->GetYaxis()->SetTitle("Greatest PE Value");
  hPeVsRangeXTalk3->GetYaxis()->CenterTitle();
  hPeVsRangeXTalk3->SetFillColor(0);
  //hPeVsRangeXTalk3->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanes=new TH1F("hNumPlanes","NumPlanes hit",77,-2,75);
  hNumPlanes->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanes->GetXaxis()->CenterTitle();
  hNumPlanes->GetYaxis()->SetTitle("");
  hNumPlanes->GetYaxis()->CenterTitle();
  hNumPlanes->SetFillColor(0);
  hNumPlanes->SetBit(TH1::kCanRebin);

  TH1F *h15_18All=new TH1F("h15_18All","h15_18All",1000,-2,75);
  h15_18All->GetXaxis()->SetTitle("SigCors");
  h15_18All->GetXaxis()->CenterTitle();
  h15_18All->GetYaxis()->SetTitle("");
  h15_18All->GetYaxis()->CenterTitle();
  h15_18All->SetFillColor(0);
  h15_18All->SetBit(TH1::kCanRebin);

  TH1F *h15_18=new TH1F("h15_18","h15_18",1000,-2,75);
  h15_18->GetXaxis()->SetTitle("SigCors");
  h15_18->GetXaxis()->CenterTitle();
  h15_18->GetYaxis()->SetTitle("");
  h15_18->GetYaxis()->CenterTitle();
  h15_18->SetFillColor(0);
  h15_18->SetBit(TH1::kCanRebin);

  TH1F *hSigCorTotal=new TH1F("hSigCorTotal","hSigCorTotal",1000,-2,75);
  hSigCorTotal->GetXaxis()->SetTitle("SigCors");
  hSigCorTotal->GetXaxis()->CenterTitle();
  hSigCorTotal->GetYaxis()->SetTitle("");
  hSigCorTotal->GetYaxis()->CenterTitle();
  hSigCorTotal->SetFillColor(0);
  hSigCorTotal->SetBit(TH1::kCanRebin);

  TH1F *hSigCorTotalTight=new TH1F("hSigCorTotalTight",
                                   "hSigCorTotalTight",1000,-2,75);
  hSigCorTotalTight->GetXaxis()->SetTitle("SigCors");
  hSigCorTotalTight->GetXaxis()->CenterTitle();
  hSigCorTotalTight->GetYaxis()->SetTitle("");
  hSigCorTotalTight->GetYaxis()->CenterTitle();
  hSigCorTotalTight->SetFillColor(0);
  hSigCorTotalTight->SetBit(TH1::kCanRebin);

  TH1F *hSigCorTotalPeak=new TH1F("hSigCorTotalPeak",
                                  "hSigCorTotalPeak",1000,-2,75);
  hSigCorTotalPeak->GetXaxis()->SetTitle("SigCors");
  hSigCorTotalPeak->GetXaxis()->CenterTitle();
  hSigCorTotalPeak->GetYaxis()->SetTitle("");
  hSigCorTotalPeak->GetYaxis()->CenterTitle();
  hSigCorTotalPeak->SetFillColor(0);
  hSigCorTotalPeak->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesAll=new TH1F("hNumPlanesAll","NumPlanesAll hit",
                               77,-2,75);
  hNumPlanesAll->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesAll->GetXaxis()->CenterTitle();
  hNumPlanesAll->GetYaxis()->SetTitle("");
  hNumPlanesAll->GetYaxis()->CenterTitle();
  hNumPlanesAll->SetFillColor(0);
  hNumPlanesAll->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesMu=new TH1F("hNumPlanesMu","hNumPlanesMu hit",
                              77,-2,75);
  hNumPlanesMu->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesMu->GetXaxis()->CenterTitle();
  hNumPlanesMu->GetYaxis()->SetTitle("");
  hNumPlanesMu->GetYaxis()->CenterTitle();
  hNumPlanesMu->SetFillColor(0);
  hNumPlanesMu->SetLineColor(2);
  hNumPlanesMu->SetBit(TH1::kCanRebin);
  
  TH1F *hFirstPlane=new TH1F("hFirstPlane","FirstPlane hit",77,-2,75);
  hFirstPlane->GetXaxis()->SetTitle("First Plane Hit");
  hFirstPlane->GetXaxis()->CenterTitle();
  hFirstPlane->GetYaxis()->SetTitle("");
  hFirstPlane->GetYaxis()->CenterTitle();
  hFirstPlane->SetFillColor(0);
  hFirstPlane->SetBit(TH1::kCanRebin);

  TH1F *hEventLength=new TH1F("hEventLength","EventLength hit",
                              77,-2,75);
  hEventLength->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hEventLength2=new TH1F("hEventLength2","EventLength",77,-2,75);
  hEventLength2->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength2->GetXaxis()->CenterTitle();
  hEventLength2->GetYaxis()->SetTitle("");
  hEventLength2->GetYaxis()->CenterTitle();
  hEventLength2->SetFillColor(0);
  hEventLength2->SetBit(TH1::kCanRebin);

  TH1F *hEventLength3=new TH1F("hEventLength3","EventLength",77,-2,75);
  hEventLength3->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength3->GetXaxis()->CenterTitle();
  hEventLength3->GetYaxis()->SetTitle("");
  hEventLength3->GetYaxis()->CenterTitle();
  hEventLength3->SetFillColor(0);
  hEventLength3->SetBit(TH1::kCanRebin);

  TH2F *hCkvAdcVsRange=new TH2F("hCkvAdcVsRange","CkvAdcVsRange",
                                20,40,60,100,-1,1500);
  hCkvAdcVsRange->GetXaxis()->SetTitle("Last Plane");
  hCkvAdcVsRange->GetXaxis()->CenterTitle();
  hCkvAdcVsRange->GetYaxis()->SetTitle("Ckv ADC");
  hCkvAdcVsRange->GetYaxis()->CenterTitle();
  hCkvAdcVsRange->SetFillColor(0);
  hCkvAdcVsRange->SetBit(TH1::kCanRebin);

  //sum of all strip ends, normal and offset planes
  //tracked
  TProfile* pSigCorVsPlane=new TProfile("pSigCorVsPlane",
                                        "pSigCorVsPlane",
                                        62,0,62);
  TProfile* pSigCorVsOsPlane=new TProfile("pSigCorVsOsPlane",
                                          "pSigCorVsOsPlane",
                                          62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneX=new TProfile("pSigCorVsPlaneX",
                                         "pSigCorVsPlaneX",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneX=new TProfile("pSigCorVsOsPlaneX",
                                           "pSigCorVsOsPlaneX",
                                           62,0,62);

  //total
  TProfile* pSigCorVsPlaneT=new TProfile("pSigCorVsPlaneT",
                                         "pSigCorVsPlaneT",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneT=new TProfile("pSigCorVsOsPlaneT",
                                           "pSigCorVsOsPlaneT",
                                           62,0,62);

  //individual strip ends
  //tracked
  TProfile* pSigCorVsPlaneO1=new TProfile("pSigCorVsPlaneO1",
                                          "pSigCorVsPlaneO1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2=new TProfile("pSigCorVsPlaneO2",
                                          "pSigCorVsPlaneO2",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1=new TProfile("pSigCorVsPlaneE1",
                                          "pSigCorVsPlaneE1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2=new TProfile("pSigCorVsPlaneE2",
                                          "pSigCorVsPlaneE2",
                                          62,0,62);
  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneO1X=new TProfile("pSigCorVsPlaneO1X",
                                          "pSigCorVsPlaneO1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2X=new TProfile("pSigCorVsPlaneO2X",
                                          "pSigCorVsPlaneO2X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1X=new TProfile("pSigCorVsPlaneE1X",
                                          "pSigCorVsPlaneE1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2X=new TProfile("pSigCorVsPlaneE2X",
                                          "pSigCorVsPlaneE2X",
                                          62,0,62);
  //total
  TProfile* pSigCorVsPlaneO1T=new TProfile("pSigCorVsPlaneO1T",
                                          "pSigCorVsPlaneO1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2T=new TProfile("pSigCorVsPlaneO2T",
                                          "pSigCorVsPlaneO2T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1T=new TProfile("pSigCorVsPlaneE1T",
                                          "pSigCorVsPlaneE1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2T=new TProfile("pSigCorVsPlaneE2T",
                                          "pSigCorVsPlaneE2T",
                                          62,0,62);

  //individual strip ends - offset planes
  //tracked
  TProfile* pSigCorVsOsPlaneO1=new TProfile("pSigCorVsOsPlaneO1",
                                            "pSigCorVsOsPlaneO1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2=new TProfile("pSigCorVsOsPlaneO2",
                                            "pSigCorVsOsPlaneO2",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1=new TProfile("pSigCorVsOsPlaneE1",
                                            "pSigCorVsOsPlaneE1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2=new TProfile("pSigCorVsOsPlaneE2",
                                            "pSigCorVsOsPlaneE2",
                                            62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsOsPlaneO1X=new TProfile("pSigCorVsOsPlaneO1X",
                                             "pSigCorVsOsPlaneO1X",
                                             62,0,62);
  TProfile* pSigCorVsOsPlaneO2X=new TProfile("pSigCorVsOsPlaneO2X",
                                            "pSigCorVsOsPlaneO2X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1X=new TProfile("pSigCorVsOsPlaneE1X",
                                            "pSigCorVsOsPlaneE1X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2X=new TProfile("pSigCorVsOsPlaneE2X",
                                            "pSigCorVsOsPlaneE2X",
                                            62,0,62);
  //total
  TProfile* pSigCorVsOsPlaneO1T=new TProfile("pSigCorVsOsPlaneO1T",
                                            "pSigCorVsOsPlaneO1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2T=new TProfile("pSigCorVsOsPlaneO2T",
                                            "pSigCorVsOsPlaneO2T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1T=new TProfile("pSigCorVsOsPlaneE1T",
                                            "pSigCorVsOsPlaneE1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2T=new TProfile("pSigCorVsOsPlaneE2T",
                                            "pSigCorVsOsPlaneE2T",
                                            62,0,62);

  TProfile* pEnVsRange=new TProfile("pEnVsRange","pEnVsRange",
                                    62,0,62);

  vector<TProfile*> pSigCorVsDist;
  vector<TProfile*> pSigCorVsDistN;
  vector<Int_t> vWindowSize;
  vector<Float_t> bigAv;
  vector<Int_t> bigAvCounter;
  Float_t sum15_18=0;
  Float_t sum15_18Counter=0;
  Float_t sum15_18Mip=0;
  Float_t sum15_18MipCounter=0;
  Float_t sumSigCorTotal=0;
  Float_t sumSigCorTotalCounter=0;
  Float_t sumMipTotal=0;
  Float_t sumMipTotalCounter=0;

  Int_t lastPlaneOddCounter=0;
  Int_t lastPlaneEvenCounter=0;
  Int_t lastPlaneO1Counter=0;
  Int_t lastPlaneO2Counter=0;
  Int_t lastPlaneE1Counter=0;
  Int_t lastPlaneE2Counter=0;
  Int_t lastPlaneOBothCounter=0;
  Int_t lastPlaneEBothCounter=0;

  Int_t totalCounter=0;
  Int_t firstPlaneInPairCounter=0;
  Int_t sharedPmtCounter=0;
  Int_t sharedPmtXTalkCounter=0;
  Int_t side1Counter=0;
  Int_t side1XTalkCounter=0;
  Int_t side2Counter=0;
  Int_t side2XTalkCounter=0;
  Int_t doubleCounter=0;
  Int_t doubleXTalkCounter=0;
  Int_t notGenuineOrXTalkCounter=0;

  //num maps for all stripends
  map<Int_t,Float_t> num;
  map<Int_t,Float_t> numX;
  map<Int_t,Float_t> numT;
  map<Int_t,Float_t> numOs;
  map<Int_t,Float_t> numOsX;
  map<Int_t,Float_t> numOsT;

  //non-offset num maps for individual stripends
  map<Int_t,Float_t> numO1;
  map<Int_t,Float_t> numO1X;
  map<Int_t,Float_t> numO1T;
  map<Int_t,Float_t> numO2;
  map<Int_t,Float_t> numO2X;
  map<Int_t,Float_t> numO2T;
  map<Int_t,Float_t> numE1;
  map<Int_t,Float_t> numE1X;
  map<Int_t,Float_t> numE1T;
  map<Int_t,Float_t> numE2;
  map<Int_t,Float_t> numE2X;
  map<Int_t,Float_t> numE2T;

  //offset num maps for individual stripends
  map<Int_t,Float_t> numOsO1;
  map<Int_t,Float_t> numOsO1X;
  map<Int_t,Float_t> numOsO1T;
  map<Int_t,Float_t> numOsO2;
  map<Int_t,Float_t> numOsO2X;
  map<Int_t,Float_t> numOsO2T;
  map<Int_t,Float_t> numOsE1;
  map<Int_t,Float_t> numOsE1X;
  map<Int_t,Float_t> numOsE1T;
  map<Int_t,Float_t> numOsE2;
  map<Int_t,Float_t> numOsE2X;
  map<Int_t,Float_t> numOsE2T;

  Int_t noTrackCounter=0;
  Int_t passPidCounter=0;
 
  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;
    //cut on not straight tracks
    //Double_t mainX1Cut=0.5;
    //if (!this->IsStraightTrack(mainX1Cut)){
    //continue;
    //}

    //count the number of events passing the pid
    passPidCounter++;

    map<Int_t,Int_t> numPlanesHit;
    map<Int_t,Int_t> numPlanesHit1;
    map<Int_t,Int_t> numPlanesHit2;
    map<Int_t,Int_t> numPlanesHitAll;
    map<Int_t,Float_t> planeSigCor;
    map<Int_t,Float_t> planeSigCorX;
    map<Int_t,Float_t> planeSigCorT;
    map<Int_t,Float_t> planeSigCorO1;    
    map<Int_t,Float_t> planeSigCorO1X;
    map<Int_t,Float_t> planeSigCorO1T;
    map<Int_t,Float_t> planeSigCorO2;
    map<Int_t,Float_t> planeSigCorO2X;
    map<Int_t,Float_t> planeSigCorO2T;
    map<Int_t,Float_t> planeSigCorE1;
    map<Int_t,Float_t> planeSigCorE1X;
    map<Int_t,Float_t> planeSigCorE1T;
    map<Int_t,Float_t> planeSigCorE2;
    map<Int_t,Float_t> planeSigCorE2X;
    map<Int_t,Float_t> planeSigCorE2T;

    map<Int_t,Float_t> planeMip;
    map<Int_t,Float_t> planeMipX;
    map<Int_t,Float_t> planeMipT;

    map<Int_t,Float_t> planePe;
    map<Int_t,Float_t> planeGreatestPe;

    Double_t sigCorTotal=0;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
    //TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=0;
    if (fTruthHitInfo) numTruthHits=fTruthHitInfo->GetEntries();

    //look for untracked big events
    if (numTrkHits<2 && numXTalkHits+numUnTrkHits>1){
      MSG("CDAnalysis",Msg::kDebug)
        <<"Event="<<event
        <<", Num hits: trk="<<numTrkHits<<", unTrk="<<numUnTrkHits
        <<", xtalk="<<numXTalkHits<<", truth="<<numTruthHits
        <<endl;
      noTrackCounter++;
      //continue;
    }

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      if (fPlane==0 && fChargeSigCor>1000){
        MSG("CDAnalysis",Msg::kDebug)
          <<"XTalk Event="<<event
          <<", fPlane="<<fPlane
          <<", fStrip="<<fStrip
          <<", fStripend="<<fStripend
          <<", fChargeAdc="<<fChargeAdc
          <<", fSigCor="<<fChargeSigCor<<endl;
      }

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      //check the channel's sanity
      this->StandardSanityChecks();

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      //check the channel's sanity
      this->StandardSanityChecks();

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }

    Bool_t lastPlaneO1Hit=false;
    Bool_t lastPlaneO2Hit=false;
    Bool_t lastPlaneE1Hit=false;
    Bool_t lastPlaneE2Hit=false;
    Int_t previousfLastPlane=-1;

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      //count the number of planes hit
      numPlanesHit[fPlane]++;
      numPlanesHitAll[fPlane]++;

      if (fLastPlane==fPlane && fPlane%2==0){

        //check if a new last plane has been found
        if (fLastPlane!=previousfLastPlane){
          lastPlaneE1Hit=false;
          lastPlaneE2Hit=false;
        }
        previousfLastPlane=fLastPlane;

        //check which stripend to set to true
        if (fStripend==1) lastPlaneE1Hit=true;
        if (fStripend==2) lastPlaneE2Hit=true;

        //set the hits in the other plane to be false
        lastPlaneO1Hit=false;
        lastPlaneO2Hit=false;
        MSG("CDAnalysis",Msg::kVerbose)
          <<"ev="<<event
          <<", last="<<fLastPlane
          <<", pl="<<fPlane
          <<", se="<<fStripend
          <<", E1="<<lastPlaneE1Hit
          <<", E2="<<lastPlaneE2Hit
          <<", O1="<<lastPlaneO1Hit
          <<", O2="<<lastPlaneO2Hit<<endl;
      }
      else if (fLastPlane==fPlane && fPlane%2==1){

        //check if a new last plane has been found
        if (fLastPlane!=previousfLastPlane){
          lastPlaneO1Hit=false;
          lastPlaneO2Hit=false;
        }
        previousfLastPlane=fLastPlane;

        //check which stripend to set to true
        if (fStripend==1) lastPlaneO1Hit=true;
        if (fStripend==2) lastPlaneO2Hit=true;

        //set the hits in the other plane to be false
        lastPlaneE1Hit=false;
        lastPlaneE2Hit=false;

        MSG("CDAnalysis",Msg::kVerbose)
          <<"ev="<<event
          <<", last="<<fLastPlane
          <<", pl="<<fPlane
          <<", se="<<fStripend
          <<", E1="<<lastPlaneE1Hit
          <<", E2="<<lastPlaneE2Hit
          <<", O1="<<lastPlaneO1Hit
          <<", O2="<<lastPlaneO2Hit<<endl;
      }

      //add up the charge of the hits in each plane
      planeSigCor[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMip[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;
      planePe[fPlane]+=fChargePe;
      if (fO1) planeSigCorO1[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }
    //end of loop over the tracked hits

    //fill histos for all data
    hNumPlanes->Fill(numPlanesHit.size());
    hNumPlanesAll->Fill(numPlanesHitAll.size());
    hEventLength->Fill(fLastPlane+1);

    //make sure that the first plane makes sense and was actually set
    if (fFirstPlane<0 || fFirstPlane>59) continue;

    //calculate the event energy
    Double_t eventEn=(fScEnDepPerMEU/fSigCorPerMEU)*sigCorTotal*
      (1/fRatioScEnToBeamEn);
    //calc the last plane on the track with no xtalk
    Int_t lastPlaneNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();

    //fill the prof
    pEnVsRange->Fill(lastPlaneNoXTalk+1,eventEn);

    if (fLastPlane%2==1) lastPlaneOddCounter++;
    if (fLastPlane%2==0) lastPlaneEvenCounter++;

    //work out which stripends in the last plane were hit
    if (lastPlaneE1Hit || lastPlaneE2Hit){
      if (lastPlaneE1Hit && !lastPlaneE2Hit) lastPlaneE1Counter++;
      else if (!lastPlaneE1Hit && lastPlaneE2Hit) lastPlaneE2Counter++;
      else lastPlaneEBothCounter++;
    }
    else if (lastPlaneO1Hit || lastPlaneO2Hit){
      if (lastPlaneO1Hit && !lastPlaneO2Hit) lastPlaneO1Counter++;
      else if (!lastPlaneO1Hit && lastPlaneO2Hit) lastPlaneO2Counter++;
      else lastPlaneOBothCounter++;
    }
    else{
      MSG("CDAnalysis",Msg::kInfo)
        <<"Nothing hit!"<<endl;

      MSG("CDAnalysis",Msg::kInfo)
        <<"ev="<<event
        <<", Num hits: trk="<<numTrkHits<<", unTrk="<<numUnTrkHits
        <<", xtalk="<<numXTalkHits
        <<", E1="<<lastPlaneE1Hit
        <<", E2="<<lastPlaneE2Hit
        <<", O1="<<lastPlaneO1Hit
        <<", O2="<<lastPlaneO2Hit<<endl;
    }

    MSG("CDAnalysis",Msg::kVerbose)<<"New event="<<event<<endl;

    totalCounter++;
    //look for the second of a pair of shared pmts
    if ((fLastPlane==26 || fLastPlane==27 ||
         fLastPlane==30 || fLastPlane==31 ||
         fLastPlane==34 || fLastPlane==35 ||
         fLastPlane==38 || fLastPlane==39 ||
         fLastPlane==42 || fLastPlane==43 ||
         fLastPlane==46 || fLastPlane==47 ||
         fLastPlane==50 || fLastPlane==51 ||
         fLastPlane==54 || fLastPlane==55 ||
         fLastPlane==58 || fLastPlane==59)){
      //fLastPlaneOdd
      //fLastPlaneEven
      
      if (this->IsDoubleEnded(fLastPlane)){
        doubleCounter++;
        if (this->IsPlaneXTalkOnly(fLastPlane)){
          doubleXTalkCounter++;
        }
      }
      else if (this->IsPlaneSideHit(fLastPlane,StripEnd::kEast)){
        side1Counter++;

        if (this->IsPlaneXTalkOnly(fLastPlane)){
          side1XTalkCounter++;
        }

        if (this->IsSharedPmtHit(fLastPlane)){
          sharedPmtCounter++;
          if (this->IsPlaneXTalkOnly(fLastPlane)){
            sharedPmtXTalkCounter++;
          }
        }
      }
      else if (this->IsPlaneSideHit(fLastPlane,StripEnd::kWest)){
        side2Counter++;
         
        if (this->IsPlaneXTalkOnly(fLastPlane)){
          side2XTalkCounter++;
        }
 
        if (this->IsSharedPmtHit(fLastPlane)){
          sharedPmtCounter++;
          if (this->IsPlaneXTalkOnly(fLastPlane)){
            sharedPmtXTalkCounter++;
          }
          MSG("CDAnalysis",Msg::kWarning)
            <<"This should not happen at CalDet!"<<endl;
        }
      }
      
      MSG("CDAnalysis",Msg::kVerbose)
        <<"Shared="<<sharedPmtCounter
        <<" ("<<sharedPmtXTalkCounter<<")"
        <<", 2end="<<doubleCounter
        <<" ("<<doubleXTalkCounter<<")"
        <<", end1="<<side1Counter
        <<" ("<<side1XTalkCounter<<")"
        <<", end2="<<side2Counter
        <<" ("<<side2XTalkCounter<<")"
        <<endl;
    }
    else{
      firstPlaneInPairCounter++;
    }

    if (!this->IsGenuineOrXTalk(fLastPlane)){
      notGenuineOrXTalkCounter++;
    }

    //make event length cuts
    if (this->CutOnEventLength()) continue;
    //make track quality cuts
    if (this->CutOnTrackQuality()) continue;

    MAXMSG("CDAnalysis",Msg::kInfo,10)
      <<"Event passing plane cuts="<<event<<endl;

    //fill the total sigcor histo
    hSigCorTotal->Fill(sigCorTotal);

    //fill event length plots for those passing cuts
    hFirstPlane->Fill(fFirstPlane);
    hEventLength2->Fill(fLastPlane+1);
    hEventLength3->Fill(lastPlaneNoXTalk+1);

    //look at a certain part of the spectrum
    if (lastPlaneNoXTalk+1>50 && lastPlaneNoXTalk+1<53){
      //fill the total sigcor histo
      hSigCorTotalTight->Fill(sigCorTotal);
    }
    
    if (lastPlaneNoXTalk+1==51){
      //fill the total sigcor histo
      hSigCorTotalPeak->Fill(sigCorTotal);
    }

    //look at pe versus range
    hPeVsRange->Fill(fLastPlane+1,planeGreatestPe[fLastPlane]);
    if (this->IsPlaneGenuine(fLastPlane)){
      hPeVsRangeGen->Fill(fLastPlane+1,planeGreatestPe[fLastPlane]);
    }
    else{
      hPeVsRangeXTalk->Fill(fLastPlane+1,planeGreatestPe[fLastPlane]);

      //now look at second from last plane
      if (this->IsPlaneGenuine(fLastPlane-1)){
        hPeVsRangeGen2->Fill(fLastPlane+1-1,
                               planeGreatestPe[fLastPlane-1]);
      }
      else{
        hPeVsRangeXTalk2->Fill(fLastPlane+1-1,
                               planeGreatestPe[fLastPlane-1]);

        //now look at third from last plane
        if (this->IsPlaneGenuine(fLastPlane-2)){
          hPeVsRangeGen3->Fill(fLastPlane+1-2,
                               planeGreatestPe[fLastPlane-2]);
        }
        else{
          hPeVsRangeXTalk3->Fill(fLastPlane+1-2,
                                 planeGreatestPe[fLastPlane-2]);
        }
      }
    }

    hCkvAdcVsRange->Fill(fLastPlane+1,fKovADC3);

    //section for response

    //const Int_t reNormPlane=70;
    //Int_t planeOffset=reNormPlane-fLastPlane;
    const Int_t os=fLastPlane;

    //do nasty hack for plane 40 - very nasty!!!!
    //if (fRunNumber==70709 || fRunNumber==70705){
    //planeSigCor[40]=planeSigCor[38];
      //don't do xtalk since if pl 38 has zero xtalk then you will make
      //the map bigger and will average a zero!!!!
      //planeSigCorX[40]=planeSigCorX[38];
      //planeSigCorT[40]=planeSigCorT[38];
    //}
    //do nasty hack for plane 35 - very nasty!!!!
    if (fRunNumber>40000 && fRunNumber<60000){
      planeSigCor[35]=planeSigCor[37];
      planeSigCorT[35]=planeSigCorT[37];
    }
    //do nasty hack for plane 35 - very nasty!!!!
    else if (fRunNumber>100000 && fRunNumber<110000){
      //map<Int_t,Float_t> tmp=planeSigCor;
      //map<Int_t,Float_t> tmpT=planeSigCor;
      //if (tmp[15]!=0){
        //planeSigCor[13]=planeSigCor[15];
      //}

      //if (tmpT[15]!=0){
        //planeSigCorT[13]=planeSigCorT[15];
      //}
    }

    //fill profs for all stripends
    this->FillProfHisto(pSigCorVsPlane,num,planeSigCor);
    this->FillProfHisto(pSigCorVsPlaneX,numX,planeSigCorX);
    this->FillProfHisto(pSigCorVsPlaneT,numT,planeSigCorT);
    //offset
    this->FillProfHisto(pSigCorVsOsPlane,numOs,planeSigCor,os);
    this->FillProfHisto(pSigCorVsOsPlaneX,numOsX,planeSigCorX,os);
    this->FillProfHisto(pSigCorVsOsPlaneT,numOsT,planeSigCorT,os);

    //fill non-offset profs for individual stripends
    this->FillProfHisto(pSigCorVsPlaneO1,numO1,planeSigCorO1);
    this->FillProfHisto(pSigCorVsPlaneO1X,numO1X,planeSigCorO1X);
    this->FillProfHisto(pSigCorVsPlaneO1T,numO1T,planeSigCorO1T);
    this->FillProfHisto(pSigCorVsPlaneO2,numO2,planeSigCorO2);
    this->FillProfHisto(pSigCorVsPlaneO2X,numO2X,planeSigCorO2X);
    this->FillProfHisto(pSigCorVsPlaneO2T,numO2T,planeSigCorO2T);
    this->FillProfHisto(pSigCorVsPlaneE1,numE1,planeSigCorE1);
    this->FillProfHisto(pSigCorVsPlaneE1X,numE1X,planeSigCorE1X);
    this->FillProfHisto(pSigCorVsPlaneE1T,numE1T,planeSigCorE1T);
    this->FillProfHisto(pSigCorVsPlaneE2,numE2,planeSigCorE2);
    this->FillProfHisto(pSigCorVsPlaneE2X,numE2X,planeSigCorE2X);
    this->FillProfHisto(pSigCorVsPlaneE2T,numE2T,planeSigCorE2T);

    //fill offset profs for individual stripends
    this->FillProfHisto(pSigCorVsOsPlaneO1,numOsO1,planeSigCorO1,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1X,numOsO1X,planeSigCorO1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1T,numOsO1T,planeSigCorO1T,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2,numOsO2,planeSigCorO2,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2X,numOsO2X,planeSigCorO2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2T,numOsO2T,planeSigCorO2T,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1,numOsE1,planeSigCorE1,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1X,numOsE1X,planeSigCorE1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1T,numOsE1T,planeSigCorE1T,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2,numOsE2,planeSigCorE2,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2X,numOsE2X,planeSigCorE2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2T,numOsE2T,planeSigCorE2T,os);

    //section for total event sigcor and mips
    Float_t localSumSigCorTotal=0;
    Float_t localSumSigCorTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeSigCorT.begin();
         sig!=planeSigCorT.end();++sig){
      localSumSigCorTotal+=sig->second;
      localSumSigCorTotalCounter++;
    }

    //add total of this event to the sum of all events 
    if (localSumSigCorTotalCounter!=0){
      sumSigCorTotal+=localSumSigCorTotal;
      sumSigCorTotalCounter++;
    }

    Float_t localSumMipTotal=0;
    Float_t localSumMipTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeMipT.begin();
         sig!=planeMipT.end();++sig){
      localSumMipTotal+=sig->second;
      localSumMipTotalCounter++;
    }

    //add total of this event to the sum of all events 
    if (localSumMipTotalCounter!=0){
      sumMipTotal+=localSumMipTotal;
      sumMipTotalCounter++;
    }

    //section for sliding window
    Int_t minEventLength=35;
    if (fLastPlane<minEventLength) continue;

    //initialise the profile histos
    static Bool_t firstTime=true;
    if (firstTime){
      for (Int_t p=15;p>1;p--){
        vWindowSize.push_back(p);
        bigAv.push_back(0);
        bigAvCounter.push_back(0);
      }

      for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
           windowSize!=vWindowSize.end();++windowSize){
        
        string sName=Form("%d",*windowSize);
        pSigCorVsDist.push_back
          (new TProfile(("pSigCorVsDist"+sName).c_str(),
                        ("pSigCorVsDist"+sName).c_str(),100,-2,40));
      }
    }
    firstTime=false;

    vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
    vector<Float_t>::iterator av=bigAv.begin();
    vector<Int_t>::iterator count=bigAvCounter.begin();
    Float_t localSum15_18=0;
    Float_t localSum15_18Counter=0;
    Float_t localSum15_18Mip=0;
    Float_t localSum15_18MipCounter=0;

    //loop over the different window sizes
    for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
         windowSize!=vWindowSize.end();++windowSize){
      
      //slide the window along from the end to 40-windowSize
      for (Int_t p=0;p<minEventLength-*windowSize;p++){
        Int_t windowStart=fLastPlane-p;

        MSG("CDAnalysis",Msg::kVerbose)
          <<"Window size="<<*windowSize
          <<", window start="<<windowStart
          <<endl;

        //loop through the hits in the window
        for (Int_t i=0;i<*windowSize;i++){
          Int_t plane=windowStart-i;
          
          //cut out planes that are greater than the last plane
          //in the view - ie the zeros at the end
          Bool_t doZeroCorrection=false;
          if (doZeroCorrection && 
              ((plane%2==0 && plane>fLastPlaneEven) || 
               (plane%2!=0 && plane>fLastPlaneOdd))){
            MSG("CDAnalysis",Msg::kVerbose)
              <<"Not using: Event="<<event
              <<", pl="<<plane
              <<", sigCor="<<planeSigCorT[plane]
              <<", fLastPlane="<<fLastPlane
              <<", fLastPlSig="<<planeSigCorT[fLastPlane]
              <<", fLastPlOdd="<<fLastPlaneOdd
              <<", fLastPlEven="<<fLastPlaneEven
              <<endl;
          }
          else{

            //calculate the best window value
            //if fLP=48 then the first plane included is 30
            //this is actually the 19th from the end of the track
            if (*windowSize==15 && windowStart==fLastPlane-18){
              localSum15_18+=planeSigCorT[plane];//total including xtalk
              localSum15_18Counter++;
              localSum15_18Mip+=planeMipT[plane];//total including xtalk
              localSum15_18MipCounter++;

              if (plane%2==0){//even
                
              }
              else if (plane%2==1){//odd

              }

            }

            (*prof)->Fill(p,planeSigCorT[plane]);
            (*av)+=planeSigCorT[plane];
            (*count)++;
          }
        }
      }
      av++;
      count++;
      prof++;
    }

    if (localSum15_18Counter!=0){
      h15_18All->Fill(localSum15_18);
      h15_18->Fill(localSum15_18/15);
      sum15_18+=localSum15_18;//add this event's energy on to total
      sum15_18Counter++;
      sum15_18Mip+=localSum15_18Mip;
      sum15_18MipCounter++;
    }

    if (localSum15_18Counter==0 || localSum15_18<200){
      MAXMSG("CDAnalysis",Msg::kInfo,40)
        <<"Event="<<event<<", strange 15_18="<<localSum15_18
        <<", counter="<<localSum15_18Counter<<endl;
    }

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);

  //all stripends
  string sTitle="Energy Deposition (SigCor, all Stripends)";
  string sXTitle="Distance from end of track (planes)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlane,pSigCorVsPlaneX,
                         pSigCorVsPlaneT,num,numX,numT);
  sTitle="Energy Deposition Vs Distance (SigCor, all Stripends)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlane,pSigCorVsOsPlaneX,
                         pSigCorVsOsPlaneT,numOs,numOsX,numOsT,sXTitle);

  //non-offset planes
  sTitle="Energy Deposition (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO1,pSigCorVsPlaneO1X,
                         pSigCorVsPlaneO1T,numO1,numO1X,numO1T);

  sTitle="Energy Deposition (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO2,pSigCorVsPlaneO2X,
                         pSigCorVsPlaneO2T,numO2,numO2X,numO2T);

  sTitle="Energy Deposition (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE1,pSigCorVsPlaneE1X,
                         pSigCorVsPlaneE1T,numE1,numE1X,numE1T);

  sTitle="Energy Deposition (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE2,pSigCorVsPlaneE2X,
                         pSigCorVsPlaneE2T,numE2,numE2X,numE2T);

  //offset planes
  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO1,pSigCorVsOsPlaneO1X,
                         pSigCorVsOsPlaneO1T,numOsO1,numOsO1X,numOsO1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO2,pSigCorVsOsPlaneO2X,
                         pSigCorVsOsPlaneO2T,numOsO2,numOsO2X,numOsO2T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE1,pSigCorVsOsPlaneE1X,
                         pSigCorVsOsPlaneE1T,numOsE1,numOsE1X,numOsE1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE2,pSigCorVsOsPlaneE2X,
                         pSigCorVsOsPlaneE2T,numOsE2,numOsE2X,numOsE2T,
                         sXTitle);


  //turn on the stats box printing
  gStyle->SetOptStat(11);

  TCanvas *cProf=new TCanvas("cProf","Prof",0,0,1200,800);
  cProf->SetFillColor(0);
  string sName="SlidingWindow.ps";
  cProf->Print((sName+"[").c_str());
  gErrorIgnoreLevel=1;
  //plot the unnormalised prof first
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Average SigCor in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Average SigCor");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
  }

  //now normalise the prof
  vector<Float_t>::iterator av=bigAv.begin();
  vector<Int_t>::iterator count=bigAvCounter.begin();
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){
      
    //normalise the prof and scale the axes
    MSG("CDAnalysis",Msg::kDebug)
      <<"bigCounter="<<*count<<", bigAv="<<*av<<endl;

    //pSigCorVsDistN.push_back
    //(new TProfile(("pSigCorVsDistN"+sName).c_str(),
    //      ("pSigCorVsDistN"+sName).c_str(),100,-2,40));
    if (*av>0) (*prof)->Scale((*count)/(*av));
    (*prof)->SetMaximum(1.2);
    (*prof)->SetMinimum(0.8);
      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Average SigCor in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Average SigCor");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
    av++;
    count++;
  }
  //close the file
  gErrorIgnoreLevel=0;
  cProf->Print((sName+"]").c_str());

  //now do a few profs on the same plot
  TCanvas *cProf2=new TCanvas("cProf2","Prof",0,0,1200,800);
  cProf2->SetFillColor(0);
  sName="SlidingWindowAll.ps";
  //cProf2->Print((sName+"[").c_str());
  Int_t counter=0;
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){

    (*prof)->SetMaximum(1.09);
    (*prof)->SetMinimum(0.96);

    //count which prof got to
    counter++;

    //decide which profs to draw
    static Bool_t firstTime=true;
    if (counter==1 || counter==6 || counter==11){ 
      if (firstTime) {
        (*prof)->Draw();
        firstTime=false;
      }
      else  (*prof)->Draw("sames");

      (*prof)->SetTitle("Average SigCor in Sliding Window");
      (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
      (*prof)->GetYaxis()->SetTitle("Average SigCor");
      (*prof)->GetXaxis()->CenterTitle();
      (*prof)->GetYaxis()->CenterTitle();
      static Int_t color=2;
      (*prof)->SetLineColor(color);
      color+=2;
    }
  }

  //turn off the stats box printing
  //gStyle->SetOptStat(0);
  gStyle->SetOptStat(1111111);

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,3);
  cGeom->cd(1);
  hEventLength2->Draw();
  cGeom->cd(2);
  hEventLength3->Draw();
  cGeom->cd(3);
  hFirstPlane->Draw();
  cGeom->cd(4);
  hEventLength->Draw();
  cGeom->cd(5);
  hNumPlanes->Draw();
  cGeom->cd(6);
  hNumPlanesAll->Draw();
  hNumPlanesMu->Draw("same");
 
  /*
  TCanvas *cCkv=new TCanvas("cCkv","Ckv",0,0,1200,800);
  cCkv->SetFillColor(0);
  cCkv->Divide(2,2);
  cCkv->cd(1);
  hCkvAdcVsRange->Draw("colz");
  hCkvAdcVsRange->Draw("profsame");
  cCkv->cd(2);
  TProfile* p=hCkvAdcVsRange->ProfileX();
  p->Draw();
  cCkv->cd(3);
  hCkvAdcVsRange->Draw("colz");
  p->Draw("sames");
  */

  TCanvas *c15_18=new TCanvas("c15_18","15_18",0,0,1200,800);
  c15_18->SetFillColor(0);
  c15_18->Divide(2,3);
  c15_18->cd(1);
  h15_18->Draw();
  c15_18->cd(2);
  h15_18All->Draw();
  c15_18->cd(3);
  hSigCorTotal->Draw();
  c15_18->cd(4);
  hSigCorTotalTight->Draw();
  c15_18->cd(5);
  hSigCorTotalPeak->Draw();
  c15_18->cd(6);
  pEnVsRange->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<endl
    <<"Mean sigCorTotal="<<hSigCorTotal->GetMean()<<endl
    <<"Ratio ScEn to BeamEn="<<fRatioScEnToBeamEn
    <<" ("<<1/fRatioScEnToBeamEn<<")"<<endl
    <<"GeV per SigCor="<<fScEnDepPerMEU/fSigCorPerMEU<<endl
    <<"Beam energy from Calorimetry (lose)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotal->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl
    <<"Beam energy from Calorimetry (tight)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotalTight->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl
    <<"Beam energy from Calorimetry (peak)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotalPeak->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl<<endl;

  /*
  TCanvas *cXtalk=new TCanvas("cXtalk","Xtalk",0,0,1200,800);
  cXtalk->SetFillColor(0);
  cXtalk->Divide(3,3);
  cXtalk->cd(1);
  hPeVsRange->Draw("colz");
  cXtalk->cd(2);
  hPeVsRangeGen->Draw("colz");
  cXtalk->cd(3);
  hPeVsRangeXTalk->Draw("colz");

  cXtalk->cd(5);
  hPeVsRangeGen2->Draw("colz");
  cXtalk->cd(6);
  hPeVsRangeXTalk2->Draw("colz");
  cXtalk->cd(8);
  hPeVsRangeGen3->Draw("colz");
  cXtalk->cd(9);
  hPeVsRangeXTalk3->Draw("colz");
  */

  Int_t oddEvenSum=lastPlaneEvenCounter+lastPlaneOddCounter;
  Float_t oddPercent=-1;
  Float_t evenPercent=-1;
  if (oddEvenSum) oddPercent=100.*lastPlaneOddCounter/oddEvenSum;
  if (oddEvenSum) evenPercent=100.*lastPlaneEvenCounter/oddEvenSum;

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Last plane, odd="<<lastPlaneOddCounter<<" ("<<oddPercent<<"%)"
    <<", even="<<lastPlaneEvenCounter<<" ("<<evenPercent<<"%)"<<endl;

  Int_t totalSum=lastPlaneE1Counter+lastPlaneE2Counter+
    lastPlaneO1Counter+lastPlaneO2Counter+
    lastPlaneEBothCounter+lastPlaneOBothCounter;
  Float_t e1Percent=-1;
  Float_t e2Percent=-1;
  Float_t o1Percent=-1;
  Float_t o2Percent=-1;
  Float_t eBothPercent=-1;
  Float_t oBothPercent=-1;
  if (totalSum) o1Percent=100.*lastPlaneO1Counter/totalSum;
  if (totalSum) o2Percent=100.*lastPlaneO2Counter/totalSum;
  if (totalSum) e1Percent=100.*lastPlaneE1Counter/totalSum;
  if (totalSum) e2Percent=100.*lastPlaneE2Counter/totalSum;
  if (totalSum) eBothPercent=100.*lastPlaneEBothCounter/totalSum;
  if (totalSum) oBothPercent=100.*lastPlaneOBothCounter/totalSum;

  Float_t totalPercent=o1Percent+o2Percent+e1Percent+e2Percent+
    oBothPercent+eBothPercent;

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Last Plane:"<<endl
    <<"  Total number hits="<<totalSum<<endl
    <<"  Hits on both sides of plane:"<<endl
    <<"    Odd="<<lastPlaneOBothCounter<<" ("<<oBothPercent<<"%)"<<endl
    <<"    Even="<<lastPlaneEBothCounter<<" ("<<eBothPercent<<"%)"<<endl
    <<"  Hits on only one side of plane:"<<endl
    <<"    Odd-ND="<<lastPlaneO2Counter<<" ("<<o2Percent<<"%)"<<endl
    <<"    Odd-FD="<<lastPlaneO1Counter<<" ("<<o1Percent<<"%)"<<endl
    <<"    Even-ND="<<lastPlaneE2Counter<<" ("<<e2Percent<<"%)"<<endl
    <<"    Even-FD="<<lastPlaneE1Counter<<" ("<<e1Percent<<"%)"<<endl
    <<"  Sum of 6 percentages="<<totalPercent<<endl;

  Float_t sharedXTalkPercent=-1;
  Float_t side1XTalkPercent=-1;
  Float_t side2XTalkPercent=-1;
  Float_t doubleXTalkPercent=-1;
  Float_t notGenuineOrXTalkPercent=-1;
  if (sharedPmtCounter) sharedXTalkPercent=100.*sharedPmtXTalkCounter/
                          sharedPmtCounter;
  if (side1Counter) side1XTalkPercent=100.*side1XTalkCounter/
                      side1Counter;
  if (side2Counter) side2XTalkPercent=100.*side2XTalkCounter/
                      side2Counter;
  if (doubleCounter) doubleXTalkPercent=100.*doubleXTalkCounter/
                      doubleCounter;
  if (totalCounter) notGenuineOrXTalkPercent=100.*
                      notGenuineOrXTalkCounter/totalCounter;

  MSG("CDAnalysis",Msg::kInfo) 
    <<endl
    <<"totalCounter="<<totalCounter<<endl
    <<"firstPlaneInPairCounter="<<firstPlaneInPairCounter<<endl
    <<"double="<<doubleCounter
    <<", xtalk="<<doubleXTalkCounter
    <<" ("<<doubleXTalkPercent<<"%)"<<endl
    <<"side1="<<side1Counter
    <<", xtalk="<<side1XTalkCounter
    <<" ("<<side1XTalkPercent<<"%)"<<endl
    <<"side2="<<side2Counter
    <<", xtalk="<<side2XTalkCounter
    <<" ("<<side2XTalkPercent<<"%)"<<endl
    <<"Number of times shared pmt on second of"
    <<" two planes was last plane="
    <<sharedPmtCounter<<endl
    <<"Number of times above was XTalk only="<<sharedPmtXTalkCounter
    <<" ("<<sharedXTalkPercent<<"%)"<<endl
    <<"notGenuineOrXTalkCounter="<<notGenuineOrXTalkCounter
    <<" ("<<notGenuineOrXTalkPercent<<"%)"<<endl;

  MSG("CDAnalysis",Msg::kInfo) 
    <<endl<<"passPidCounter="<<passPidCounter<<endl
    <<"noTrackCounter="<<noTrackCounter
    <<" ("<<Pct(noTrackCounter,passPidCounter)<<"%)"<<endl;
   
  if (sum15_18Counter!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** Calibration Summary **"<<endl
      <<"SigCor in sliding window 15_18:"<<endl
      <<"    SigCor dep="<<sum15_18<<" (N="<<sum15_18Counter<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18/sum15_18Counter
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"    Av SigCor dep per plane="<<(sum15_18/sum15_18Counter)/15
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"MIPs in sliding window 15_18:"<<endl
      <<"    MIPs dep="<<sum15_18Mip
      <<" (N="<<sum15_18MipCounter<<")"<<endl
      <<"    Av MIPs dep="<<sum15_18Mip/sum15_18MipCounter
      <<endl;
    if (sumSigCorTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"SigCor of whole event:"<<endl
        <<"    Sum of SigCor dep="<<sumSigCorTotal
        <<" (N="<<sumSigCorTotalCounter<<")"<<endl
        <<"    Av sigCor dep="
        <<sumSigCorTotal/sumSigCorTotalCounter<<endl
        <<"    1 sigCor="
        <<1800/(sumSigCorTotal/sumSigCorTotalCounter)<<" MeV"
        <<endl;
    }
    if (sumMipTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"MIPs of whole event:"<<endl
        <<"    Sum of MIPs dep="<<sumMipTotal
        <<" (N="<<sumMipTotalCounter<<")"<<endl
        <<"    Av MIPs dep="
        <<sumMipTotal/sumMipTotalCounter<<endl
        <<"    1 MIP="
        <<1800/(sumMipTotal/sumMipTotalCounter)<<" MeV"<<endl
        <<"    1 GeV="
        <<(sumMipTotal/sumMipTotalCounter)/1.8<<" MIPs"
        <<endl<<endl;
    }
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonResponse method **"<<endl;
}

//......................................................................

void CDAnalysis::MuonNearFar()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonNearFar method... **"<<endl;

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"MuonNF");

  TH1F *h15_18All=new TH1F("h15_18All","h15_18All",1000,-2,75);
  h15_18All->GetXaxis()->SetTitle("SigCors");
  h15_18All->GetXaxis()->CenterTitle();
  h15_18All->GetYaxis()->SetTitle("");
  h15_18All->GetYaxis()->CenterTitle();
  h15_18All->SetFillColor(0);
  h15_18All->SetBit(TH1::kCanRebin);

  TH1F *h15_18=new TH1F("h15_18","h15_18",1000,-2,75);
  h15_18->GetXaxis()->SetTitle("SigCors");
  h15_18->GetXaxis()->CenterTitle();
  h15_18->GetYaxis()->SetTitle("");
  h15_18->GetYaxis()->CenterTitle();
  h15_18->SetFillColor(0);
  h15_18->SetBit(TH1::kCanRebin);

  TH1F *h15_18_O1=new TH1F("h15_18_O1","h15_18_O1",1000,-2,75);
  h15_18_O1->GetXaxis()->SetTitle("SigCors");
  h15_18_O1->GetXaxis()->CenterTitle();
  h15_18_O1->GetYaxis()->SetTitle("");
  h15_18_O1->GetYaxis()->CenterTitle();
  h15_18_O1->SetFillColor(0);
  h15_18_O1->SetBit(TH1::kCanRebin);

  TH1F *h15_18_E1=new TH1F("h15_18_E1","h15_18_E1",1000,-2,75);
  h15_18_E1->GetXaxis()->SetTitle("SigCors");
  h15_18_E1->GetXaxis()->CenterTitle();
  h15_18_E1->GetYaxis()->SetTitle("");
  h15_18_E1->GetYaxis()->CenterTitle();
  h15_18_E1->SetFillColor(0);
  h15_18_E1->SetBit(TH1::kCanRebin);

  TH1F *h15_18_O2=new TH1F("h15_18_O2","h15_18_O2",1000,-2,75);
  h15_18_O2->GetXaxis()->SetTitle("SigCors");
  h15_18_O2->GetXaxis()->CenterTitle();
  h15_18_O2->GetYaxis()->SetTitle("");
  h15_18_O2->GetYaxis()->CenterTitle();
  h15_18_O2->SetFillColor(0);
  h15_18_O2->SetBit(TH1::kCanRebin);

  TH1F *h15_18_E2=new TH1F("h15_18_E2","h15_18_E2",1000,-2,75);
  h15_18_E2->GetXaxis()->SetTitle("SigCors");
  h15_18_E2->GetXaxis()->CenterTitle();
  h15_18_E2->GetYaxis()->SetTitle("");
  h15_18_E2->GetYaxis()->CenterTitle();
  h15_18_E2->SetFillColor(0);
  h15_18_E2->SetBit(TH1::kCanRebin);

  //sum of all strip ends, normal and offset planes
  //tracked
  TProfile* pSigCorVsPlane=new TProfile("pSigCorVsPlane",
                                        "pSigCorVsPlane",
                                        62,0,62);
  TProfile* pSigCorVsOsPlane=new TProfile("pSigCorVsOsPlane",
                                          "pSigCorVsOsPlane",
                                          62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneX=new TProfile("pSigCorVsPlaneX",
                                         "pSigCorVsPlaneX",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneX=new TProfile("pSigCorVsOsPlaneX",
                                           "pSigCorVsOsPlaneX",
                                           62,0,62);

  //total
  TProfile* pSigCorVsPlaneT=new TProfile("pSigCorVsPlaneT",
                                         "pSigCorVsPlaneT",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneT=new TProfile("pSigCorVsOsPlaneT",
                                           "pSigCorVsOsPlaneT",
                                           62,0,62);

  //individual strip ends
  //tracked
  TProfile* pSigCorVsPlaneO1=new TProfile("pSigCorVsPlaneO1",
                                          "pSigCorVsPlaneO1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2=new TProfile("pSigCorVsPlaneO2",
                                          "pSigCorVsPlaneO2",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1=new TProfile("pSigCorVsPlaneE1",
                                          "pSigCorVsPlaneE1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2=new TProfile("pSigCorVsPlaneE2",
                                          "pSigCorVsPlaneE2",
                                          62,0,62);
  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneO1X=new TProfile("pSigCorVsPlaneO1X",
                                          "pSigCorVsPlaneO1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2X=new TProfile("pSigCorVsPlaneO2X",
                                          "pSigCorVsPlaneO2X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1X=new TProfile("pSigCorVsPlaneE1X",
                                          "pSigCorVsPlaneE1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2X=new TProfile("pSigCorVsPlaneE2X",
                                          "pSigCorVsPlaneE2X",
                                          62,0,62);
  //total
  TProfile* pSigCorVsPlaneO1T=new TProfile("pSigCorVsPlaneO1T",
                                          "pSigCorVsPlaneO1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2T=new TProfile("pSigCorVsPlaneO2T",
                                          "pSigCorVsPlaneO2T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1T=new TProfile("pSigCorVsPlaneE1T",
                                          "pSigCorVsPlaneE1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2T=new TProfile("pSigCorVsPlaneE2T",
                                          "pSigCorVsPlaneE2T",
                                          62,0,62);

  //individual strip ends - offset planes
  //tracked
  TProfile* pSigCorVsOsPlaneO1=new TProfile("pSigCorVsOsPlaneO1",
                                            "pSigCorVsOsPlaneO1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2=new TProfile("pSigCorVsOsPlaneO2",
                                            "pSigCorVsOsPlaneO2",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1=new TProfile("pSigCorVsOsPlaneE1",
                                            "pSigCorVsOsPlaneE1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2=new TProfile("pSigCorVsOsPlaneE2",
                                            "pSigCorVsOsPlaneE2",
                                            62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsOsPlaneO1X=new TProfile("pSigCorVsOsPlaneO1X",
                                             "pSigCorVsOsPlaneO1X",
                                             62,0,62);
  TProfile* pSigCorVsOsPlaneO2X=new TProfile("pSigCorVsOsPlaneO2X",
                                            "pSigCorVsOsPlaneO2X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1X=new TProfile("pSigCorVsOsPlaneE1X",
                                            "pSigCorVsOsPlaneE1X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2X=new TProfile("pSigCorVsOsPlaneE2X",
                                            "pSigCorVsOsPlaneE2X",
                                            62,0,62);
  //total
  TProfile* pSigCorVsOsPlaneO1T=new TProfile("pSigCorVsOsPlaneO1T",
                                            "pSigCorVsOsPlaneO1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2T=new TProfile("pSigCorVsOsPlaneO2T",
                                            "pSigCorVsOsPlaneO2T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1T=new TProfile("pSigCorVsOsPlaneE1T",
                                            "pSigCorVsOsPlaneE1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2T=new TProfile("pSigCorVsOsPlaneE2T",
                                            "pSigCorVsOsPlaneE2T",
                                            62,0,62);


  //near/far differences
  TProfile* pNearFarOdd=new TProfile("pNearFarOdd",
                                     "pNearFarOdd",62,0,62);
  TProfile* pNearFarEven=new TProfile("pNearFarEven",
                                      "pNearFarEven",62,0,62);


  vector<TProfile*> pSigCorVsDist;
  vector<Int_t> vWindowSize;
  vector<Float_t> bigAv;
  vector<Int_t> bigAvCounter;
  Float_t sum15_18=0;
  Float_t sum15_18Counter=0;
  Float_t sum15_18Mip=0;
  Float_t sum15_18MipCounter=0;
  Float_t sumSigCorTotal=0;
  Float_t sumSigCorTotalCounter=0;
  Float_t sumMipTotal=0;
  Float_t sumMipTotalCounter=0;

  //variables to calculate the energy dep for different stripends
  Float_t sum15_18_O1=0;
  Float_t sum15_18CounterO1=0;
  Float_t sum15_18_O2=0;
  Float_t sum15_18CounterO2=0;
  Float_t sum15_18_E1=0;
  Float_t sum15_18CounterE1=0;
  Float_t sum15_18_E2=0;
  Float_t sum15_18CounterE2=0;

  //num maps for all stripends
  map<Int_t,Float_t> num;
  map<Int_t,Float_t> numX;
  map<Int_t,Float_t> numT;
  map<Int_t,Float_t> numOs;
  map<Int_t,Float_t> numOsX;
  map<Int_t,Float_t> numOsT;

  //non-offset num maps for individual stripends
  map<Int_t,Float_t> numO1;
  map<Int_t,Float_t> numO1X;
  map<Int_t,Float_t> numO1T;
  map<Int_t,Float_t> numO2;
  map<Int_t,Float_t> numO2X;
  map<Int_t,Float_t> numO2T;
  map<Int_t,Float_t> numE1;
  map<Int_t,Float_t> numE1X;
  map<Int_t,Float_t> numE1T;
  map<Int_t,Float_t> numE2;
  map<Int_t,Float_t> numE2X;
  map<Int_t,Float_t> numE2T;

  //offset num maps for individual stripends
  map<Int_t,Float_t> numOsO1;
  map<Int_t,Float_t> numOsO1X;
  map<Int_t,Float_t> numOsO1T;
  map<Int_t,Float_t> numOsO2;
  map<Int_t,Float_t> numOsO2X;
  map<Int_t,Float_t> numOsO2T;
  map<Int_t,Float_t> numOsE1;
  map<Int_t,Float_t> numOsE1X;
  map<Int_t,Float_t> numOsE1T;
  map<Int_t,Float_t> numOsE2;
  map<Int_t,Float_t> numOsE2X;
  map<Int_t,Float_t> numOsE2T;

  Int_t noTrackCounter=0;
  Int_t passPidCounter=0;
 
  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;

    //cut on not straight tracks
    //Double_t mainX1Cut=0.5;
    //if (!this->IsStraightTrack(mainX1Cut)){
    //continue;
    //}

    //count the number of events passing the pid
    passPidCounter++;

    map<Int_t,Int_t> numPlanesHit;
    map<Int_t,Int_t> numPlanesHit1;
    map<Int_t,Int_t> numPlanesHit2;
    map<Int_t,Int_t> numPlanesHitAll;
    map<Int_t,Float_t> planeSigCor;
    map<Int_t,Float_t> planeSigCorX;
    map<Int_t,Float_t> planeSigCorT;
    map<Int_t,Float_t> planeSigCorO1;    
    map<Int_t,Float_t> planeSigCorO1X;
    map<Int_t,Float_t> planeSigCorO1T;
    map<Int_t,Float_t> planeSigCorO2;
    map<Int_t,Float_t> planeSigCorO2X;
    map<Int_t,Float_t> planeSigCorO2T;
    map<Int_t,Float_t> planeSigCorE1;
    map<Int_t,Float_t> planeSigCorE1X;
    map<Int_t,Float_t> planeSigCorE1T;
    map<Int_t,Float_t> planeSigCorE2;
    map<Int_t,Float_t> planeSigCorE2X;
    map<Int_t,Float_t> planeSigCorE2T;

    map<Int_t,Float_t> planeMip;
    map<Int_t,Float_t> planeMipX;
    map<Int_t,Float_t> planeMipT;

    map<Int_t,Float_t> planePe;
    map<Int_t,Float_t> planeGreatestPe;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
    //TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=0;
    if (fTruthHitInfo) numTruthHits=fTruthHitInfo->GetEntries();

    //look for untracked big events
    if (numTrkHits<2 && numXTalkHits+numUnTrkHits>1){
      MSG("CDAnalysis",Msg::kDebug)
        <<"Event="<<event
        <<", Num hits: trk="<<numTrkHits<<", unTrk="<<numUnTrkHits
        <<", xtalk="<<numXTalkHits<<", truth="<<numTruthHits
        <<endl;
      noTrackCounter++;
      //continue;
    }

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      if (fPlane==0 && fChargeSigCor>1000){
        MSG("CDAnalysis",Msg::kDebug)
          <<"XTalk Event="<<event
          <<", fPlane="<<fPlane
          <<", fStrip="<<fStrip
          <<", fStripend="<<fStripend
          <<", fChargeAdc="<<fChargeAdc
          <<", fSigCor="<<fChargeSigCor<<endl;
      }

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      //check the channel's sanity
      this->StandardSanityChecks();

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      //check the channel's sanity
      this->StandardSanityChecks();

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;
    }

    Bool_t lastPlaneO1Hit=false;
    Bool_t lastPlaneO2Hit=false;
    Bool_t lastPlaneE1Hit=false;
    Bool_t lastPlaneE2Hit=false;
    Int_t previousfLastPlane=-1;

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      //count the number of planes hit
      numPlanesHit[fPlane]++;
      numPlanesHitAll[fPlane]++;

     if (fLastPlane==fPlane && fPlane%2==0){

        //check if a new last plane has been found
        if (fLastPlane!=previousfLastPlane){
          lastPlaneE1Hit=false;
          lastPlaneE2Hit=false;
        }
        previousfLastPlane=fLastPlane;

        //check which stripend to set to true
        if (fStripend==1) lastPlaneE1Hit=true;
        if (fStripend==2) lastPlaneE2Hit=true;

        //set the hits in the other plane to be false
        lastPlaneO1Hit=false;
        lastPlaneO2Hit=false;
        MSG("CDAnalysis",Msg::kVerbose)
          <<"ev="<<event
          <<", last="<<fLastPlane
          <<", pl="<<fPlane
          <<", se="<<fStripend
          <<", E1="<<lastPlaneE1Hit
          <<", E2="<<lastPlaneE2Hit
          <<", O1="<<lastPlaneO1Hit
          <<", O2="<<lastPlaneO2Hit<<endl;
      }
      else if (fLastPlane==fPlane && fPlane%2==1){

        //check if a new last plane has been found
        if (fLastPlane!=previousfLastPlane){
          lastPlaneO1Hit=false;
          lastPlaneO2Hit=false;
        }
        previousfLastPlane=fLastPlane;

        //check which stripend to set to true
        if (fStripend==1) lastPlaneO1Hit=true;
        if (fStripend==2) lastPlaneO2Hit=true;

        //set the hits in the other plane to be false
        lastPlaneE1Hit=false;
        lastPlaneE2Hit=false;

        MSG("CDAnalysis",Msg::kVerbose)
          <<"ev="<<event
          <<", last="<<fLastPlane
          <<", pl="<<fPlane
          <<", se="<<fStripend
          <<", E1="<<lastPlaneE1Hit
          <<", E2="<<lastPlaneE2Hit
          <<", O1="<<lastPlaneO1Hit
          <<", O2="<<lastPlaneO2Hit<<endl;
      }

      //add up the charge of the hits in each plane
      planeSigCor[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMip[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fChargePe>planeGreatestPe[fPlane]) planeGreatestPe[fPlane]=
                                               fChargePe;
      planePe[fPlane]+=fChargePe;
      if (fO1) planeSigCorO1[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;
    }
    //end of loop over the tracked hits

    //make sure that the first plane makes sense and was actually set
    if (fFirstPlane<0 || fFirstPlane>59) continue;

    //calc the last plane on the track with no xtalk
    //Int_t lastPlaneNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();

    //make event length cuts
    if (this->CutOnEventLength()) continue;
    //make track quality cuts
    if (this->CutOnTrackQuality()) continue;

    //section for response
    const Int_t os=fLastPlane;

    //must fill the profs before looping over the maps because
    //zeros will get added to the maps at the window stage!
    //fill profs for all stripends
    this->FillProfHisto(pSigCorVsPlane,num,planeSigCor);
    this->FillProfHisto(pSigCorVsPlaneX,numX,planeSigCorX);
    this->FillProfHisto(pSigCorVsPlaneT,numT,planeSigCorT);
    //offset
    this->FillProfHisto(pSigCorVsOsPlane,numOs,planeSigCor,os);
    this->FillProfHisto(pSigCorVsOsPlaneX,numOsX,planeSigCorX,os);
    this->FillProfHisto(pSigCorVsOsPlaneT,numOsT,planeSigCorT,os);

    //fill non-offset profs for individual stripends
    this->FillProfHisto(pSigCorVsPlaneO1,numO1,planeSigCorO1);
    this->FillProfHisto(pSigCorVsPlaneO1X,numO1X,planeSigCorO1X);
    this->FillProfHisto(pSigCorVsPlaneO1T,numO1T,planeSigCorO1T);
    this->FillProfHisto(pSigCorVsPlaneO2,numO2,planeSigCorO2);
    this->FillProfHisto(pSigCorVsPlaneO2X,numO2X,planeSigCorO2X);
    this->FillProfHisto(pSigCorVsPlaneO2T,numO2T,planeSigCorO2T);
    this->FillProfHisto(pSigCorVsPlaneE1,numE1,planeSigCorE1);
    this->FillProfHisto(pSigCorVsPlaneE1X,numE1X,planeSigCorE1X);
    this->FillProfHisto(pSigCorVsPlaneE1T,numE1T,planeSigCorE1T);
    this->FillProfHisto(pSigCorVsPlaneE2,numE2,planeSigCorE2);
    this->FillProfHisto(pSigCorVsPlaneE2X,numE2X,planeSigCorE2X);
    this->FillProfHisto(pSigCorVsPlaneE2T,numE2T,planeSigCorE2T);

    //fill offset profs for individual stripends
    this->FillProfHisto(pSigCorVsOsPlaneO1,numOsO1,planeSigCorO1,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1X,numOsO1X,planeSigCorO1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1T,numOsO1T,planeSigCorO1T,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2,numOsO2,planeSigCorO2,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2X,numOsO2X,planeSigCorO2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2T,numOsO2T,planeSigCorO2T,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1,numOsE1,planeSigCorE1,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1X,numOsE1X,planeSigCorE1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1T,numOsE1T,planeSigCorE1T,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2,numOsE2,planeSigCorE2,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2X,numOsE2X,planeSigCorE2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2T,numOsE2T,planeSigCorE2T,os);

    //section for total event sigcor and mips
    Float_t localSumSigCorTotal=0;
    Float_t localSumSigCorTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeSigCorT.begin();
         sig!=planeSigCorT.end();++sig){
      localSumSigCorTotal+=sig->second;
      localSumSigCorTotalCounter++;
    }

    //add total of this event to the sum of all events 
    if (localSumSigCorTotalCounter!=0){
      sumSigCorTotal+=localSumSigCorTotal;
      sumSigCorTotalCounter++;
    }

    Float_t localSumMipTotal=0;
    Float_t localSumMipTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeMipT.begin();
         sig!=planeMipT.end();++sig){
      localSumMipTotal+=sig->second;
      localSumMipTotalCounter++;
    }

    //add total of this event to the sum of all events 
    if (localSumMipTotalCounter!=0){
      sumMipTotal+=localSumMipTotal;
      sumMipTotalCounter++;
    }

    //section for sliding window
    Int_t minEventLength=35;
    if (fLastPlane<minEventLength) continue;

    //initialise the profile histos
    static Bool_t firstTime=true;
    if (firstTime){
      for (Int_t p=15;p>1;p--){
        vWindowSize.push_back(p);
        bigAv.push_back(0);
        bigAvCounter.push_back(0);
      }

      for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
           windowSize!=vWindowSize.end();++windowSize){
        
        string sName=Form("%d",*windowSize);
        pSigCorVsDist.push_back
          (new TProfile(("pSigCorVsDist"+sName).c_str(),
                        ("pSigCorVsDist"+sName).c_str(),100,-2,40));
      }
    }
    firstTime=false;

    vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
    vector<Float_t>::iterator av=bigAv.begin();
    vector<Int_t>::iterator count=bigAvCounter.begin();
    Float_t localSum15_18=0;
    Float_t localSum15_18Counter=0;
    Float_t localSum15_18Mip=0;
    Float_t localSum15_18MipCounter=0;

    Float_t localSum15_18_O1=0;
    Float_t localSum15_18CounterO1=0;
    Float_t localSum15_18_O2=0;
    Float_t localSum15_18CounterO2=0;
    Float_t localSum15_18_E1=0;
    Float_t localSum15_18CounterE1=0;
    Float_t localSum15_18_E2=0;
    Float_t localSum15_18CounterE2=0;
    Bool_t oneMoreEvenPlane=false;

    //loop over the different window sizes
    for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
         windowSize!=vWindowSize.end();++windowSize){
      
      Float_t localSumO1=0;
      Float_t localSumCounterO1=0;
      Float_t localSumO2=0;
      Float_t localSumCounterO2=0;
      Float_t localSumE1=0;
      Float_t localSumCounterE1=0;
      Float_t localSumE2=0;
      Float_t localSumCounterE2=0;

      //slide the window along from the end to 40-windowSize
      for (Int_t p=0;p<minEventLength-*windowSize;p++){
        Int_t windowStart=fLastPlane-p;

        MSG("CDAnalysis",Msg::kVerbose)
          <<"Window size="<<*windowSize
          <<", window start="<<windowStart
          <<endl;

        //loop through the hits in the window
        for (Int_t i=0;i<*windowSize;i++){
          Int_t plane=windowStart-i;
          
          //cut out planes that are greater than the last plane
          //in the view - ie the zeros at the end
          Bool_t doZeroCorrection=false;
          if (doZeroCorrection && 
              ((plane%2==0 && plane>fLastPlaneEven) || 
               (plane%2!=0 && plane>fLastPlaneOdd))){
            MSG("CDAnalysis",Msg::kVerbose)
              <<"Not using: Event="<<event
              <<", pl="<<plane
              <<", sigCor="<<planeSigCorT[plane]
              <<", fLastPlane="<<fLastPlane
              <<", fLastPlSig="<<planeSigCorT[fLastPlane]
              <<", fLastPlOdd="<<fLastPlaneOdd
              <<", fLastPlEven="<<fLastPlaneEven
              <<endl;
          }
          else{

            //calculate the best window value
            //if fLP=48 then the first plane included is 30
            //this is actually the 19th from the end of the track
            if (*windowSize==15 && windowStart==fLastPlane-18){
              localSum15_18+=planeSigCorT[plane];//total including xtalk
              localSum15_18Counter++;
              localSum15_18Mip+=planeMipT[plane];//total including xtalk
              localSum15_18MipCounter++;

              //a 15 plane window means 7 even and 8 odd or vice versa!
              if (windowStart%2==0) oneMoreEvenPlane=true;

              //look at the individual stripends
              if (plane%2==0){//even
                localSum15_18_E1+=planeSigCorE1T[plane];
                localSum15_18CounterE1++;
                localSum15_18_E2+=planeSigCorE2T[plane];
                localSum15_18CounterE2++;
              }
              else if (plane%2==1){//odd
                localSum15_18_O1+=planeSigCorO1T[plane];
                localSum15_18CounterO1++;
                localSum15_18_O2+=planeSigCorO2T[plane];
                localSum15_18CounterO2++;
              }
            }


            if (*windowSize==15){
              //look at the individual stripends
              if (plane%2==0){//even
                localSumE1+=planeSigCorE1T[plane];
                localSumCounterE1++;
                localSumE2+=planeSigCorE2T[plane];
                localSumCounterE2++;
              }
              else if (plane%2==1){//odd
                localSumO1+=planeSigCorO1T[plane];
                localSumCounterO1++;
                localSumO2+=planeSigCorO2T[plane];
                localSumCounterO2++;
              }
            }

            (*prof)->Fill(p,planeSigCorT[plane]);
            (*av)+=planeSigCorT[plane];
            (*count)++;
          }
        }

        //calculate the near/far differences
        if (*windowSize==15){

          //a 15 plane window means 7 even and 8 odd or vice versa!
          Bool_t moreEven=false;
          if (windowStart%2==0) moreEven=true;
          Float_t divEven=1;
          Float_t divOdd=1;

          if (moreEven) {divEven=8; divOdd=7;}
          else {divEven=7; divOdd=8;}

          MAXMSG("CDAnalysis",Msg::kVerbose,70)
            <<"WindowStart="<<windowStart<<", moreEven="<<moreEven
            <<", divEven="<<divEven<<", divOdd="<<divOdd
            <<endl;
    
          Float_t largestOdd=localSumO1/divOdd;
          Float_t largestEven=localSumE1/divEven;
          
          if (localSumO2/divOdd>localSumO1/divOdd){
            largestOdd=localSumO2/divOdd;
          }
          if (localSumE2/divEven>localSumE1/divEven){
            largestEven=localSumE2/divEven;
          }

          //protect fpe
          if (largestOdd>0){
            Float_t diffNearFarOdd=100*(localSumO1/divOdd-
                                        localSumO2/divOdd)/largestOdd;
            pNearFarOdd->Fill(p,diffNearFarOdd);
          }
          if (largestEven>0){
            Float_t diffNearFarEven=100*(localSumE1/divEven-
                                         localSumE2/divEven
                                         )/largestEven;
            pNearFarEven->Fill(p,diffNearFarEven);
          }      
        }
      }
      av++;
      count++;
      prof++;
    }

    if (localSum15_18Counter!=0){
      h15_18All->Fill(localSum15_18);
      h15_18->Fill(localSum15_18/15);
      sum15_18+=localSum15_18;//add this event's energy on to total
      sum15_18Counter++;
      sum15_18Mip+=localSum15_18Mip;
      sum15_18MipCounter++;
    }
    else{
      MAXMSG("CDAnalysis",Msg::kInfo,40)
        <<"Event="<<event<<", strange 15_18="<<localSum15_18
        <<", counter="<<localSum15_18Counter<<endl;
    }

    Float_t divEven=1;
    Float_t divOdd=1;
    
    if (oneMoreEvenPlane) {divEven=8; divOdd=7;}
    else {divEven=7; divOdd=8;}
    
    h15_18_O1->Fill(localSum15_18_O1/divOdd);
    sum15_18_O1+=localSum15_18_O1/divOdd;
    sum15_18CounterO1++;
    h15_18_O2->Fill(localSum15_18_O2/divOdd);
    sum15_18_O2+=localSum15_18_O2/divOdd;
    sum15_18CounterO2++;
    
    h15_18_E1->Fill(localSum15_18_E1/divEven);
    sum15_18_E1+=localSum15_18_E1/divEven;
    sum15_18CounterE1++;
    h15_18_E2->Fill(localSum15_18_E2/divEven);
    sum15_18_E2+=localSum15_18_E2/divEven;
    sum15_18CounterE2++;

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);

  //all stripends
  string sTitle="Energy Deposition (SigCor, all Stripends)";
  string sXTitle="Distance from end of track (planes)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlane,pSigCorVsPlaneX,
                         pSigCorVsPlaneT,num,numX,numT);
  sTitle="Energy Deposition Vs Distance (SigCor, all Stripends)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlane,pSigCorVsOsPlaneX,
                         pSigCorVsOsPlaneT,numOs,numOsX,numOsT,sXTitle);

  //non-offset planes
  sTitle="Energy Deposition (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO1,pSigCorVsPlaneO1X,
                         pSigCorVsPlaneO1T,numO1,numO1X,numO1T);

  sTitle="Energy Deposition (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO2,pSigCorVsPlaneO2X,
                         pSigCorVsPlaneO2T,numO2,numO2X,numO2T);

  sTitle="Energy Deposition (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE1,pSigCorVsPlaneE1X,
                         pSigCorVsPlaneE1T,numE1,numE1X,numE1T);

  sTitle="Energy Deposition (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE2,pSigCorVsPlaneE2X,
                         pSigCorVsPlaneE2T,numE2,numE2X,numE2T);

  //offset planes
  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO1,pSigCorVsOsPlaneO1X,
                         pSigCorVsOsPlaneO1T,numOsO1,numOsO1X,numOsO1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO2,pSigCorVsOsPlaneO2X,
                         pSigCorVsOsPlaneO2T,numOsO2,numOsO2X,numOsO2T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE1,pSigCorVsOsPlaneE1X,
                         pSigCorVsOsPlaneE1T,numOsE1,numOsE1X,numOsE1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE2,pSigCorVsOsPlaneE2X,
                         pSigCorVsOsPlaneE2T,numOsE2,numOsE2X,numOsE2T,
                         sXTitle);

  //turn on the stats box printing
  gStyle->SetOptStat(111111);

  TCanvas *c15_18=new TCanvas("c15_18","15_18",0,0,1200,800);
  c15_18->SetFillColor(0);
  c15_18->Divide(2,3);
  c15_18->cd(1);
  h15_18->Draw();
  c15_18->cd(2);
  h15_18All->Draw();
  c15_18->cd(3);
  h15_18_O1->Draw();
  c15_18->cd(4);
  h15_18_O2->Draw();
  c15_18->cd(5);
  h15_18_E1->Draw();
  c15_18->cd(6);
  h15_18_E2->Draw();

  TCanvas *cNearFar=new TCanvas("cNearFar","NearFar",0,0,1200,800);
  cNearFar->SetFillColor(0);
  cNearFar->Divide(2,3);
  cNearFar->cd(1);
  pNearFarOdd->Draw();
  cNearFar->cd(2);
  pNearFarEven->Draw();

  if (sum15_18Counter!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** Calibration Summary **"<<endl
      <<"SigCor in sliding window 15_18:"<<endl
      <<"    SigCor dep="<<sum15_18<<" (N="<<sum15_18Counter<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18/sum15_18Counter
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"    Av SigCor dep per plane="<<(sum15_18/sum15_18Counter)/15
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"MIPs in sliding window 15_18:"<<endl
      <<"    MIPs dep="<<sum15_18Mip
      <<" (N="<<sum15_18MipCounter<<")"<<endl
      <<"    Av MIPs dep="<<sum15_18Mip/sum15_18MipCounter
      <<endl;
    if (sumSigCorTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"SigCor of whole event:"<<endl
        <<"    Sum of SigCor dep="<<sumSigCorTotal
        <<" (N="<<sumSigCorTotalCounter<<")"<<endl
        <<"    Av sigCor dep="
        <<sumSigCorTotal/sumSigCorTotalCounter<<endl
        <<"    1 sigCor="
        <<1800/(sumSigCorTotal/sumSigCorTotalCounter)<<" MeV"
        <<endl;
    }
    if (sumMipTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"MIPs of whole event:"<<endl
        <<"    Sum of MIPs dep="<<sumMipTotal
        <<" (N="<<sumMipTotalCounter<<")"<<endl
        <<"    Av MIPs dep="
        <<sumMipTotal/sumMipTotalCounter<<endl
        <<"    1 MIP="
        <<1800/(sumMipTotal/sumMipTotalCounter)<<" MeV"<<endl
        <<"    1 GeV="
        <<(sumMipTotal/sumMipTotalCounter)/1.8<<" MIPs"
        <<endl<<endl;
    }
  }

  if (sum15_18CounterO1!=0 && sum15_18CounterE1!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<"SigCor in sliding window 15_18 in stripend 1:"<<endl
      <<" Odd planes:"<<endl
      <<"    SigCor dep="<<sum15_18_O1
      <<" (N="<<sum15_18CounterO1<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18_O1/sum15_18CounterO1
      <<" +/- "<<h15_18_O1->GetRMS()/sqrt(h15_18_O1->GetEntries())
      <<" ("<<100*((h15_18_O1->GetRMS()/
                   sqrt(h15_18_O1->GetEntries()))/
                   h15_18_O1->GetMean())<<"%)"
      <<endl
      <<" Even planes:"<<endl
      <<"    SigCor dep="<<sum15_18_E1
      <<" (N="<<sum15_18CounterE1<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18_E1/sum15_18CounterE1
      <<" +/- "<<h15_18_E1->GetRMS()/sqrt(h15_18_E1->GetEntries())
      <<" ("<<100*((h15_18_E1->GetRMS()/
                   sqrt(h15_18_E1->GetEntries()))/
                   h15_18_E1->GetMean())<<"%)"<<endl
      <<endl;
  }
  if (sum15_18CounterO2!=0 && sum15_18CounterE2!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<"SigCor in sliding window 15_18 in stripend 2:"<<endl
      <<" Odd planes:"<<endl
      <<"    SigCor dep="<<sum15_18_O2
      <<" (N="<<sum15_18CounterO2<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18_O2/sum15_18CounterO2
      <<" +/- "<<h15_18_O2->GetRMS()/sqrt(h15_18_O2->GetEntries())
      <<" ("<<100*((h15_18_O2->GetRMS()/
                   sqrt(h15_18_O2->GetEntries()))/
                   h15_18_O2->GetMean())<<"%)"
      <<endl
      <<" Even planes:"<<endl
      <<"    SigCor dep="<<sum15_18_E2
      <<" (N="<<sum15_18CounterE2<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18_E2/sum15_18CounterE2
      <<" +/- "<<h15_18_E2->GetRMS()/sqrt(h15_18_E2->GetEntries())
      <<" ("<<100*((h15_18_E2->GetRMS()/
                   sqrt(h15_18_E2->GetEntries()))/
                   h15_18_E2->GetMean())<<"%)"<<endl
      <<endl;
  }

  //calculate the differences between near/far
  if (sum15_18CounterO2!=0 && sum15_18CounterE2!=0 &&
      sum15_18CounterO1!=0 && sum15_18CounterE1!=0){

    Float_t largestOdd=sum15_18_O1/sum15_18CounterO1;
    Float_t largestEven=sum15_18_E1/sum15_18CounterE1;
    Float_t diffOdd=sum15_18_O1/sum15_18CounterO1-
      sum15_18_O2/sum15_18CounterO2;
    Float_t diffEven=sum15_18_E1/sum15_18CounterE1-
      sum15_18_E2/sum15_18CounterE2;

    if (sum15_18_O2/sum15_18CounterO2>sum15_18_O1/sum15_18CounterO1) {
      largestOdd=sum15_18_O2/sum15_18CounterO2;
    }
    if (sum15_18_E2/sum15_18CounterE2>sum15_18_E1/sum15_18CounterE1) {
      largestEven=sum15_18_E2/sum15_18CounterE2;
    }
    
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<"Difference between stripend 1 and 2 (1-2/largest):"<<endl
      <<" Odd planes:"<<endl
      <<"    Difference="<<diffOdd<<" ("<<100*diffOdd/largestOdd<<"%)"
      <<endl
      <<" Even planes:"<<endl
      <<"    Difference="<<diffEven<<" ("
      <<100*diffEven/largestEven<<"%)"
      <<endl;
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonNearFar method **"<<endl;

}

//......................................................................

Float_t CDAnalysis::ReCalibrate(Float_t chargeAdc,Int_t plane,
                                Int_t strip,Int_t stripend) const
{
  if (fDoReCalibration && fSimFlag==SimFlag::kData){
    MAXMSG("CDAnalysis",Msg::kInfo,10)
      <<"Running ReCalibrate: fSec="<<fSec
      <<", simFlag="<<fSimFlag<<endl;
    
    //get a calibrator
    Calibrator& cal=Calibrator::Instance();
    //VldTimeStamp (const time_t &t, const Int_t nsec)
    VldTimeStamp vldts(fSec,0);
    VldContext vc(Detector::kCalDet,fSimFlag,vldts);
    cal.ReInitialise(vc);
    MAXMSG("CDAnalysis",Msg::kVerbose,100)
      <<"Calibrator reinitialised sucessfully"<<endl;
    
    //get the seid
    PlexStripEndId seid(Detector::kCalDet,plane,strip,
                        static_cast<StripEnd::EStripEnd>(stripend));
    
    MAXMSG("CDAnalysis",Msg::kVerbose,100)
      <<"Now calibrating drift..."<<endl;
    //now calibrate: first drift, then sts
    Float_t tmpCharge=chargeAdc;
    tmpCharge=cal.GetDriftCorrected(tmpCharge,seid);
    MAXMSG("CDAnalysis",Msg::kVerbose,100)
    <<"Now calibrating sts..."<<endl;
    tmpCharge=cal.GetStripToStripCorrected(tmpCharge,seid);
    
    MAXMSG("CDAnalysis",Msg::kInfo,50)
      <<"ReCalibrate: fChargeSigCor="<<fChargeSigCor
      <<", newSigCor="<<tmpCharge
      <<", temperature="<<cal.GetTemperature()<<endl;
    
    //return the newly calibrated number
    return tmpCharge;
  }
  else {
    //just return the original value of sigcor
    return fChargeSigCor;
  }
}

//......................................................................

void CDAnalysis::StoppingMuonCalibration()
{
  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"StopMuCal");

  //set the recalibration flag
  fDoReCalibration=false;

  VldTimeStamp ts;
  cout<<"Time in secs right now is:"<<ts.GetSec()<<endl;
  Int_t minRunTime=4;//is:1112976714
  if (ts.GetSec()>minRunTime){
    //analyse the electrons and fill histos
    this->ElectronResponse();
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running StoppingMuonCalibration method... **"<<endl;

  vector<TH1F*> meuHistos(60);
  vector<TH1F*> sigCorNoPLCorHistos(60);
  //vector<TH1F*> adcNoPLCorHistos(60);//no adc info stored: June 2007
  for (Int_t i=0;i<60;i++){
    string sName="hMeuPlane";
    string sNameSigCor="hSigCorNoPLCorPlane";
    //string sNameAdc="hAdcNoPLCorPlane";
    string sNum=Form("%d",i);
    sName+=sNum;
    sNameSigCor+=sNum;
    //sNameAdc+=sNum;

    meuHistos[i]=new TH1F(sName.c_str(),sName.c_str(),300,-2,3000);
    meuHistos[i]->SetBit(TH1::kCanRebin);//leave this as is June/07
    //meuHistos[i]->Print();

    //added sigcor in June 2007
    sigCorNoPLCorHistos[i]=new TH1F
      (sNameSigCor.c_str(),sNameSigCor.c_str(),300,-2,3000);
    //adcNoPLCorHistos[i]=new TH1F
    //(sName.c_str(),sName.c_str(),300,-2,3000);
  }
  
  TH1F *hMeu=new TH1F("hMeu","hMeu",1000,-2,1000);
  hMeu->GetXaxis()->SetTitle("SigCors");
  hMeu->GetXaxis()->CenterTitle();
  hMeu->GetYaxis()->SetTitle("");
  hMeu->GetYaxis()->CenterTitle();
  hMeu->SetFillColor(0);
  hMeu->SetBit(TH1::kCanRebin);

  TH1F* hGeVPerMeu=new TH1F("hGeVPerMeu","hGeVPerMeu",3000,-0.001,0.3);
  hGeVPerMeu->SetFillColor(0);
  hGeVPerMeu->SetTitle("GeV/MEU");
  hGeVPerMeu->GetXaxis()->SetTitle("GeV/MEU");
  hGeVPerMeu->GetXaxis()->CenterTitle();

  TH1F *hMeuPLCor=new TH1F("hMeuPLCor","hMeuPLCor",1000,-2,1000);
  hMeuPLCor->GetXaxis()->SetTitle("SigCors");
  hMeuPLCor->GetXaxis()->CenterTitle();
  hMeuPLCor->GetYaxis()->SetTitle("");
  hMeuPLCor->GetYaxis()->CenterTitle();
  hMeuPLCor->SetFillColor(0);
  hMeuPLCor->SetBit(TH1::kCanRebin);

  TH1F *hMeuTruePLCor=new TH1F("hMeuTruePLCor","hMeuTruePLCor",
                               1000,-2,1000);
  hMeuTruePLCor->GetXaxis()->SetTitle("SigCors");
  hMeuTruePLCor->GetXaxis()->CenterTitle();
  hMeuTruePLCor->GetYaxis()->SetTitle("");
  hMeuTruePLCor->GetYaxis()->CenterTitle();
  hMeuTruePLCor->SetFillColor(0);
  hMeuTruePLCor->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyEventLengthCut=new TH1F("hMeuOnlyEventLengthCut",
                                        "hMeuOnlyEventLengthCut",
                                        1000,-2,1000);
  hMeuOnlyEventLengthCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyEventLengthCut->GetXaxis()->CenterTitle();
  hMeuOnlyEventLengthCut->GetYaxis()->SetTitle("");
  hMeuOnlyEventLengthCut->GetYaxis()->CenterTitle();
  hMeuOnlyEventLengthCut->SetFillColor(0);
  hMeuOnlyEventLengthCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyEL_FidCut=new TH1F("hMeuOnlyEL_FidCut",
                                   "hMeuOnlyEL_FidCut",
                                   1000,-2,1000);
  hMeuOnlyEL_FidCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyEL_FidCut->GetXaxis()->CenterTitle();
  hMeuOnlyEL_FidCut->GetYaxis()->SetTitle("");
  hMeuOnlyEL_FidCut->GetYaxis()->CenterTitle();
  hMeuOnlyEL_FidCut->SetFillColor(0);
  hMeuOnlyEL_FidCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyEL_Fid_TimeCut=new TH1F("hMeuOnlyEL_Fid_TimeCut",
                                        "hMeuOnlyEL_Fid_TimeCut",
                                        1000,-2,1000);
  hMeuOnlyEL_Fid_TimeCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyEL_Fid_TimeCut->GetXaxis()->CenterTitle();
  hMeuOnlyEL_Fid_TimeCut->GetYaxis()->SetTitle("");
  hMeuOnlyEL_Fid_TimeCut->GetYaxis()->CenterTitle();
  hMeuOnlyEL_Fid_TimeCut->SetFillColor(0);
  hMeuOnlyEL_Fid_TimeCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyEL_TimeCut=new TH1F("hMeuOnlyEL_TimeCut",
                                   "hMeuOnlyEL_TimeCut",
                                   1000,-2,1000);
  hMeuOnlyEL_TimeCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyEL_TimeCut->GetXaxis()->CenterTitle();
  hMeuOnlyEL_TimeCut->GetYaxis()->SetTitle("");
  hMeuOnlyEL_TimeCut->GetYaxis()->CenterTitle();
  hMeuOnlyEL_TimeCut->SetFillColor(0);
  hMeuOnlyEL_TimeCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyEL_HppCut=new TH1F("hMeuOnlyEL_HppCut",
                                   "hMeuOnlyEL_HppCut",
                                   1000,-2,1000);
  hMeuOnlyEL_HppCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyEL_HppCut->GetXaxis()->CenterTitle();
  hMeuOnlyEL_HppCut->GetYaxis()->SetTitle("");
  hMeuOnlyEL_HppCut->GetYaxis()->CenterTitle();
  hMeuOnlyEL_HppCut->SetFillColor(0);
  hMeuOnlyEL_HppCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyPID_EventLengthCut=new TH1F("hMeuOnlyPID_EventLengthCut",
                                        "hMeuOnlyPID_EventLengthCut",
                                        1000,-2,1000);
  hMeuOnlyPID_EventLengthCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyPID_EventLengthCut->GetXaxis()->CenterTitle();
  hMeuOnlyPID_EventLengthCut->GetYaxis()->SetTitle("");
  hMeuOnlyPID_EventLengthCut->GetYaxis()->CenterTitle();
  hMeuOnlyPID_EventLengthCut->SetFillColor(0);
  hMeuOnlyPID_EventLengthCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyPID_EL_FidCut=new TH1F("hMeuOnlyPID_EL_FidCut",
                                   "hMeuOnlyPID_EL_FidCut",
                                   1000,-2,1000);
  hMeuOnlyPID_EL_FidCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyPID_EL_FidCut->GetXaxis()->CenterTitle();
  hMeuOnlyPID_EL_FidCut->GetYaxis()->SetTitle("");
  hMeuOnlyPID_EL_FidCut->GetYaxis()->CenterTitle();
  hMeuOnlyPID_EL_FidCut->SetFillColor(0);
  hMeuOnlyPID_EL_FidCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyPID_EL_Fid_TimeCut=new TH1F("hMeuOnlyPID_EL_Fid_TimeCut",
                                        "hMeuOnlyPID_EL_Fid_TimeCut",
                                        1000,-2,1000);
  hMeuOnlyPID_EL_Fid_TimeCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyPID_EL_Fid_TimeCut->GetXaxis()->CenterTitle();
  hMeuOnlyPID_EL_Fid_TimeCut->GetYaxis()->SetTitle("");
  hMeuOnlyPID_EL_Fid_TimeCut->GetYaxis()->CenterTitle();
  hMeuOnlyPID_EL_Fid_TimeCut->SetFillColor(0);
  hMeuOnlyPID_EL_Fid_TimeCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyPID_EL_TimeCut=new TH1F("hMeuOnlyPID_EL_TimeCut",
                                   "hMeuOnlyPID_EL_TimeCut",
                                   1000,-2,1000);
  hMeuOnlyPID_EL_TimeCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyPID_EL_TimeCut->GetXaxis()->CenterTitle();
  hMeuOnlyPID_EL_TimeCut->GetYaxis()->SetTitle("");
  hMeuOnlyPID_EL_TimeCut->GetYaxis()->CenterTitle();
  hMeuOnlyPID_EL_TimeCut->SetFillColor(0);
  hMeuOnlyPID_EL_TimeCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuOnlyPID_EL_HppCut=new TH1F("hMeuOnlyPID_EL_HppCut",
                                   "hMeuOnlyPID_EL_HppCut",
                                   1000,-2,1000);
  hMeuOnlyPID_EL_HppCut->GetXaxis()->SetTitle("SigCors");
  hMeuOnlyPID_EL_HppCut->GetXaxis()->CenterTitle();
  hMeuOnlyPID_EL_HppCut->GetYaxis()->SetTitle("");
  hMeuOnlyPID_EL_HppCut->GetYaxis()->CenterTitle();
  hMeuOnlyPID_EL_HppCut->SetFillColor(0);
  hMeuOnlyPID_EL_HppCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoPidCut=new TH1F("hMeuNoPidCut","hMeuNoPidCut",
                              1000,-2,1000);
  hMeuNoPidCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoPidCut->GetXaxis()->CenterTitle();
  hMeuNoPidCut->GetYaxis()->SetTitle("");
  hMeuNoPidCut->GetYaxis()->CenterTitle();
  hMeuNoPidCut->SetFillColor(0);
  hMeuNoPidCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoEventLengthCut=new TH1F("hMeuNoEventLengthCut",
                                      "hMeuNoEventLengthCut",
                                      1000,-2,1000);
  hMeuNoEventLengthCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoEventLengthCut->GetXaxis()->CenterTitle();
  hMeuNoEventLengthCut->GetYaxis()->SetTitle("");
  hMeuNoEventLengthCut->GetYaxis()->CenterTitle();
  hMeuNoEventLengthCut->SetFillColor(0);
  hMeuNoEventLengthCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoFidVolCut=new TH1F("hMeuNoFidVolCut","hMeuNoFidVolCut",
                                 1000,-2,1000);
  hMeuNoFidVolCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoFidVolCut->GetXaxis()->CenterTitle();
  hMeuNoFidVolCut->GetYaxis()->SetTitle("");
  hMeuNoFidVolCut->GetYaxis()->CenterTitle();
  hMeuNoFidVolCut->SetFillColor(0);
  hMeuNoFidVolCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoTrackQualityCut=new TH1F("hMeuNoTrackQualityCut",
                                       "hMeuNoTrackQualityCut",
                                       1000,-2,1000);
  hMeuNoTrackQualityCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoTrackQualityCut->GetXaxis()->CenterTitle();
  hMeuNoTrackQualityCut->GetYaxis()->SetTitle("");
  hMeuNoTrackQualityCut->GetYaxis()->CenterTitle();
  hMeuNoTrackQualityCut->SetFillColor(0);
  hMeuNoTrackQualityCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoPSMuCut=new TH1F("hMeuNoPSMuCut","hMeuNoPSMuCut",
                               1000,-2,1000);
  hMeuNoPSMuCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoPSMuCut->GetXaxis()->CenterTitle();
  hMeuNoPSMuCut->GetYaxis()->SetTitle("");
  hMeuNoPSMuCut->GetYaxis()->CenterTitle();
  hMeuNoPSMuCut->SetFillColor(0);
  hMeuNoPSMuCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoHitsPerPlaneCut=new TH1F("hMeuNoHitsPerPlaneCut",
                                       "hMeuNoHitsPerPlaneCut",
                                       1000,-2,1000);
  hMeuNoHitsPerPlaneCut->GetXaxis()->SetTitle("SigCors");
  hMeuNoHitsPerPlaneCut->GetXaxis()->CenterTitle();
  hMeuNoHitsPerPlaneCut->GetYaxis()->SetTitle("");
  hMeuNoHitsPerPlaneCut->GetYaxis()->CenterTitle();
  hMeuNoHitsPerPlaneCut->SetFillColor(0);
  hMeuNoHitsPerPlaneCut->SetBit(TH1::kCanRebin);

  TH1F *hMeuNoHitsPerPlane10Cut=new TH1F("hMeuNoHitsPerPlane10Cut",
                                         "hMeuNoHitsPerPlane10Cut",
                                         1000,-2,1000);
  hMeuNoHitsPerPlane10Cut->GetXaxis()->SetTitle("SigCors");
  hMeuNoHitsPerPlane10Cut->GetXaxis()->CenterTitle();
  hMeuNoHitsPerPlane10Cut->GetYaxis()->SetTitle("");
  hMeuNoHitsPerPlane10Cut->GetYaxis()->CenterTitle();
  hMeuNoHitsPerPlane10Cut->SetFillColor(0);
  hMeuNoHitsPerPlane10Cut->SetBit(TH1::kCanRebin);

  TH1F *h15_18=new TH1F("h15_18","h15_18",1000,-2,1000);
  h15_18->GetXaxis()->SetTitle("SigCors");
  h15_18->GetXaxis()->CenterTitle();
  h15_18->GetYaxis()->SetTitle("");
  h15_18->GetYaxis()->CenterTitle();
  h15_18->SetFillColor(0);
  h15_18->SetBit(TH1::kCanRebin);

  TH1F *h10_16=new TH1F("h10_16","h10_16",1000,-2,1000);
  h10_16->GetXaxis()->SetTitle("SigCors");
  h10_16->GetXaxis()->CenterTitle();
  h10_16->GetYaxis()->SetTitle("");
  h10_16->GetYaxis()->CenterTitle();
  h10_16->SetFillColor(0);
  h10_16->SetBit(TH1::kCanRebin);

  TH1F *h10_10=new TH1F("h10_10","h10_10",1000,-2,1000);
  h10_10->GetXaxis()->SetTitle("SigCors");
  h10_10->GetXaxis()->CenterTitle();
  h10_10->GetYaxis()->SetTitle("");
  h10_10->GetYaxis()->CenterTitle();
  h10_10->SetFillColor(0);
  h10_10->SetBit(TH1::kCanRebin);

  TH1F *h14_16=new TH1F("h14_16","h14_16",1000,-2,1000);
  h14_16->GetXaxis()->SetTitle("SigCors");
  h14_16->GetXaxis()->CenterTitle();
  h14_16->GetYaxis()->SetTitle("");
  h14_16->GetYaxis()->CenterTitle();
  h14_16->SetFillColor(0);
  h14_16->SetBit(TH1::kCanRebin);

  TH1F *h14_16OL=new TH1F("h14_16OL","h14_16OL",1000,-2,1000);
  h14_16OL->GetXaxis()->SetTitle("SigCors");
  h14_16OL->GetXaxis()->CenterTitle();
  h14_16OL->GetYaxis()->SetTitle("");
  h14_16OL->GetYaxis()->CenterTitle();
  h14_16OL->SetFillColor(0);
  h14_16OL->SetBit(TH1::kCanRebin);

  TH1F *h14_16NoTrkCut=new TH1F("h14_16NoTrkCut","h14_16NoTrkCut",
                                1000,-2,1000);
  h14_16NoTrkCut->GetXaxis()->SetTitle("SigCors");
  h14_16NoTrkCut->GetXaxis()->CenterTitle();
  h14_16NoTrkCut->GetYaxis()->SetTitle("");
  h14_16NoTrkCut->GetYaxis()->CenterTitle();
  h14_16NoTrkCut->SetFillColor(0);
  h14_16NoTrkCut->SetBit(TH1::kCanRebin);

  TH1F *h14_16TrkUV=new TH1F("h14_16TrkUV","h14_16TrkUV",
                                1000,-2,1000);
  h14_16TrkUV->GetXaxis()->SetTitle("SigCors");
  h14_16TrkUV->GetXaxis()->CenterTitle();
  h14_16TrkUV->GetYaxis()->SetTitle("");
  h14_16TrkUV->GetYaxis()->CenterTitle();
  h14_16TrkUV->SetFillColor(0);
  h14_16TrkUV->SetBit(TH1::kCanRebin);

  TH1F *h14_16NoXTalk=new TH1F("h14_16NoXTalk","h14_16NoXTalk",
                               1000,-2,1000);
  h14_16NoXTalk->GetXaxis()->SetTitle("SigCors");
  h14_16NoXTalk->GetXaxis()->CenterTitle();
  h14_16NoXTalk->GetYaxis()->SetTitle("");
  h14_16NoXTalk->GetYaxis()->CenterTitle();
  h14_16NoXTalk->SetFillColor(0);
  h14_16NoXTalk->SetBit(TH1::kCanRebin);

  TH1F *h14_16O1=new TH1F("h14_16O1","h14_16O1",1000,-2,1000);
  h14_16O1->GetXaxis()->SetTitle("SigCors");
  h14_16O1->GetXaxis()->CenterTitle();
  h14_16O1->GetYaxis()->SetTitle("");
  h14_16O1->GetYaxis()->CenterTitle();
  h14_16O1->SetFillColor(0);
  h14_16O1->SetBit(TH1::kCanRebin);

  TH1F *h14_16O2=new TH1F("h14_16O2","h14_16O2",1000,-2,1000);
  h14_16O2->GetXaxis()->SetTitle("SigCors");
  h14_16O2->GetXaxis()->CenterTitle();
  h14_16O2->GetYaxis()->SetTitle("");
  h14_16O2->GetYaxis()->CenterTitle();
  h14_16O2->SetFillColor(0);
  h14_16O2->SetBit(TH1::kCanRebin);

  TH1F *h14_16E1=new TH1F("h14_16E1","h14_16E1",1000,-2,1000);
  h14_16E1->GetXaxis()->SetTitle("SigCors");
  h14_16E1->GetXaxis()->CenterTitle();
  h14_16E1->GetYaxis()->SetTitle("");
  h14_16E1->GetYaxis()->CenterTitle();
  h14_16E1->SetFillColor(0);
  h14_16E1->SetBit(TH1::kCanRebin);

  TH1F *h14_16E2=new TH1F("h14_16E2","h14_16E2",1000,-2,1000);
  h14_16E2->GetXaxis()->SetTitle("SigCors");
  h14_16E2->GetXaxis()->CenterTitle();
  h14_16E2->GetYaxis()->SetTitle("");
  h14_16E2->GetYaxis()->CenterTitle();
  h14_16E2->SetFillColor(0);
  h14_16E2->SetBit(TH1::kCanRebin);

  TH1F *h14_16TimeCut=new TH1F("h14_16TimeCut","h14_16TimeCut",
                               1000,-2,1000);
  h14_16TimeCut->GetXaxis()->SetTitle("SigCors");
  h14_16TimeCut->GetXaxis()->CenterTitle();
  h14_16TimeCut->GetYaxis()->SetTitle("");
  h14_16TimeCut->GetYaxis()->CenterTitle();
  h14_16TimeCut->SetFillColor(0);
  h14_16TimeCut->SetBit(TH1::kCanRebin);

  TH1F *h14_16TimeCutO1=new TH1F("h14_16TimeCutO1","h14_16TimeCutO1",
                                 1000,-2,1000);
  h14_16TimeCutO1->GetXaxis()->SetTitle("SigCors");
  h14_16TimeCutO1->GetXaxis()->CenterTitle();
  h14_16TimeCutO1->GetYaxis()->SetTitle("");
  h14_16TimeCutO1->GetYaxis()->CenterTitle();
  h14_16TimeCutO1->SetFillColor(0);
  h14_16TimeCutO1->SetBit(TH1::kCanRebin);

  TH1F *h14_16TimeCutO2=new TH1F("h14_16TimeCutO2","h14_16TimeCutO2",
                                 1000,-2,1000);
  h14_16TimeCutO2->GetXaxis()->SetTitle("SigCors");
  h14_16TimeCutO2->GetXaxis()->CenterTitle();
  h14_16TimeCutO2->GetYaxis()->SetTitle("");
  h14_16TimeCutO2->GetYaxis()->CenterTitle();
  h14_16TimeCutO2->SetFillColor(0);
  h14_16TimeCutO2->SetBit(TH1::kCanRebin);

  TH1F *h14_16TimeCutE1=new TH1F("h14_16TimeCutE1","h14_16TimeCutE1",
                                 1000,-2,1000);
  h14_16TimeCutE1->GetXaxis()->SetTitle("SigCors");
  h14_16TimeCutE1->GetXaxis()->CenterTitle();
  h14_16TimeCutE1->GetYaxis()->SetTitle("");
  h14_16TimeCutE1->GetYaxis()->CenterTitle();
  h14_16TimeCutE1->SetFillColor(0);
  h14_16TimeCutE1->SetBit(TH1::kCanRebin);

  TH1F *h14_16TimeCutE2=new TH1F("h14_16TimeCutE2","h14_16TimeCutE2",
                                 1000,-2,1000);
  h14_16TimeCutE2->GetXaxis()->SetTitle("SigCors");
  h14_16TimeCutE2->GetXaxis()->CenterTitle();
  h14_16TimeCutE2->GetYaxis()->SetTitle("");
  h14_16TimeCutE2->GetYaxis()->CenterTitle();
  h14_16TimeCutE2->SetFillColor(0);
  h14_16TimeCutE2->SetBit(TH1::kCanRebin);

  TH1F *h14_16Straight=new TH1F("h14_16Straight","14_16Straight",
                                1000,-2,1000);
  h14_16Straight->GetXaxis()->SetTitle("SigCors");
  h14_16Straight->GetXaxis()->CenterTitle();
  h14_16Straight->GetYaxis()->SetTitle("");
  h14_16Straight->GetYaxis()->CenterTitle();
  h14_16Straight->SetFillColor(0);
  h14_16Straight->SetBit(TH1::kCanRebin);

  TH1F *h14_10=new TH1F("h14_10","h14_10",1000,-2,1000);
  h14_10->GetXaxis()->SetTitle("SigCors");
  h14_10->GetXaxis()->CenterTitle();
  h14_10->GetYaxis()->SetTitle("");
  h14_10->GetYaxis()->CenterTitle();
  h14_10->SetFillColor(0);
  h14_10->SetBit(TH1::kCanRebin);

  TH1F *h18_16=new TH1F("h18_16","h18_16",1000,-2,1000);
  h18_16->GetXaxis()->SetTitle("SigCors");
  h18_16->GetXaxis()->CenterTitle();
  h18_16->GetYaxis()->SetTitle("");
  h18_16->GetYaxis()->CenterTitle();
  h18_16->SetFillColor(0);
  h18_16->SetBit(TH1::kCanRebin);

  TH1F *h18_10=new TH1F("h18_10","h18_10",1000,-2,1000);
  h18_10->GetXaxis()->SetTitle("SigCors");
  h18_10->GetXaxis()->CenterTitle();
  h18_10->GetYaxis()->SetTitle("");
  h18_10->GetYaxis()->CenterTitle();
  h18_10->SetFillColor(0);
  h18_10->SetBit(TH1::kCanRebin);

  TH1F *hEvLenFe=new TH1F("hEvLenFe","hEvLenFe",62,0,62);
  hEvLenFe->GetXaxis()->SetTitle("Event Length (Planes of Fe)");
  hEvLenFe->GetXaxis()->CenterTitle();
  hEvLenFe->GetYaxis()->SetTitle("");
  hEvLenFe->GetYaxis()->CenterTitle();
  hEvLenFe->SetFillColor(0);
  hEvLenFe->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2=new TH1F("hOLChi2","hOLChi2",200,0,10);
  hOLChi2->GetXaxis()->SetTitle("OLChi2");
  hOLChi2->GetXaxis()->CenterTitle();
  hOLChi2->GetYaxis()->SetTitle("");
  hOLChi2->GetYaxis()->CenterTitle();
  hOLChi2->SetFillColor(0);
  hOLChi2->SetLineWidth(3);
  hOLChi2->SetLineColor(1);
  //hOLChi2->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2N_1=new TH1F("hOLChi2N_1","hOLChi2N_1",200,0,10);
  hOLChi2N_1->GetXaxis()->SetTitle("OLChi2");
  hOLChi2N_1->GetXaxis()->CenterTitle();
  hOLChi2N_1->GetYaxis()->SetTitle("");
  hOLChi2N_1->GetYaxis()->CenterTitle();
  hOLChi2N_1->SetFillColor(0);
  hOLChi2N_1->SetLineWidth(3);
  hOLChi2N_1->SetLineColor(2);
  //hOLChi2N_1->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2N=new TH1F("hOLChi2N","hOLChi2N",200,0,10);
  hOLChi2N->GetXaxis()->SetTitle("OLChi2");
  hOLChi2N->GetXaxis()->CenterTitle();
  hOLChi2N->GetYaxis()->SetTitle("");
  hOLChi2N->GetYaxis()->CenterTitle();
  hOLChi2N->SetFillColor(0);
  hOLChi2N->SetLineWidth(3);
  hOLChi2N->SetLineColor(4);
  //hOLChi2N->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsOLChi2Sum=new TProfile("pSigCorVsOLChi2Sum",
                                            "pSigCorVsOLChi2Sum",
                                            200,0,10);

  TProfile* pSigCorVsOLChi2=new TProfile("pSigCorVsOLChi2",
                                         "pSigCorVsOLChi2",200,0,10);

  TProfile* pSigCorVsRange=new TProfile("pSigCorVsRange",
                                        "pSigCorVsRange",62,0,62);

  //sum of all strip ends, normal and offset planes
  //tracked
  TProfile* pSigCorVsPlane=new TProfile("pSigCorVsPlane",
                                        "pSigCorVsPlane",
                                        62,0,62);
  TProfile* pSigCorVsOsPlane=new TProfile("pSigCorVsOsPlane",
                                          "pSigCorVsOsPlane",
                                          62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneX=new TProfile("pSigCorVsPlaneX",
                                         "pSigCorVsPlaneX",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneX=new TProfile("pSigCorVsOsPlaneX",
                                           "pSigCorVsOsPlaneX",
                                           62,0,62);

  //total
  TProfile* pSigCorVsPlaneT=new TProfile("pSigCorVsPlaneT",
                                         "pSigCorVsPlaneT",
                                         62,0,62);
  TProfile* pSigCorVsOsPlaneT=new TProfile("pSigCorVsOsPlaneT",
                                           "pSigCorVsOsPlaneT",
                                           62,0,62);

  //individual strip ends
  //tracked
  TProfile* pSigCorVsPlaneO1=new TProfile("pSigCorVsPlaneO1",
                                          "pSigCorVsPlaneO1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2=new TProfile("pSigCorVsPlaneO2",
                                          "pSigCorVsPlaneO2",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1=new TProfile("pSigCorVsPlaneE1",
                                          "pSigCorVsPlaneE1",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2=new TProfile("pSigCorVsPlaneE2",
                                          "pSigCorVsPlaneE2",
                                          62,0,62);
  //xtalk + untracked hits
  TProfile* pSigCorVsPlaneO1X=new TProfile("pSigCorVsPlaneO1X",
                                          "pSigCorVsPlaneO1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2X=new TProfile("pSigCorVsPlaneO2X",
                                          "pSigCorVsPlaneO2X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1X=new TProfile("pSigCorVsPlaneE1X",
                                          "pSigCorVsPlaneE1X",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2X=new TProfile("pSigCorVsPlaneE2X",
                                          "pSigCorVsPlaneE2X",
                                          62,0,62);
  //total
  TProfile* pSigCorVsPlaneO1T=new TProfile("pSigCorVsPlaneO1T",
                                          "pSigCorVsPlaneO1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneO2T=new TProfile("pSigCorVsPlaneO2T",
                                          "pSigCorVsPlaneO2T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE1T=new TProfile("pSigCorVsPlaneE1T",
                                          "pSigCorVsPlaneE1T",
                                          62,0,62);
  TProfile* pSigCorVsPlaneE2T=new TProfile("pSigCorVsPlaneE2T",
                                          "pSigCorVsPlaneE2T",
                                          62,0,62);

  //individual strip ends - offset planes
  //tracked
  TProfile* pSigCorVsOsPlaneO1=new TProfile("pSigCorVsOsPlaneO1",
                                            "pSigCorVsOsPlaneO1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2=new TProfile("pSigCorVsOsPlaneO2",
                                            "pSigCorVsOsPlaneO2",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1=new TProfile("pSigCorVsOsPlaneE1",
                                            "pSigCorVsOsPlaneE1",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2=new TProfile("pSigCorVsOsPlaneE2",
                                            "pSigCorVsOsPlaneE2",
                                            62,0,62);

  //xtalk + untracked hits
  TProfile* pSigCorVsOsPlaneO1X=new TProfile("pSigCorVsOsPlaneO1X",
                                             "pSigCorVsOsPlaneO1X",
                                             62,0,62);
  TProfile* pSigCorVsOsPlaneO2X=new TProfile("pSigCorVsOsPlaneO2X",
                                            "pSigCorVsOsPlaneO2X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1X=new TProfile("pSigCorVsOsPlaneE1X",
                                            "pSigCorVsOsPlaneE1X",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2X=new TProfile("pSigCorVsOsPlaneE2X",
                                            "pSigCorVsOsPlaneE2X",
                                            62,0,62);
  //total
  TProfile* pSigCorVsOsPlaneO1T=new TProfile("pSigCorVsOsPlaneO1T",
                                            "pSigCorVsOsPlaneO1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneO2T=new TProfile("pSigCorVsOsPlaneO2T",
                                            "pSigCorVsOsPlaneO2T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE1T=new TProfile("pSigCorVsOsPlaneE1T",
                                            "pSigCorVsOsPlaneE1T",
                                            62,0,62);
  TProfile* pSigCorVsOsPlaneE2T=new TProfile("pSigCorVsOsPlaneE2T",
                                            "pSigCorVsOsPlaneE2T",
                                            62,0,62);

  TProfile* pMeuVsHit_PlCut=new TProfile("pMeuVsHit_PlCut",
                                         "pMeuVsHit_PlCut",120,0,12);
  pMeuVsHit_PlCut->SetTitle("MEU vs Hits/Plane Cut");
  pMeuVsHit_PlCut->GetXaxis()->SetTitle("Hits/Plane Cut");
  pMeuVsHit_PlCut->GetXaxis()->CenterTitle();
  pMeuVsHit_PlCut->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsHit_PlCut->GetYaxis()->CenterTitle();
  pMeuVsHit_PlCut->SetFillColor(0);

  TProfile* pMeuVsHit_PlCut10=new TProfile("pMeuVsHit_PlCut10",
                                           "pMeuVsHit_PlCut10",
                                           120,0,12);
  pMeuVsHit_PlCut10->SetTitle("MEU vs Hits/Plane Cut");
  pMeuVsHit_PlCut10->GetXaxis()->SetTitle("Hits/Plane Cut");
  pMeuVsHit_PlCut10->GetXaxis()->CenterTitle();
  pMeuVsHit_PlCut10->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsHit_PlCut10->GetYaxis()->CenterTitle();
  pMeuVsHit_PlCut10->SetFillColor(0);

  TProfile* pMeuVsLowTimeCutN_1=new TProfile("pMeuVsLowTimeCutN_1",
                                             "pMeuVsLowTimeCutN_1",
                                             50,-500,500);
  pMeuVsLowTimeCutN_1->SetTitle("MEU vs Time Cut");
  pMeuVsLowTimeCutN_1->GetXaxis()->SetTitle("Time Cut");
  pMeuVsLowTimeCutN_1->GetXaxis()->CenterTitle();
  pMeuVsLowTimeCutN_1->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsLowTimeCutN_1->GetYaxis()->CenterTitle();
  pMeuVsLowTimeCutN_1->SetFillColor(0);
  pMeuVsLowTimeCutN_1->SetLineColor(2);

  TProfile* pMeuVsLowTimeCutN=new TProfile("pMeuVsLowTimeCutN",
                                           "pMeuVsLowTimeCutN",
                                           50,-500,500);
  pMeuVsLowTimeCutN->SetTitle("MEU vs Time Cut");
  pMeuVsLowTimeCutN->GetXaxis()->SetTitle("Time Cut");
  pMeuVsLowTimeCutN->GetXaxis()->CenterTitle();
  pMeuVsLowTimeCutN->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsLowTimeCutN->GetYaxis()->CenterTitle();
  pMeuVsLowTimeCutN->SetFillColor(0);
  pMeuVsLowTimeCutN->SetLineColor(4);

  TProfile* pMeuVsUpTimeCutN_1=new TProfile("pMeuVsUpTimeCutN_1",
                                            "pMeuVsUpTimeCutN_1",
                                            50,-500,500);
  pMeuVsUpTimeCutN_1->SetTitle("MEU vs Time Cut");
  pMeuVsUpTimeCutN_1->GetXaxis()->SetTitle("Time Cut");
  pMeuVsUpTimeCutN_1->GetXaxis()->CenterTitle();
  pMeuVsUpTimeCutN_1->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsUpTimeCutN_1->GetYaxis()->CenterTitle();
  pMeuVsUpTimeCutN_1->SetFillColor(0);
  pMeuVsUpTimeCutN_1->SetLineColor(2);

  TProfile* pMeuVsUpTimeCutN=new TProfile("pMeuVsUpTimeCutN",
                                          "pMeuVsUpTimeCutN",
                                          50,-500,500);
  pMeuVsUpTimeCutN->SetTitle("MEU vs Time Cut");
  pMeuVsUpTimeCutN->GetXaxis()->SetTitle("Time Cut");
  pMeuVsUpTimeCutN->GetXaxis()->CenterTitle();
  pMeuVsUpTimeCutN->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsUpTimeCutN->GetYaxis()->CenterTitle();
  pMeuVsUpTimeCutN->SetFillColor(0);
  pMeuVsUpTimeCutN->SetLineColor(4);

  TProfile* pMeuVsLowEvLenCutN=new TProfile("pMeuVsLowEvLenCutN",
                                        "pMeuVsLowEvLenCutN",62,0,62);
  pMeuVsLowEvLenCutN->SetTitle("MEU vs Event Length Cut");
  pMeuVsLowEvLenCutN->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsLowEvLenCutN->GetXaxis()->CenterTitle();
  pMeuVsLowEvLenCutN->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsLowEvLenCutN->GetYaxis()->CenterTitle();
  pMeuVsLowEvLenCutN->SetFillColor(0);

  TProfile* pMeuVsLowEvLenCutNormN=new TProfile
    ("pMeuVsLowEvLenCutNormN","pMeuVsLowEvLenCutNormN",62,0,62);
  pMeuVsLowEvLenCutNormN->SetTitle("Normalised MEU vs Event Length Cut");
  pMeuVsLowEvLenCutNormN->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsLowEvLenCutNormN->GetXaxis()->CenterTitle();
  pMeuVsLowEvLenCutNormN->GetYaxis()->SetTitle("Normalised SigCors/MEU");
  pMeuVsLowEvLenCutNormN->GetYaxis()->CenterTitle();
  pMeuVsLowEvLenCutNormN->SetFillColor(0);

  TProfile* pMeuVsLowEvLenCutN_1=new TProfile
    ("pMeuVsLowEvLenCutN_1","pMeuVsLowEvLenCutN_1",62,0,62);
  pMeuVsLowEvLenCutN_1->SetTitle("MEU vs Event Length Cut");
  pMeuVsLowEvLenCutN_1->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsLowEvLenCutN_1->GetXaxis()->CenterTitle();
  pMeuVsLowEvLenCutN_1->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsLowEvLenCutN_1->GetYaxis()->CenterTitle();
  pMeuVsLowEvLenCutN_1->SetFillColor(0);

  TProfile* pMeuVsLowEvLenCutNormN_1=new TProfile
    ("pMeuVsLowEvLenCutNormN_1","pMeuVsLowEvLenCutNormN_1",62,0,62);
  pMeuVsLowEvLenCutNormN_1->SetTitle
    ("Normalised MEU vs Event Length Cut");
  pMeuVsLowEvLenCutNormN_1->GetXaxis()->SetTitle
    ("Lower Event Length Cut");
  pMeuVsLowEvLenCutNormN_1->GetXaxis()->CenterTitle();
  pMeuVsLowEvLenCutNormN_1->GetYaxis()->SetTitle
    ("Normalised SigCors/MEU");
  pMeuVsLowEvLenCutNormN_1->GetYaxis()->CenterTitle();
  pMeuVsLowEvLenCutNormN_1->SetFillColor(0);

  TProfile* pMeuVsUpEvLenCutN=new TProfile("pMeuVsUpEvLenCutN",
                                        "pMeuVsUpEvLenCutN",62,0,62);
  pMeuVsUpEvLenCutN->SetTitle("MEU vs Event Length Cut");
  pMeuVsUpEvLenCutN->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsUpEvLenCutN->GetXaxis()->CenterTitle();
  pMeuVsUpEvLenCutN->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsUpEvLenCutN->GetYaxis()->CenterTitle();
  pMeuVsUpEvLenCutN->SetFillColor(0);

  TProfile* pMeuVsUpEvLenCutNormN=new TProfile("pMeuVsUpEvLenCutNormN",
                                        "pMeuVsUpEvLenCutNormN",62,0,62);
  pMeuVsUpEvLenCutNormN->SetTitle("Normalised MEU vs Event Length Cut");
  pMeuVsUpEvLenCutNormN->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsUpEvLenCutNormN->GetXaxis()->CenterTitle();
  pMeuVsUpEvLenCutNormN->GetYaxis()->SetTitle("Normalised SigCors/MEU");
  pMeuVsUpEvLenCutNormN->GetYaxis()->CenterTitle();
  pMeuVsUpEvLenCutNormN->SetFillColor(0);

  TProfile* pMeuVsUpEvLenCutN_1=new TProfile("pMeuVsUpEvLenCutN_1",
                                        "pMeuVsUpEvLenCutN_1",62,0,62);
  pMeuVsUpEvLenCutN_1->SetTitle("MEU vs Event Length Cut");
  pMeuVsUpEvLenCutN_1->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsUpEvLenCutN_1->GetXaxis()->CenterTitle();
  pMeuVsUpEvLenCutN_1->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsUpEvLenCutN_1->GetYaxis()->CenterTitle();
  pMeuVsUpEvLenCutN_1->SetFillColor(0);

  TProfile* pMeuVsUpEvLenCutNormN_1=new TProfile
    ("pMeuVsUpEvLenCutNormN_1","pMeuVsUpEvLenCutNormN_1",62,0,62);
  pMeuVsUpEvLenCutNormN_1->SetTitle
    ("Normalised MEU vs Event Length Cut");
  pMeuVsUpEvLenCutNormN_1->GetXaxis()->SetTitle
    ("Lower Event Length Cut");
  pMeuVsUpEvLenCutNormN_1->GetXaxis()->CenterTitle();
  pMeuVsUpEvLenCutNormN_1->GetYaxis()->SetTitle
    ("Normalised SigCors/MEU");
  pMeuVsUpEvLenCutNormN_1->GetYaxis()->CenterTitle();
  pMeuVsUpEvLenCutNormN_1->SetFillColor(0);

  TProfile* pMeuVsStraightness=new TProfile("pMeuVsStraightness",
                                            "pMeuVsStraightness",
                                            100,-0.025,0.6);
  pMeuVsStraightness->SetTitle("MEU Vs TrackStraightness");
  pMeuVsStraightness->GetXaxis()->
    SetTitle("Straightness Radius Cut (m from centre)");
  pMeuVsStraightness->GetXaxis()->CenterTitle();
  pMeuVsStraightness->GetYaxis()->SetTitle("MEU");
  pMeuVsStraightness->GetYaxis()->CenterTitle();
  pMeuVsStraightness->SetFillColor(0);

  TProfile* pMeuVsStraightnessN=new TProfile("pMeuVsStraightnessN",
                                             "pMeuVsStraightnessN",
                                             100,-0.025,0.6);
  pMeuVsStraightnessN->SetTitle("Normalised MEU Vs TrackStraightness");
  pMeuVsStraightnessN->GetXaxis()->
    SetTitle("Straightness Radius Cut (m from centre)");
  pMeuVsStraightnessN->GetXaxis()->CenterTitle();
  pMeuVsStraightnessN->GetYaxis()->SetTitle("Normalised MEU");
  pMeuVsStraightnessN->GetYaxis()->CenterTitle();
  pMeuVsStraightnessN->SetFillColor(0);

  TH1F *hStripsFromCentre=new TH1F("hStripsFromCentre",
                                   "hStripsFromCentre",12,0,12);
  hStripsFromCentre->GetXaxis()->SetTitle("Strips from Centre");
  hStripsFromCentre->GetXaxis()->CenterTitle();
  hStripsFromCentre->GetYaxis()->SetTitle("");
  hStripsFromCentre->GetYaxis()->CenterTitle();
  hStripsFromCentre->SetFillColor(0);
  //hStripsFromCentre->SetBit(TH1::kCanRebin);

  TH1F *hStripsFromCentrePeCut=new TH1F("hStripsFromCentrePeCut",
                                        "hStripsFromCentrePeCut",
                                        14,0,14);
  hStripsFromCentrePeCut->GetXaxis()->SetTitle("Strips from Centre");
  hStripsFromCentrePeCut->GetXaxis()->CenterTitle();
  hStripsFromCentrePeCut->GetYaxis()->SetTitle("");
  hStripsFromCentrePeCut->GetYaxis()->CenterTitle();
  hStripsFromCentrePeCut->SetFillColor(0);
  //hStripsFromCentrePeCut->SetBit(TH1::kCanRebin);

  TH1F *hStripsFromCentrePeCutN_1=new TH1F("hStripsFromCentrePeCutN_1",
                                        "hStripsFromCentrePeCutN_1",
                                        14,0,14);
  hStripsFromCentrePeCutN_1->GetXaxis()->SetTitle("Strips from Centre");
  hStripsFromCentrePeCutN_1->GetXaxis()->CenterTitle();
  hStripsFromCentrePeCutN_1->GetYaxis()->SetTitle("");
  hStripsFromCentrePeCutN_1->GetYaxis()->CenterTitle();
  hStripsFromCentrePeCutN_1->SetFillColor(0);
  hStripsFromCentrePeCutN_1->SetLineColor(2);
  //hStripsFromCentrePeCutN_1->SetBit(TH1::kCanRebin);

  TH1F *hStripsFromCentrePeCutN=new TH1F("hStripsFromCentrePeCutN",
                                        "hStripsFromCentrePeCutN",
                                        14,0,14);
  hStripsFromCentrePeCutN->GetXaxis()->SetTitle("Strips from Centre");
  hStripsFromCentrePeCutN->GetXaxis()->CenterTitle();
  hStripsFromCentrePeCutN->GetYaxis()->SetTitle("");
  hStripsFromCentrePeCutN->GetYaxis()->CenterTitle();
  hStripsFromCentrePeCutN->SetFillColor(0);
  hStripsFromCentrePeCutN->SetLineColor(4);
  //hStripsFromCentrePeCutN->SetBit(TH1::kCanRebin);

  TProfile* pMeuVsStripCut=new TProfile("pMeuVsStripCut",
                                        "pMeuVsStripCut",
                                        12,0,12);
  pMeuVsStripCut->SetTitle("MEU Vs Strips from Centre");
  pMeuVsStripCut->GetXaxis()->
    SetTitle("Strip Cut (strips from centre)");
  pMeuVsStripCut->GetXaxis()->CenterTitle();
  pMeuVsStripCut->GetYaxis()->SetTitle("MEU");
  pMeuVsStripCut->GetYaxis()->CenterTitle();
  pMeuVsStripCut->SetFillColor(0);

  TProfile* pMeuVsStripCutPeCut=new TProfile("pMeuVsStripCutPeCut",
                                             "pMeuVsStripCutPeCut",
                                             14,0,14);
  pMeuVsStripCutPeCut->SetTitle("MEU Vs Strips from Centre (PeCut)");
  pMeuVsStripCutPeCut->GetXaxis()->
    SetTitle("Strip Cut (strips from centre)");
  pMeuVsStripCutPeCut->GetXaxis()->CenterTitle();
  pMeuVsStripCutPeCut->GetYaxis()->SetTitle("MEU");
  pMeuVsStripCutPeCut->GetYaxis()->CenterTitle();
  pMeuVsStripCutPeCut->SetFillColor(0);

  fS="Strip Vs Plane: Av. SigCor in Track Window";
  TProfile2D* pStVsPlWin=new TProfile2D("pStVsPlWin",fS.c_str(),
                                      64,-2,62,30,-3,27);
  pStVsPlWin->GetXaxis()->SetTitle("Plane");
  pStVsPlWin->GetXaxis()->CenterTitle();
  pStVsPlWin->GetYaxis()->SetTitle("Strip");
  pStVsPlWin->GetYaxis()->CenterTitle();
  pStVsPlWin->SetFillColor(0);
  //pStVsPlWin->SetMaximum(15000);

  fS="Av. Fraction of MEU";
  TProfile2D* pStVsPlWinFract=new TProfile2D("pStVsPlWinFract",
                                             fS.c_str(),
                                             64,-2,62,30,-3,27);
  pStVsPlWinFract->GetXaxis()->SetTitle("Plane");
  pStVsPlWinFract->GetXaxis()->CenterTitle();
  pStVsPlWinFract->GetYaxis()->SetTitle("Strip");
  pStVsPlWinFract->GetYaxis()->CenterTitle();
  pStVsPlWinFract->SetFillColor(0);
  //pStVsPlWinFract->SetMaximum(15000);

  fS="Strip Vs Plane: Number of Hits in Track Window";
  TH2F* hStVsPlNum=new TH2F("hStVsPlNum",fS.c_str(),
                          64,-2,62,30,-3,27);
  hStVsPlNum->GetXaxis()->SetTitle("Plane");
  hStVsPlNum->GetXaxis()->CenterTitle();
  hStVsPlNum->GetYaxis()->SetTitle("Strip");
  hStVsPlNum->GetYaxis()->CenterTitle();
  hStVsPlNum->SetFillColor(0);
  //hStVsPlNum->SetMaximum(15000);


  fS="Strip Vs Plane SigCor (SE1)";
  TProfile2D* pStVsPl1=new TProfile2D("pStVsPl1",fS.c_str(),
                                      64,-2,62,30,-3,27);
  pStVsPl1->GetXaxis()->SetTitle("Plane");
  pStVsPl1->GetXaxis()->CenterTitle();
  pStVsPl1->GetYaxis()->SetTitle("Strip");
  pStVsPl1->GetYaxis()->CenterTitle();
  pStVsPl1->SetFillColor(0);
  //pStVsPl1->SetMaximum(15000);

  fS="Strip Vs Plane SigCor (SE2)";
  TProfile2D* pStVsPl2=new TProfile2D("pStVsPl2",fS.c_str(),
                                      64,-2,62,30,-3,27);
  pStVsPl2->GetXaxis()->SetTitle("Plane");
  pStVsPl2->GetXaxis()->CenterTitle();
  pStVsPl2->GetYaxis()->SetTitle("Strip");
  pStVsPl2->GetYaxis()->CenterTitle();
  pStVsPl2->SetFillColor(0);
  //pStVsPl2->SetMaximum(15000);

  fS="Strip Vs Plane SigCor (SE1)";
  TH2F* hStVsPl1=new TH2F("hStVsPl1",fS.c_str(),
                          64,-2,62,30,-3,27);
  hStVsPl1->GetXaxis()->SetTitle("Plane");
  hStVsPl1->GetXaxis()->CenterTitle();
  hStVsPl1->GetYaxis()->SetTitle("Strip");
  hStVsPl1->GetYaxis()->CenterTitle();
  hStVsPl1->SetFillColor(0);
  //hStVsPl1->SetMaximum(15000);

  fS="Strip Vs Plane SigCor (SE2)";
  TH2F* hStVsPl2=new TH2F("hStVsPl2",fS.c_str(),
                                      64,-2,62,30,-3,27);
  hStVsPl2->GetXaxis()->SetTitle("Plane");
  hStVsPl2->GetXaxis()->CenterTitle();
  hStVsPl2->GetYaxis()->SetTitle("Strip");
  hStVsPl2->GetYaxis()->CenterTitle();
  hStVsPl2->SetFillColor(0);
  //hStVsPl2->SetMaximum(15000);

  TH1F *hNumPlanesMuPi=new TH1F("hNumPlanesMuPi","hNumPlanesMuPi",
                                77,-2,75);
  hNumPlanesMuPi->SetTitle("Number of Planes Hit");
  hNumPlanesMuPi->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesMuPi->GetXaxis()->CenterTitle();
  hNumPlanesMuPi->GetYaxis()->SetTitle("");
  hNumPlanesMuPi->GetYaxis()->CenterTitle();
  hNumPlanesMuPi->SetFillColor(0);
  hNumPlanesMuPi->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanes=new TH1F("hNumPlanes","hNumPlanes",77,-2,75);
  hNumPlanes->SetTitle("Number of Planes Hit");
  hNumPlanes->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanes->GetXaxis()->CenterTitle();
  hNumPlanes->GetYaxis()->SetTitle("");
  hNumPlanes->GetYaxis()->CenterTitle();
  hNumPlanes->SetFillColor(0);
  hNumPlanes->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesN_1=new TH1F("hNumPlanesN_1","hNumPlanesN_1",
                               77,-2,75);
  hNumPlanesN_1->SetTitle("Number of Planes Hit");  
  hNumPlanesN_1->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesN_1->GetXaxis()->CenterTitle();
  hNumPlanesN_1->GetYaxis()->SetTitle("");
  hNumPlanesN_1->GetYaxis()->CenterTitle();
  hNumPlanesN_1->SetFillColor(0);
  hNumPlanesN_1->SetLineColor(2);
  hNumPlanesN_1->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesN=new TH1F("hNumPlanesN","hNumPlanesN",
                               77,-2,75);
  hNumPlanesN->SetTitle("Number of Planes Hit");  
  hNumPlanesN->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesN->GetXaxis()->CenterTitle();
  hNumPlanesN->GetYaxis()->SetTitle("");
  hNumPlanesN->GetYaxis()->CenterTitle();
  hNumPlanesN->SetFillColor(0);
  hNumPlanesN->SetLineColor(4);
  hNumPlanesN->SetBit(TH1::kCanRebin);

  TH1F *hEventLength=new TH1F("hEventLength","hEventLength",77,-2,75);
  hEventLength->SetTitle("Event Length");
  hEventLength->GetXaxis()->SetTitle("Event Length");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hEventLengthN_1=new TH1F("hEventLengthN_1","hEventLengthN_1",
                               77,-2,75);
  hEventLengthN_1->SetTitle("Event Length");  
  hEventLengthN_1->GetXaxis()->SetTitle("Event Length");
  hEventLengthN_1->GetXaxis()->CenterTitle();
  hEventLengthN_1->GetYaxis()->SetTitle("");
  hEventLengthN_1->GetYaxis()->CenterTitle();
  hEventLengthN_1->SetFillColor(0);
  hEventLengthN_1->SetLineColor(2);
  hEventLengthN_1->SetBit(TH1::kCanRebin);

  TH1F *hEventLengthN=new TH1F("hEventLengthN","hEventLengthN",
                               77,-2,75);
  hEventLengthN->SetTitle("Event Length");  
  hEventLengthN->GetXaxis()->SetTitle("Event Length");
  hEventLengthN->GetXaxis()->CenterTitle();
  hEventLengthN->GetYaxis()->SetTitle("");
  hEventLengthN->GetYaxis()->CenterTitle();
  hEventLengthN->SetFillColor(0);
  hEventLengthN->SetLineColor(4);
  hEventLengthN->SetBit(TH1::kCanRebin);

  TH1F *hNumHits=new TH1F("hNumHits","hNumHits",200,-2,200);
  hNumHits->SetTitle("Number of Hits");
  hNumHits->GetXaxis()->SetTitle("Number of Hits");
  hNumHits->GetXaxis()->CenterTitle();
  hNumHits->GetYaxis()->SetTitle("");
  hNumHits->GetYaxis()->CenterTitle();
  hNumHits->SetFillColor(0);
  //hNumHits->SetBit(TH1::kCanRebin);

  TH1F *hNumHitsN_1=new TH1F("hNumHitsN_1","hNumHitsN_1",200,-2,200);
  hNumHitsN_1->SetTitle("Number of Hits");
  hNumHitsN_1->GetXaxis()->SetTitle("Number of Hits");
  hNumHitsN_1->GetXaxis()->CenterTitle();
  hNumHitsN_1->GetYaxis()->SetTitle("");
  hNumHitsN_1->GetYaxis()->CenterTitle();
  hNumHitsN_1->SetFillColor(0);
  hNumHitsN_1->SetLineColor(2);
  //hNumHitsN_1->SetBit(TH1::kCanRebin);

  TH1F *hNumHitsN=new TH1F("hNumHitsN","hNumHitsN",200,-2,200);
  hNumHitsN->SetTitle("Number of Hits");
  hNumHitsN->GetXaxis()->SetTitle("Number of Hits");
  hNumHitsN->GetXaxis()->CenterTitle();
  hNumHitsN->GetYaxis()->SetTitle("");
  hNumHitsN->GetYaxis()->CenterTitle();
  hNumHitsN->SetFillColor(0);
  hNumHitsN->SetLineColor(4);
  //hNumHitsN->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPl=new TH1F("hHitsPerPl","hHitsPerPl",
                               200,-1,12);
  hHitsPerPl->SetTitle("Number of Hits per Plane");
  hHitsPerPl->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPl->GetXaxis()->CenterTitle();
  hHitsPerPl->GetYaxis()->SetTitle("");
  hHitsPerPl->GetYaxis()->CenterTitle();
  hHitsPerPl->SetFillColor(0);
  //hHitsPerPl->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlN_1=new TH1F("hHitsPerPlN_1","hHitsPerPlN_1",
                               200,-1,12);
  hHitsPerPlN_1->SetTitle("Number of Hits per Plane");
  hHitsPerPlN_1->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlN_1->GetXaxis()->CenterTitle();
  hHitsPerPlN_1->GetYaxis()->SetTitle("");
  hHitsPerPlN_1->GetYaxis()->CenterTitle();
  hHitsPerPlN_1->SetFillColor(0);
  hHitsPerPlN_1->SetLineColor(2);
  //hHitsPerPlN_1->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlN_1XCut=new TH1F("hHitsPerPlN_1XCut",
                                   "hHitsPerPlN_1XCut",
                                   200,-1,12);
  hHitsPerPlN_1XCut->SetTitle("Number of Hits per Plane");
  hHitsPerPlN_1XCut->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlN_1XCut->GetXaxis()->CenterTitle();
  hHitsPerPlN_1XCut->GetYaxis()->SetTitle("");
  hHitsPerPlN_1XCut->GetYaxis()->CenterTitle();
  hHitsPerPlN_1XCut->SetFillColor(0);
  hHitsPerPlN_1XCut->SetLineColor(2);
  //hHitsPerPlN_1XCut->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlN=new TH1F("hHitsPerPlN","hHitsPerPlN",
                               200,-1,12);
  hHitsPerPlN->SetTitle("Number of Hits per Plane");
  hHitsPerPlN->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlN->GetXaxis()->CenterTitle();
  hHitsPerPlN->GetYaxis()->SetTitle("");
  hHitsPerPlN->GetYaxis()->CenterTitle();
  hHitsPerPlN->SetFillColor(0);
  hHitsPerPlN->SetLineColor(4);
  //hHitsPerPlN->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlInWin=new TH1F("hHitsPerPlInWin","hHitsPerPlInWin",
                               200,-1,12);
  hHitsPerPlInWin->SetTitle("Number of Hits per Plane");
  hHitsPerPlInWin->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlInWin->GetXaxis()->CenterTitle();
  hHitsPerPlInWin->GetYaxis()->SetTitle("");
  hHitsPerPlInWin->GetYaxis()->CenterTitle();
  hHitsPerPlInWin->SetFillColor(0);
  hHitsPerPlInWin->SetLineColor(6);
  //hHitsPerPlInWin->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlPeCutN_1=new TH1F("hHitsPerPlPeCutN_1",
                                    "hHitsPerPlPeCutN_1",200,-1,12);
  hHitsPerPlPeCutN_1->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCutN_1->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCutN_1->GetXaxis()->CenterTitle();
  hHitsPerPlPeCutN_1->GetYaxis()->SetTitle("");
  hHitsPerPlPeCutN_1->GetYaxis()->CenterTitle();
  hHitsPerPlPeCutN_1->SetFillColor(0);
  hHitsPerPlPeCutN_1->SetLineColor(3);
  //hHitsPerPlPeCutN_1->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlPeCut10=new TH1F("hHitsPerPlPeCut10",
                                   "hHitsPerPlPeCut10",
                                   200,-1,12);
  hHitsPerPlPeCut10->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10->GetXaxis()->CenterTitle();
  hHitsPerPlPeCut10->GetYaxis()->SetTitle("");
  hHitsPerPlPeCut10->GetYaxis()->CenterTitle();
  hHitsPerPlPeCut10->SetFillColor(0);
  //hHitsPerPlPeCut10->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPlPeCut10N_1=new TH1F("hHitsPerPlPeCut10N_1",
                                      "hHitsPerPlPeCut10N_1",
                                      200,-1,12);
  hHitsPerPlPeCut10N_1->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10N_1->GetXaxis()->
    SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10N_1->GetXaxis()->CenterTitle();
  hHitsPerPlPeCut10N_1->GetYaxis()->SetTitle("");
  hHitsPerPlPeCut10N_1->GetYaxis()->CenterTitle();
  hHitsPerPlPeCut10N_1->SetFillColor(0);
  hHitsPerPlPeCut10N_1->SetLineColor(2);
  //hHitsPerPlPeCut10N_1->SetBit(TH1::kCanRebin);
  
  TH1F *hHitsPerPlPeCut10N=new TH1F("hHitsPerPlPeCut10N",
                                    "hHitsPerPlPeCut10N",
                                    200,-1,12);
  hHitsPerPlPeCut10N->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10N->GetXaxis()->SetTitle("Number of Hits per Plane");
  hHitsPerPlPeCut10N->GetXaxis()->CenterTitle();
  hHitsPerPlPeCut10N->GetYaxis()->SetTitle("");
  hHitsPerPlPeCut10N->GetYaxis()->CenterTitle();
  hHitsPerPlPeCut10N->SetFillColor(0);
  hHitsPerPlPeCut10N->SetLineColor(4);
  //hHitsPerPlPeCut10N->SetBit(TH1::kCanRebin);

  TH1F *hHitsPerPl25N_1=new TH1F("hHitsPerPl25N_1",
                                 "hHitsPerPl25N_1",200,-1,12);
  hHitsPerPl25N_1->SetTitle("Number of Hits per Plane");
  hHitsPerPl25N_1->GetXaxis()->
    SetTitle("Number of Hits per Plane");
  hHitsPerPl25N_1->GetXaxis()->CenterTitle();
  hHitsPerPl25N_1->GetYaxis()->SetTitle("");
  hHitsPerPl25N_1->GetYaxis()->CenterTitle();
  hHitsPerPl25N_1->SetFillColor(0);
  hHitsPerPl25N_1->SetLineColor(2);
  //hHitsPerPl25N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow1=new TH1F("hTofScintDiffLow1",
                                   "hTofScintDiffLow1",500,-500,500);
  hTofScintDiffLow1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1->GetXaxis()->CenterTitle();
  hTofScintDiffLow1->GetYaxis()->SetTitle("");
  hTofScintDiffLow1->GetYaxis()->CenterTitle();
  hTofScintDiffLow1->SetFillColor(0);
  hTofScintDiffLow1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow1N_1=new TH1F("hTofScintDiffLow1N_1",
                                   "hTofScintDiffLow1N_1",500,-500,500);
  hTofScintDiffLow1N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1N_1->GetXaxis()->CenterTitle();
  hTofScintDiffLow1N_1->GetYaxis()->SetTitle("");
  hTofScintDiffLow1N_1->GetYaxis()->CenterTitle();
  hTofScintDiffLow1N_1->SetFillColor(0);
  hTofScintDiffLow1N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow1N=new TH1F("hTofScintDiffLow1N",
                                   "hTofScintDiffLow1N",500,-500,500);
  hTofScintDiffLow1N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow1N->GetXaxis()->CenterTitle();
  hTofScintDiffLow1N->GetYaxis()->SetTitle("");
  hTofScintDiffLow1N->GetYaxis()->CenterTitle();
  hTofScintDiffLow1N->SetFillColor(0);
  hTofScintDiffLow1N->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp1=new TH1F("hTofScintDiffUp1",
                                  "hTofScintDiffUp1",500,-500,500);
  hTofScintDiffUp1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1->GetXaxis()->CenterTitle();
  hTofScintDiffUp1->GetYaxis()->SetTitle("");
  hTofScintDiffUp1->GetYaxis()->CenterTitle();
  hTofScintDiffUp1->SetFillColor(0);
  hTofScintDiffUp1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp1N_1=new TH1F("hTofScintDiffUp1N_1",
                                  "hTofScintDiffUp1N_1",500,-500,500);
  hTofScintDiffUp1N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1N_1->GetXaxis()->CenterTitle();
  hTofScintDiffUp1N_1->GetYaxis()->SetTitle("");
  hTofScintDiffUp1N_1->GetYaxis()->CenterTitle();
  hTofScintDiffUp1N_1->SetFillColor(0);
  hTofScintDiffUp1N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp1N=new TH1F("hTofScintDiffUp1N",
                                  "hTofScintDiffUp1N",500,-500,500);
  hTofScintDiffUp1N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp1N->GetXaxis()->CenterTitle();
  hTofScintDiffUp1N->GetYaxis()->SetTitle("");
  hTofScintDiffUp1N->GetYaxis()->CenterTitle();
  hTofScintDiffUp1N->SetFillColor(0);
  hTofScintDiffUp1N->SetBit(TH1::kCanRebin);
  
  TH1F *hTofScintDiff=new TH1F("hTofScintDiff",
                                "hTofScintDiff",500,-500,500);
  hTofScintDiff->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff->GetXaxis()->CenterTitle();
  hTofScintDiff->GetYaxis()->SetTitle("");
  hTofScintDiff->GetYaxis()->CenterTitle();
  hTofScintDiff->SetFillColor(0);
  hTofScintDiff->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffN_1=new TH1F("hTofScintDiffN_1",
                                  "hTofScintDiffN_1",500,-500,500);
  hTofScintDiffN_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffN_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffN_1->GetXaxis()->CenterTitle();
  hTofScintDiffN_1->GetYaxis()->SetTitle("");
  hTofScintDiffN_1->GetYaxis()->CenterTitle();
  hTofScintDiffN_1->SetFillColor(0);
  hTofScintDiffN_1->SetLineColor(2);
  hTofScintDiffN_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffN=new TH1F("hTofScintDiffN",
                                  "hTofScintDiffN",500,-500,500);
  hTofScintDiffN->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffN->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffN->GetXaxis()->CenterTitle();
  hTofScintDiffN->GetYaxis()->SetTitle("");
  hTofScintDiffN->GetYaxis()->CenterTitle();
  hTofScintDiffN->SetFillColor(0);
  hTofScintDiffN->SetLineColor(4);
  hTofScintDiffN->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff1=new TH1F("hTofScintDiff1",
                                "hTofScintDiff1",500,-500,500);
  hTofScintDiff1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1->GetXaxis()->CenterTitle();
  hTofScintDiff1->GetYaxis()->SetTitle("");
  hTofScintDiff1->GetYaxis()->CenterTitle();
  hTofScintDiff1->SetFillColor(0);
  hTofScintDiff1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff1N_1=new TH1F("hTofScintDiff1N_1",
                                   "hTofScintDiff1N_1",500,-500,500);
  hTofScintDiff1N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1N_1->GetXaxis()->CenterTitle();
  hTofScintDiff1N_1->GetYaxis()->SetTitle("");
  hTofScintDiff1N_1->GetYaxis()->CenterTitle();
  hTofScintDiff1N_1->SetFillColor(0);
  hTofScintDiff1N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff1N=new TH1F("hTofScintDiff1N",
                                 "hTofScintDiff1N",500,-500,500);
  hTofScintDiff1N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff1N->GetXaxis()->CenterTitle();
  hTofScintDiff1N->GetYaxis()->SetTitle("");
  hTofScintDiff1N->GetYaxis()->CenterTitle();
  hTofScintDiff1N->SetFillColor(0);
  hTofScintDiff1N->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow2=new TH1F("hTofScintDiffLow2",
                                   "hTofScintDiffLow2",500,-500,500);
  hTofScintDiffLow2->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2->GetXaxis()->CenterTitle();
  hTofScintDiffLow2->GetYaxis()->SetTitle("");
  hTofScintDiffLow2->GetYaxis()->CenterTitle();
  hTofScintDiffLow2->SetFillColor(0);
  hTofScintDiffLow2->SetLineColor(2);
  hTofScintDiffLow2->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow2N_1=new TH1F("hTofScintDiffLow2N_1",
                                      "hTofScintDiffLow2N_1",
                                      500,-500,500);
  hTofScintDiffLow2N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2N_1->GetXaxis()->CenterTitle();
  hTofScintDiffLow2N_1->GetYaxis()->SetTitle("");
  hTofScintDiffLow2N_1->GetYaxis()->CenterTitle();
  hTofScintDiffLow2N_1->SetFillColor(0);
  hTofScintDiffLow2N_1->SetLineColor(2);
  hTofScintDiffLow2N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffLow2N=new TH1F("hTofScintDiffLow2N",
                                    "hTofScintDiffLow2N",
                                    500,-500,500);
  hTofScintDiffLow2N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffLow2N->GetXaxis()->CenterTitle();
  hTofScintDiffLow2N->GetYaxis()->SetTitle("");
  hTofScintDiffLow2N->GetYaxis()->CenterTitle();
  hTofScintDiffLow2N->SetFillColor(0);
  hTofScintDiffLow2N->SetLineColor(2);
  hTofScintDiffLow2N->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp2=new TH1F("hTofScintDiffUp2",
                                  "hTofScintDiffUp2",500,-500,500);
  hTofScintDiffUp2->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2->GetXaxis()->CenterTitle();
  hTofScintDiffUp2->GetYaxis()->SetTitle("");
  hTofScintDiffUp2->GetYaxis()->CenterTitle();
  hTofScintDiffUp2->SetFillColor(0);
  hTofScintDiffUp2->SetLineColor(2);
  hTofScintDiffUp2->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp2N_1=new TH1F("hTofScintDiffUp2N_1",
                                  "hTofScintDiffUp2N_1",500,-500,500);
  hTofScintDiffUp2N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2N_1->GetXaxis()->CenterTitle();
  hTofScintDiffUp2N_1->GetYaxis()->SetTitle("");
  hTofScintDiffUp2N_1->GetYaxis()->CenterTitle();
  hTofScintDiffUp2N_1->SetFillColor(0);
  hTofScintDiffUp2N_1->SetLineColor(2);
  hTofScintDiffUp2N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiffUp2N=new TH1F("hTofScintDiffUp2N",
                                  "hTofScintDiffUp2N",500,-500,500);
  hTofScintDiffUp2N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiffUp2N->GetXaxis()->CenterTitle();
  hTofScintDiffUp2N->GetYaxis()->SetTitle("");
  hTofScintDiffUp2N->GetYaxis()->CenterTitle();
  hTofScintDiffUp2N->SetFillColor(0);
  hTofScintDiffUp2N->SetLineColor(2);
  hTofScintDiffUp2N->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff2=new TH1F("hTofScintDiff2",
                                "hTofScintDiff2",500,-500,500);
  hTofScintDiff2->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2->GetXaxis()->CenterTitle();
  hTofScintDiff2->GetYaxis()->SetTitle("");
  hTofScintDiff2->GetYaxis()->CenterTitle();
  hTofScintDiff2->SetFillColor(0);
  hTofScintDiff2->SetLineColor(2);
  hTofScintDiff2->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff2N_1=new TH1F("hTofScintDiff2N_1",
                                   "hTofScintDiff2N_1",500,-500,500);
  hTofScintDiff2N_1->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2N_1->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2N_1->GetXaxis()->CenterTitle();
  hTofScintDiff2N_1->GetYaxis()->SetTitle("");
  hTofScintDiff2N_1->GetYaxis()->CenterTitle();
  hTofScintDiff2N_1->SetFillColor(0);
  hTofScintDiff2N_1->SetLineColor(2);
  hTofScintDiff2N_1->SetBit(TH1::kCanRebin);

  TH1F *hTofScintDiff2N=new TH1F("hTofScintDiff2N",
                                 "hTofScintDiff2N",500,-500,500);
  hTofScintDiff2N->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2N->GetXaxis()->SetTitle("TOF Scint. Time Diff.");
  hTofScintDiff2N->GetXaxis()->CenterTitle();
  hTofScintDiff2N->GetYaxis()->SetTitle("");
  hTofScintDiff2N->GetYaxis()->CenterTitle();
  hTofScintDiff2N->SetFillColor(0);
  hTofScintDiff2N->SetLineColor(2);
  hTofScintDiff2N->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1=new TH1F("hKovADC1","KovADC1",400,-5,10000);
  hKovADC1->GetXaxis()->SetTitle("KovADC1");
  hKovADC1->GetXaxis()->CenterTitle();
  hKovADC1->GetYaxis()->SetTitle("");
  hKovADC1->GetYaxis()->CenterTitle();
  hKovADC1->SetFillColor(0);
  hKovADC1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1N_1=new TH1F("hKovADC1N_1","KovADC1N_1",400,-5,10000);
  hKovADC1N_1->GetXaxis()->SetTitle("KovADC1");
  hKovADC1N_1->GetXaxis()->CenterTitle();
  hKovADC1N_1->GetYaxis()->SetTitle("");
  hKovADC1N_1->GetYaxis()->CenterTitle();
  hKovADC1N_1->SetFillColor(0);
  hKovADC1N_1->SetLineColor(2);
  hKovADC1N_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1N=new TH1F("hKovADC1N","KovADC1N",400,-5,10000);
  hKovADC1N->GetXaxis()->SetTitle("KovADC1");
  hKovADC1N->GetXaxis()->CenterTitle();
  hKovADC1N->GetYaxis()->SetTitle("");
  hKovADC1N->GetYaxis()->CenterTitle();
  hKovADC1N->SetFillColor(0);
  hKovADC1N->SetLineColor(4);
  hKovADC1N->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2=new TH1F("hKovADC2","KovADC2",400,-5,10000);
  hKovADC2->GetXaxis()->SetTitle("KovADC2");
  hKovADC2->GetXaxis()->CenterTitle();
  hKovADC2->GetYaxis()->SetTitle("");
  hKovADC2->GetYaxis()->CenterTitle();
  hKovADC2->SetFillColor(0);
  hKovADC2->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2N_1=new TH1F("hKovADC2N_1","KovADC2N_1",400,-5,10000);
  hKovADC2N_1->GetXaxis()->SetTitle("KovADC2");
  hKovADC2N_1->GetXaxis()->CenterTitle();
  hKovADC2N_1->GetYaxis()->SetTitle("");
  hKovADC2N_1->GetYaxis()->CenterTitle();
  hKovADC2N_1->SetFillColor(0);
  hKovADC2N_1->SetLineColor(2);
  hKovADC2N_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2N=new TH1F("hKovADC2N","KovADC2N",400,-5,10000);
  hKovADC2N->GetXaxis()->SetTitle("KovADC2");
  hKovADC2N->GetXaxis()->CenterTitle();
  hKovADC2N->GetYaxis()->SetTitle("");
  hKovADC2N->GetYaxis()->CenterTitle();
  hKovADC2N->SetFillColor(0);
  hKovADC2N->SetLineColor(4);
  hKovADC2N->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3=new TH1F("hKovADC3","KovADC3",400,-5,10000);
  hKovADC3->GetXaxis()->SetTitle("KovADC3");
  hKovADC3->GetXaxis()->CenterTitle();
  hKovADC3->GetYaxis()->SetTitle("");
  hKovADC3->GetYaxis()->CenterTitle();
  hKovADC3->SetFillColor(0);
  hKovADC3->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3N_1=new TH1F("hKovADC3N_1","KovADC3N_1",400,-5,10000);
  hKovADC3N_1->GetXaxis()->SetTitle("KovADC3");
  hKovADC3N_1->GetXaxis()->CenterTitle();
  hKovADC3N_1->GetYaxis()->SetTitle("");
  hKovADC3N_1->GetYaxis()->CenterTitle();
  hKovADC3N_1->SetFillColor(0);
  hKovADC3N_1->SetLineColor(2);
  hKovADC3N_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3N=new TH1F("hKovADC3N","KovADC3N",400,-5,10000);
  hKovADC3N->GetXaxis()->SetTitle("KovADC3");
  hKovADC3N->GetXaxis()->CenterTitle();
  hKovADC3N->GetYaxis()->SetTitle("");
  hKovADC3N->GetYaxis()->CenterTitle();
  hKovADC3N->SetFillColor(0);
  hKovADC3N->SetLineColor(4);
  hKovADC3N->SetBit(TH1::kCanRebin);

  TH1F *hTofDiff=new TH1F("hTofDiff","hTofDiff",400,-4000,4000);
  hTofDiff->GetXaxis()->SetTitle("TOF");
  hTofDiff->GetXaxis()->CenterTitle();
  hTofDiff->GetYaxis()->SetTitle("");
  hTofDiff->GetYaxis()->CenterTitle();
  hTofDiff->SetFillColor(0);
  hTofDiff->SetBit(TH1::kCanRebin);

  TH1F *hTofDiffN_1=new TH1F("hTofDiffN_1","hTofDiffN_1",400,-4000,4000);
  hTofDiffN_1->GetXaxis()->SetTitle("TOF");
  hTofDiffN_1->GetXaxis()->CenterTitle();
  hTofDiffN_1->GetYaxis()->SetTitle("");
  hTofDiffN_1->GetYaxis()->CenterTitle();
  hTofDiffN_1->SetFillColor(0);
  hTofDiffN_1->SetLineColor(2);
  hTofDiffN_1->SetBit(TH1::kCanRebin);

  TH1F *hTofDiffN=new TH1F("hTofDiffN","hTofDiffN",400,-4000,4000);
  hTofDiffN->GetXaxis()->SetTitle("TOF");
  hTofDiffN->GetXaxis()->CenterTitle();
  hTofDiffN->GetYaxis()->SetTitle("");
  hTofDiffN->GetYaxis()->CenterTitle();
  hTofDiffN->SetFillColor(0);
  hTofDiffN->SetLineColor(4);
  hTofDiffN->SetBit(TH1::kCanRebin);

  TH1F *hAvStrip=new TH1F("hAvStrip","hAvStrip",25,-1,24);
  hAvStrip->GetXaxis()->SetTitle("Average Strip");
  hAvStrip->GetXaxis()->CenterTitle();
  hAvStrip->GetYaxis()->SetTitle("");
  hAvStrip->GetYaxis()->CenterTitle();
  hAvStrip->SetFillColor(0);
  hAvStrip->SetBit(TH1::kCanRebin);

  TH1F *hAvStripN_1=new TH1F("hAvStripN_1","hAvStripN_1",25,-1,24);
  hAvStripN_1->GetXaxis()->SetTitle("Average Strip");
  hAvStripN_1->GetXaxis()->CenterTitle();
  hAvStripN_1->GetYaxis()->SetTitle("");
  hAvStripN_1->GetYaxis()->CenterTitle();
  hAvStripN_1->SetFillColor(0);
  hAvStripN_1->SetLineColor(2);
  hAvStripN_1->SetBit(TH1::kCanRebin);

  TH1F *hAvStripN=new TH1F("hAvStripN","hAvStripN",25,-1,24);
  hAvStripN->GetXaxis()->SetTitle("Average Strip");
  hAvStripN->GetXaxis()->CenterTitle();
  hAvStripN->GetYaxis()->SetTitle("");
  hAvStripN->GetYaxis()->CenterTitle();
  hAvStripN->SetFillColor(0);
  hAvStripN->SetLineColor(4);
  hAvStripN->SetBit(TH1::kCanRebin);

  TH1F *hFirstPlane=new TH1F("hFirstPlane",
                             "hFirstPlane",77,-2,75);
  hFirstPlane->GetXaxis()->SetTitle("First Plane");
  hFirstPlane->GetXaxis()->CenterTitle();
  hFirstPlane->GetYaxis()->SetTitle("");
  hFirstPlane->GetYaxis()->CenterTitle();
  hFirstPlane->SetFillColor(0);
  hFirstPlane->SetBit(TH1::kCanRebin);

  TH1F *hFirstPlaneN_1=new TH1F("hFirstPlaneN_1",
                                "hFirstPlaneN_1",77,-2,75);
  hFirstPlaneN_1->GetXaxis()->SetTitle("First Plane");
  hFirstPlaneN_1->GetXaxis()->CenterTitle();
  hFirstPlaneN_1->GetYaxis()->SetTitle("");
  hFirstPlaneN_1->GetYaxis()->CenterTitle();
  hFirstPlaneN_1->SetFillColor(0);
  hFirstPlaneN_1->SetLineColor(2);
  hFirstPlaneN_1->SetBit(TH1::kCanRebin);

  TH1F *hFirstPlaneN=new TH1F("hFirstPlaneN",
                              "hFirstPlaneN",77,-2,75);
  hFirstPlaneN->GetXaxis()->SetTitle("First Plane");
  hFirstPlaneN->GetXaxis()->CenterTitle();
  hFirstPlaneN->GetYaxis()->SetTitle("");
  hFirstPlaneN->GetYaxis()->CenterTitle();
  hFirstPlaneN->SetFillColor(0);
  hFirstPlaneN->SetLineColor(4);
  hFirstPlaneN->SetBit(TH1::kCanRebin);

  TH1F* hLowEn=new TH1F("hLowEn","hLowEn",6000,-1,20);
  hLowEn->SetTitle("hLowEn");
  hLowEn->GetXaxis()->SetTitle("hLowEn");
  hLowEn->GetXaxis()->CenterTitle();
  hLowEn->SetFillColor(0);
  hLowEn->SetLineWidth(3);
  //hLowEn->SetBit(TH1::kCanRebin);

  TH1F* hHighEn=new TH1F("hHighEn","hHighEn",6000,-1,20);
  hHighEn->SetTitle("hHighEn");
  hHighEn->GetXaxis()->SetTitle("hHighEn");
  hHighEn->GetXaxis()->CenterTitle();
  hHighEn->SetFillColor(0);
  //hHighEn->SetBit(TH1::kCanRebin);

  vector<TProfile*> pSigCorVsDist;
  vector<TProfile*> pSigCorVsDistN;
  vector<Int_t> vWindowSize;
  vector<Float_t> bigAv;
  vector<Int_t> bigAvCounter;
  Float_t sum15_18=0;
  Float_t sum15_18Counter=0;
  Float_t sum15_18Mip=0;
  Float_t sum15_18MipCounter=0;
  Float_t sumSigCorTotal=0;
  Float_t sumSigCorTotalCounter=0;
  Float_t sumMipTotal=0;
  Float_t sumMipTotalCounter=0;

  //num maps for all stripends
  map<Int_t,Float_t> num;
  map<Int_t,Float_t> numX;
  map<Int_t,Float_t> numT;
  map<Int_t,Float_t> numOs;
  map<Int_t,Float_t> numOsX;
  map<Int_t,Float_t> numOsT;

  //non-offset num maps for individual stripends
  map<Int_t,Float_t> numO1;
  map<Int_t,Float_t> numO1X;
  map<Int_t,Float_t> numO1T;
  map<Int_t,Float_t> numO2;
  map<Int_t,Float_t> numO2X;
  map<Int_t,Float_t> numO2T;
  map<Int_t,Float_t> numE1;
  map<Int_t,Float_t> numE1X;
  map<Int_t,Float_t> numE1T;
  map<Int_t,Float_t> numE2;
  map<Int_t,Float_t> numE2X;
  map<Int_t,Float_t> numE2T;

  //offset num maps for individual stripends
  map<Int_t,Float_t> numOsO1;
  map<Int_t,Float_t> numOsO1X;
  map<Int_t,Float_t> numOsO1T;
  map<Int_t,Float_t> numOsO2;
  map<Int_t,Float_t> numOsO2X;
  map<Int_t,Float_t> numOsO2T;
  map<Int_t,Float_t> numOsE1;
  map<Int_t,Float_t> numOsE1X;
  map<Int_t,Float_t> numOsE1T;
  map<Int_t,Float_t> numOsE2;
  map<Int_t,Float_t> numOsE2X;
  map<Int_t,Float_t> numOsE2T;

  Int_t passPidCounter=0;
  Int_t straightTrackCounter=0;
  Int_t NCutsCounter=0;

  //txt file to hold events

  ofstream& eventsTxtFile=(*(this->OpenTxtFile(fRunNumber,
                                                "myevents")));
  ofstream& eventsTxtFileHpp=(*(this->OpenTxtFile(fRunNumber,
                                                  "myeventsHpp")));
  ofstream& eventsTxtFileHpp10=(*(this->OpenTxtFile(fRunNumber,
                                                   "myeventsHpp10")));
  ofstream& eventsTxtFilePSMu=(*(this->OpenTxtFile(fRunNumber,
                                                   "myeventsPSMu")));
  ofstream& eventsTxtFileOL=(*(this->OpenTxtFile(fRunNumber,
                                                 "myeventsOL")));
  ofstream& eventsTxtFileFidVol=
    (*(this->OpenTxtFile(fRunNumber,"myeventsFidVol")));
  ofstream& eventsTxtFileStrips25=(*(this->OpenTxtFile
                                     (fRunNumber,"myeventsStrips25")));
  ofstream& eventsTxtFileLowPlanesHit=
    (*(this->OpenTxtFile(fRunNumber,"myeventsLowPlanesHit")));

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //the dead chips should be random and so can be done here
    if (this->CutOnDeadChips()) continue;
    //only do full analysis if time is greater than minRunTime
    if (ts.GetSec()<minRunTime){
      if (this->CutOnPid()) continue;
    }

    map<Int_t,Float_t> planeSigCor;
    map<Int_t,Float_t> planeSigCorX;
    map<Int_t,Float_t> planeSigCorT;
    map<Int_t,Float_t> planeSigCorO1;    
    map<Int_t,Float_t> planeSigCorO1X;
    map<Int_t,Float_t> planeSigCorO1T;
    map<Int_t,Float_t> planeSigCorO2;
    map<Int_t,Float_t> planeSigCorO2X;
    map<Int_t,Float_t> planeSigCorO2T;
    map<Int_t,Float_t> planeSigCorE1;
    map<Int_t,Float_t> planeSigCorE1X;
    map<Int_t,Float_t> planeSigCorE1T;
    map<Int_t,Float_t> planeSigCorE2;
    map<Int_t,Float_t> planeSigCorE2X;
    map<Int_t,Float_t> planeSigCorE2T;

    map<Int_t,Float_t> planeMip;
    map<Int_t,Float_t> planeMipX;
    map<Int_t,Float_t> planeMipT;

    //Int_t numHits=0;

    map<Int_t,map<Int_t,Float_t> > stplSigCor;
    map<Int_t,map<Int_t,Float_t> > stplNum;

    Int_t lowTrkStrip=25;//stores the lowest tracked strip
    Int_t upTrkStrip=-1;
    Int_t lowTrkStripPeCut=25;
    Int_t upTrkStripPeCut=-1;

    vector<Float_t> vTimes1;//store all the times
    vector<Float_t> vTimes2;//store all the times
    vTimes1.reserve(100);
    vTimes2.reserve(100);

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calc the number of planes hit
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);
      //store the times
      if (fStripend==2 || 
          (fStripend==1 && fPlane==0 && fRunNumber>70000)) {
        vTimes2.push_back(fTime);
      }
      else if (fStripend==1) vTimes1.push_back(fTime);
          
      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      //store the plane and strip info
      (stplSigCor[fPlane])[fStrip]+=fChargeSigCor;
      (stplNum[fPlane])[fStrip]++;

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fStripend==1) pStVsPl1->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==2) pStVsPl2->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==1) hStVsPl1->Fill(fPlane,fStrip);
      if (fStripend==2) hStVsPl2->Fill(fPlane,fStrip);
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calc the number of planes hit
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);
      //store the times
      if (fStripend==2 || 
          (fStripend==1 && fPlane==0 && fRunNumber>70000)) {
        vTimes2.push_back(fTime);
      }
      else if (fStripend==1) vTimes1.push_back(fTime);

      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      //store the plane and strip info
      (stplSigCor[fPlane])[fStrip]+=fChargeSigCor;
      (stplNum[fPlane])[fStrip]++;

      //add up the charge of the hits in each plane
      planeSigCorX[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMipX[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;
      if (fO1) planeSigCorO1X[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2X[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1X[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2X[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fStripend==1) pStVsPl1->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==2) pStVsPl2->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==1) hStVsPl1->Fill(fPlane,fStrip);
      if (fStripend==2) hStVsPl2->Fill(fPlane,fStrip);
    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calc the number of planes hit
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);
      //calc the average strip for the ps muon cut
      this->CalcAvStripForPSMuonCut(fPlane,fStrip,fStripend);

      //calc the lowest and highest tracked strips
      if (fStrip<lowTrkStrip) lowTrkStrip=fStrip;
      if (fStrip>upTrkStrip) upTrkStrip=fStrip;
      if (fChargePe>1.5){
        if (fStrip<lowTrkStripPeCut) lowTrkStripPeCut=fStrip;
        if (fStrip>upTrkStripPeCut) upTrkStripPeCut=fStrip;
      }

      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);
      //store the times
      if (fStripend==2 || 
          (fStripend==1 && fPlane==0 && fRunNumber>70000)) {
        vTimes2.push_back(fTime);
      }
      else if (fStripend==1) vTimes1.push_back(fTime);

      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      //store the plane and strip info
      (stplSigCor[fPlane])[fStrip]+=fChargeSigCor;
      (stplNum[fPlane])[fStrip]++;

      //add up the charge of the hits in each plane
      planeSigCor[fPlane]+=fChargeSigCor;
      planeSigCorT[fPlane]+=fChargeSigCor;
      planeMip[fPlane]+=fChargeMip;
      planeMipT[fPlane]+=fChargeMip;

      if (fO1) planeSigCorO1[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2[fPlane]+=fChargeSigCor;
      if (fO1) planeSigCorO1T[fPlane]+=fChargeSigCor;
      if (fO2) planeSigCorO2T[fPlane]+=fChargeSigCor;
      if (fE1) planeSigCorE1T[fPlane]+=fChargeSigCor;
      if (fE2) planeSigCorE2T[fPlane]+=fChargeSigCor;

      if (fStripend==1) pStVsPl1->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==2) pStVsPl2->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==1) hStVsPl1->Fill(fPlane,fStrip);
      if (fStripend==2) hStVsPl2->Fill(fPlane,fStrip);
    }
    //end of loop over the tracked hits

    //get the number of planes
    const Float_t numPlanesHit=fNumPlanesHitAll.size();
    const Float_t numPlanesHit25=fNumPlanesHit25.size();
    const Float_t numPlanesHitPeCut=fNumPlanesHitPeCut.size();
    const Float_t numPlanesHitPeCut10=fNumPlanesHitPeCut10.size();

    //calc the number of hits
    const Float_t numHits=this->SumMapValues(fNumPlanesHitAll);
    const Float_t numHits25=this->SumMapValues(fNumPlanesHit25);
    const Float_t numHitsPeCut=this->SumMapValues(fNumPlanesHitPeCut);
    const Float_t numHitsPeCut10=this->
      SumMapValues(fNumPlanesHitPeCut10);

    //calc the number of hits per plane
    const Float_t numHitsPerPlane=(numPlanesHit>0)?
      numHits/numPlanesHit:-0.5;
    const Float_t numHitsPerPlane25=(numPlanesHit25>0)?
      numHits25/numPlanesHit25:-0.5;
    const Float_t numHitsPerPlanePeCut=(numPlanesHitPeCut>0)?
      numHitsPeCut/numPlanesHitPeCut:-0.5;
    const Float_t numHitsPerPlanePeCut10=(numPlanesHitPeCut10>0)?
      numHitsPeCut10/numPlanesHitPeCut10:-0.5;

    const Int_t lowStripsFromCentre=12-lowTrkStrip;
    const Int_t upStripsFromCentre=upTrkStrip-11;
    const Int_t stripsFromCentre=
      (upStripsFromCentre>lowStripsFromCentre)?
      upStripsFromCentre:lowStripsFromCentre;
    const Int_t lowStripsFromCentrePeCut=12-lowTrkStripPeCut;
    const Int_t upStripsFromCentrePeCut=upTrkStripPeCut-11;
    const Int_t stripsFromCentrePeCut=
      (upStripsFromCentrePeCut>lowStripsFromCentrePeCut)?
      upStripsFromCentrePeCut:lowStripsFromCentrePeCut;
    
    const Int_t eventLength=this->GetEventLength();

    //set the globals (do this before cut booleans)
    fNumHitsPerPlane=numHitsPerPlane;
    fNumHitsPerPlane25=numHitsPerPlane25;
    fNumHitsPerPlanePeCut10=numHitsPerPlanePeCut10;
    fStripsFromCentrePeCut=stripsFromCentrePeCut;

    //official cuts
    Bool_t passesPidCut=!this->CutOnPid();
    Bool_t passesEventLengthCut=!this->CutOnEventLength();
    //MAXMSG("CDAnalysis",Msg::kInfo,200)
    //<<"Nasty, fiducial volume hack..."<<endl;
    //Bool_t passesFiducialVolumeCut=true;
    Bool_t passesFiducialVolumeCut=!this->CutOnFiducialVolume();
    Bool_t passesTrackQualityCut=!this->CutOnTrackQuality(true);
    Bool_t passesScint_TofDiffCut=!this->CutOnScint_TofDiff();
    Bool_t passesPSMuonsCut=!this->CutOnPSMuons();
    Bool_t passesNumHitsPerPlane10Cut=!this->CutOnNumHitsPerPlane10();
    Bool_t passesNumHitsPerPlaneCut=!this->CutOnNumHitsPerPlane();

    Bool_t passesAllCuts=passesPidCut &&
      passesEventLengthCut &&
      passesFiducialVolumeCut &&
      passesTrackQualityCut &&
      passesScint_TofDiffCut &&
      passesPSMuonsCut &&
      passesNumHitsPerPlane10Cut &&
      passesNumHitsPerPlaneCut;
    
    //other cuts (not used in final analysis)
    Bool_t passesOverlapCut=!this->CutOnOverlap();


    //pid cut
    hKovADC1->Fill(fKovADC1);
    hKovADC2->Fill(fKovADC2);
    hKovADC3->Fill(fKovADC3);
    hTofDiff->Fill(fTofTDC2-fTofTDC0); 

    //event length cut
    hEventLength->Fill(eventLength);

    //fiducial volume cut
    hStripsFromCentrePeCut->Fill(stripsFromCentrePeCut);

    //track quality cut
    hFirstPlane->Fill(fFirstPlane);

    //timing cut     
    MAXMSG("CDAnalysis",Msg::kDebug,500)
      <<"vTimes1 size="<<vTimes1.size()
      <<", vTimes2 size="<<vTimes2.size()<<endl;
    Float_t lowTimeDiff1=500;
    Float_t upTimeDiff1=-500;
    Float_t lowTimeDiff2=500;
    Float_t upTimeDiff2=-500;
    Float_t lowTime=2e9;
    Float_t upTime=0;
    for (vector<Float_t>::iterator tIt=vTimes1.begin();
         tIt!=vTimes1.end();++tIt){
      Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
      if (timeDiff>-2000 && timeDiff<2000){
        if ((*tIt)*1e9<lowTime) lowTime=(*tIt)*1e9;
        if ((*tIt)*1e9>upTime) upTime=(*tIt)*1e9;
        if (timeDiff>upTimeDiff1) upTimeDiff1=timeDiff;
        if (timeDiff<lowTimeDiff1) lowTimeDiff1=timeDiff;
        hTofScintDiff1->Fill(timeDiff);
        hTofScintDiff->Fill(timeDiff);
      }
      MAXMSG("CDAnalysis",Msg::kDebug,5000)
        <<"timeDiff="<<timeDiff
        <<", tofT="<<fTofADCTimeStamp1
        <<", scintT="<<(*tIt)<<endl;
    }
    for (vector<Float_t>::iterator tIt=vTimes2.begin();
         tIt!=vTimes2.end();++tIt){
      Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
      if (timeDiff>-2000 && timeDiff<2000){
        if ((*tIt)*1e9<lowTime) lowTime=(*tIt)*1e9;
        if ((*tIt)*1e9>upTime) upTime=(*tIt)*1e9;
        if (timeDiff>upTimeDiff2) upTimeDiff2=timeDiff;
        if (timeDiff<lowTimeDiff2) lowTimeDiff2=timeDiff;
        hTofScintDiff2->Fill(timeDiff);
        hTofScintDiff->Fill(timeDiff);
      }
    }
    hTofScintDiffLow1->Fill(lowTimeDiff1);
    hTofScintDiffUp1->Fill(upTimeDiff1);
    hTofScintDiffLow2->Fill(lowTimeDiff2);
    hTofScintDiffUp2->Fill(upTimeDiff2);

    //ps muon cut
    hAvStrip->Fill(fAvStrip);

    //hits per plane cut 10
    hHitsPerPlPeCut10->Fill(numHitsPerPlanePeCut10);

    //hits per plane cut
    hHitsPerPl->Fill(numHitsPerPlane);


    //fill other histos
    hNumHits->Fill(numHits);
    hOLChi2->Fill(fOLChi2);
    hNumPlanes->Fill(numPlanesHit);

    Float_t meu=-1;
    Float_t meuO1=-1;
    Float_t meuO2=-1;
    Float_t meuE1=-1;
    Float_t meuE2=-1;

    //make copies before doing nasty hack
    map<Int_t,Float_t> planeSigCorTOrig=planeSigCorT;
    map<Int_t,Float_t> planeSigCorOrig=planeSigCor;
    map<Int_t,Float_t> planeSigCorO1TOrig=planeSigCorO1T;
    map<Int_t,Float_t> planeSigCorO2TOrig=planeSigCorO2T;
    map<Int_t,Float_t> planeSigCorE1TOrig=planeSigCorE1T;
    map<Int_t,Float_t> planeSigCorE2TOrig=planeSigCorE2T;

    if (true && fSimFlag==SimFlag::kData){
      //do nasty hack for plane 35 - very nasty!!!!
      planeSigCor[35]=planeSigCor[33];
      planeSigCorT[35]=planeSigCorT[33];
      planeSigCorO1T[35]=planeSigCorO1T[33];
      planeSigCorO2T[35]=planeSigCorO2T[33];
      planeSigCorE1T[35]=planeSigCorE1T[33];
      planeSigCorE2T[35]=planeSigCorE2T[33];    
    }

    //section for 14_16 window
    //make cut on everything BUT event length
    if (false) {
      //do nothing
    }
    else {
      Float_t localSum14_16=0;
      Float_t localSum14_16Counter=0;

      Float_t localSum14_16O1=0;
      Float_t localSum14_16O2=0;
      Float_t localSum14_16E1=0;
      Float_t localSum14_16E2=0;
      Int_t planesFromEnd=16;
      Int_t windowStart=eventLength-planesFromEnd;
      Int_t windowSize=14;

      Float_t localSum14_16NoTrkCut=0;
      Float_t localSum14_16NoTrkCutCounter=0;
      Int_t windowStartNoTrkCut=static_cast<Int_t>(numPlanesHit)-
        planesFromEnd;

      //make temp maps to avoid zeros problem
      map<Int_t,Float_t> tempMap=planeSigCorT;
      map<Int_t,Float_t> tempMapO1=planeSigCorO1T;
      map<Int_t,Float_t> tempMapO2=planeSigCorO2T;
      map<Int_t,Float_t> tempMapE1=planeSigCorE1T;
      map<Int_t,Float_t> tempMapE2=planeSigCorE2T;
      map<Int_t,Int_t> tempNumPlanesHitPeCut=fNumPlanesHitPeCut;

      Int_t hitsInWin=0;

      //loop through the hits in the window
      for (Int_t i=0;i<windowSize;i++){
        Int_t plane=windowStart-i;
        Int_t planeNoTrkCut=windowStartNoTrkCut-i;

        //calculate the best window value
        //if fLP=48 then the first plane included is 30
        //this is actually the 19th from the end of the track
        localSum14_16+=tempMap[plane];//total including xtalk
        localSum14_16Counter++;

        //now do odd and even
        if (plane%2==1){
          localSum14_16O1+=tempMapO1[plane];//total including xtalk
          localSum14_16O2+=tempMapO2[plane];//total including xtalk
        }
        if (plane%2==0){
          localSum14_16E1+=tempMapE1[plane];//total including xtalk
          localSum14_16E2+=tempMapE2[plane];//total including xtalk
        }

        //sum the number of hits in the window
        hitsInWin+=tempNumPlanesHitPeCut[plane];

        //calc no trk cut meu
        localSum14_16NoTrkCut+=tempMap[planeNoTrkCut];
        localSum14_16NoTrkCutCounter++;
      }

      //set meu
      meu=localSum14_16/windowSize;
      meuO1=localSum14_16O1/(windowSize*0.5);
      meuO2=localSum14_16O2/(windowSize*0.5);
      meuE1=localSum14_16E1/(windowSize*0.5);
      meuE2=localSum14_16E2/(windowSize*0.5);

      //calc the number of hits in the window
      Float_t hitsPerPlInWin=1.*hitsInWin/windowSize;

      //fill the histo when no trk requirement is made
      if (passesPidCut && 
          passesOverlapCut && 
          !this->CutOnNumPlanesHit(static_cast<Int_t>(numPlanesHit))){
        //passesPSMuonsCut){//don't want this - needs track
        Float_t meuNoTrkCut=localSum14_16NoTrkCut/windowSize;
        h14_16NoTrkCut->Fill(meuNoTrkCut);
      }

      //now cut on the track quality and fill histos
      Int_t localMinEventLength=14+16+1;//+1 'cause don't want pl. zero
      Int_t localMaxEvLen=59;
      if (eventLength>localMinEventLength && 
          eventLength<localMaxEvLen &&
          passesPidCut && 
          passesFiducialVolumeCut && 
          passesTrackQualityCut &&
          passesScint_TofDiffCut &&
          passesPSMuonsCut && 
          passesNumHitsPerPlane10Cut && 
          passesNumHitsPerPlaneCut){
        
        //make individual stripend plots
        //make sure to perform the LAST cut too!
        if (passesEventLengthCut){
          h14_16O1->Fill(meuO1);
          h14_16O2->Fill(meuO2);
          h14_16E1->Fill(meuE1);
          h14_16E2->Fill(meuE2);
          
          //fill the histo for trk in both views requirement
          if (fResultEven>0 && fResultOdd>0){
            h14_16TrkUV->Fill(meu);
          }
          
          hHitsPerPlInWin->Fill(hitsPerPlInWin);
        }
        
        //make plot to look at how MEU varies with ev len cut
        //do the lower cut plots
        for (Int_t lowerPlCut=59;lowerPlCut>localMinEventLength;
             lowerPlCut--){
          if (localSum14_16Counter!=0 && eventLength>=lowerPlCut){
            MAXMSG("CDAnalysis",Msg::kVerbose,300)
              <<"Filling prof: lowerPlCut="<<lowerPlCut
              <<", 14_16="<<localSum14_16/windowSize<<endl;
            pMeuVsLowEvLenCutN_1->Fill(lowerPlCut,meu);
            pMeuVsLowEvLenCutNormN_1->Fill(lowerPlCut,meu);
            
            //make N-1 cut
            Int_t minPlane=0;
            Int_t maxPlane=59;
            this->GetEvLenMinMax(minPlane,maxPlane);
            if (eventLength<=maxPlane){//apply hard cut of maxPlane
              pMeuVsLowEvLenCutN->Fill(lowerPlCut,meu);
              pMeuVsLowEvLenCutNormN->Fill(lowerPlCut,meu);
            }
          }
        }
        //now do the upper cut plots
        for (Int_t upperPlCut=31;upperPlCut<=59;upperPlCut++){
          if (localSum14_16Counter!=0 && eventLength<=upperPlCut && 
              eventLength>31){
            MAXMSG("CDAnalysis",Msg::kVerbose,300)
              <<"Filling prof: upperPlCut="<<upperPlCut
              <<", 14_16="<<meu<<endl;
            pMeuVsUpEvLenCutN_1->Fill(upperPlCut,meu);
            pMeuVsUpEvLenCutNormN_1->Fill(upperPlCut,meu);
            
            //make N-1 cut
            Int_t minPlane=0;
            Int_t maxPlane=59;
            this->GetEvLenMinMax(minPlane,maxPlane);
            if (eventLength>minPlane){
              pMeuVsUpEvLenCutN->Fill(upperPlCut,meu);
              pMeuVsUpEvLenCutNormN->Fill(upperPlCut,meu);
            }
          }
        }
      }
    }

    Float_t meuPLCorrected=-999;
    Float_t meuTruePLCorrected=-999;
    Float_t GeVPerMeu=-999;
   
    if (fResultEven==1 && fResultOdd==1){
      //this->CalcXYZ();
      map<Int_t,TVector3> mPlPos;
      map<Int_t,Float_t> mPLCor;
      //first calc all the xyz positions
      if (this->CalcXYZ(mPlPos)){
        //second calculate the PL corrections
        if (this->CalcPLCor(mPlPos,mPLCor)){
          meuPLCorrected=this->CalcMeuPLCorrected(planeSigCorT,mPLCor,
                                                  event,&GeVPerMeu);
          if (passesAllCuts) {
            this->FillEnVsDist(planeSigCorT,mPLCor,event);
            MAXMSG("CDAnalysis",Msg::kInfo,100)
              <<"Found GeVPerMeu="<<GeVPerMeu<<endl;
            hGeVPerMeu->Fill(GeVPerMeu);
          }
        }
      }

      //now try truth info
      map<Int_t,Float_t> mTruePLCor;
      Float_t trueGeVPerMeu=-999;
      this->TruePLCor(mTruePLCor,event);
      meuTruePLCorrected=this->CalcMeuPLCorrected(planeSigCorT,
                                                  mTruePLCor,
                                                  event,&trueGeVPerMeu);
      
      MAXMSG("CDAnalysis",Msg::kInfo,100)
        <<endl<<"meu="<<meu<<", meuPLCorrected="<<meuPLCorrected
        <<", meuTruePLCorrected="<<meuTruePLCorrected
        <<endl<<endl;
    }
   
    if (passesPidCut){
      //fill the number of planes hit histo
      hNumPlanesMuPi->Fill(numPlanesHit);//all events passing pid
    }
    
    //all but num hits per plane
    if (passesPidCut && 
        passesEventLengthCut && 
        passesFiducialVolumeCut && 
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesPSMuonsCut){
      pSigCorVsOLChi2->Fill(fOLChi2,meu);

      //fill number of hits per plane histos
      hNumHitsN_1->Fill(numHits);
      hHitsPerPlPeCutN_1->Fill(numHitsPerPlanePeCut);

      //now look at effect of hits per plane cut
      for (Float_t hpp=0;hpp<12;hpp+=0.1){
        if (hpp>numHitsPerPlane) pMeuVsHit_PlCut->Fill(hpp,meu);
        if (hpp>numHitsPerPlanePeCut10) pMeuVsHit_PlCut10->
                                          Fill(hpp,meu);
      }

      //fill the meu histo just for OL failures
      if (this->CutOnOverlap()){
        h14_16OL->Fill(meu);
      }
    }

    //all but track quality and ps muon cut
    if (passesPidCut && 
        passesEventLengthCut && 
        passesFiducialVolumeCut && 
        passesTrackQualityCut && 
        passesScint_TofDiffCut){
      if (fAvStrip<9|| fAvStrip>13){
        Double_t time=-1;
        if (vTimes1.size()) time=vTimes1[0];
        MAXMSG("CDAnalysis",Msg::kDebug,100)
          <<"ps muon: event="<<event
          <<", fAvStrip="<<fAvStrip<<", fStCount="<<fStCount
          <<", Time="<<time<<", sec="<<fSec<<endl;
      }
      Bool_t printPSMuons12=false;
      if (printPSMuons12){
        if (fAvStrip1<9|| fAvStrip1>13){
          Double_t time=-1;
          if (vTimes1.size()) time=vTimes1[0];
          MAXMSG("CDAnalysis",Msg::kDebug,100)
            <<"** ps muon end=1: event="<<event
            <<", fAvStrip1="<<fAvStrip1<<", fStCount="<<fStCount1
            <<", Time="<<time<<", sec="<<fSec<<endl;
        }
        if (fAvStrip2<9|| fAvStrip2>13){
          Double_t time=-1;
          if (vTimes1.size()) time=vTimes1[0];
          MAXMSG("CDAnalysis",Msg::kDebug,100)
            <<"** ps muon end=2: event="<<event
            <<", fAvStrip1="<<fAvStrip2<<", fStCount="<<fStCount2
            <<", Time="<<time<<", sec="<<fSec<<endl;
        }
      }

      //look at OL
      if (passesNumHitsPerPlane10Cut && passesNumHitsPerPlaneCut && 
          passesPSMuonsCut) {
        //make cut on overlap

        MAXMSG("CDAnalysis",Msg::kDebug,100)
          <<"strip<="<<upTrkStripPeCut<<", strip>="<<lowTrkStripPeCut
          <<", lowFromCent="<<lowStripsFromCentrePeCut
          <<", upFromCent="<<upStripsFromCentrePeCut
          <<", stFromCent="<<stripsFromCentrePeCut<<endl;
        
        hStripsFromCentre->Fill(stripsFromCentre);

        for (Int_t s=0;s<=12;s++){
          if (s>stripsFromCentre){
            pMeuVsStripCut->Fill(s,meu);
          }
          if (s<stripsFromCentre){
            pMeuVsStripCutPeCut->Fill(s,meu);
          }
        }
      }
    }
    
    //count the number of events passing the pid
    if (passesPidCut){
      passPidCounter++;
    }

    //get meu number with various combinations of cuts
    //all with pid
    if (passesPidCut && 
        passesEventLengthCut) hMeuOnlyPID_EventLengthCut->Fill(meu);
    if (passesPidCut &&
        passesEventLengthCut && 
        passesFiducialVolumeCut &&
        passesPSMuonsCut) hMeuOnlyPID_EL_FidCut->Fill(meu);
    if (passesPidCut &&
        passesEventLengthCut && 
        passesScint_TofDiffCut) hMeuOnlyPID_EL_TimeCut->Fill(meu);
    if (passesPidCut &&
        passesEventLengthCut && 
        passesFiducialVolumeCut &&
        passesPSMuonsCut &&//considered a fid vol cut
        passesScint_TofDiffCut) hMeuOnlyPID_EL_Fid_TimeCut->Fill(meu);
    if (passesPidCut &&
        passesEventLengthCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut) hMeuOnlyPID_EL_HppCut->Fill(meu);
    //all without pid
    if (passesEventLengthCut) hMeuOnlyEventLengthCut->Fill(meu);
    if (passesEventLengthCut && 
        passesFiducialVolumeCut &&
        passesPSMuonsCut) hMeuOnlyEL_FidCut->Fill(meu);
    if (passesEventLengthCut && 
        passesScint_TofDiffCut) hMeuOnlyEL_TimeCut->Fill(meu);
    if (passesEventLengthCut && 
        passesFiducialVolumeCut &&
        passesPSMuonsCut &&//considered a fid vol cut
        passesScint_TofDiffCut) hMeuOnlyEL_Fid_TimeCut->Fill(meu);
    if (passesEventLengthCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut) hMeuOnlyEL_HppCut->Fill(meu);


    //fill the N_1 histos for pid
    if (passesEventLengthCut && 
        passesFiducialVolumeCut && 
        passesTrackQualityCut && 
        passesScint_TofDiffCut && 
        passesPSMuonsCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){
      hOLChi2N_1->Fill(fOLChi2);
      hKovADC1N_1->Fill(fKovADC1);
      hKovADC2N_1->Fill(fKovADC2);
      hKovADC3N_1->Fill(fKovADC3);
      hTofDiffN_1->Fill(fTofTDC2-fTofTDC0); 
      hMeuNoPidCut->Fill(meu);
    }

    //fill the N_1 histos for event length cut
    if (passesPidCut &&
        passesFiducialVolumeCut && 
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesPSMuonsCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){
      hNumPlanesN_1->Fill(numPlanesHit);//unofficial cut
      hEventLengthN_1->Fill(eventLength);
      hMeuNoEventLengthCut->Fill(meu);
    }

    //fill the N_1 histos for fiducial volume cut
    if (passesPidCut &&
        passesEventLengthCut &&
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesPSMuonsCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){
      hStripsFromCentrePeCutN_1->Fill(stripsFromCentrePeCut);
      hMeuNoFidVolCut->Fill(meu);
      if (!passesFiducialVolumeCut) eventsTxtFileFidVol<<event<<endl;
    }

    //fill the N_1 histos for track quality cut
    if (passesPidCut &&
        passesEventLengthCut &&
        passesFiducialVolumeCut && 
        passesScint_TofDiffCut &&
        //passesPSMuonsCut && //equivalent to finding a track!
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){
      hFirstPlaneN_1->Fill(fFirstPlane);
      hMeuNoTrackQualityCut->Fill(meu);
    }

    //fill the N_1 histos for timing
    if (passesPidCut &&
        passesEventLengthCut && 
        passesFiducialVolumeCut && 
        passesTrackQualityCut && 
        passesPSMuonsCut && 
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){

      for (vector<Float_t>::iterator tIt=vTimes1.begin();
           tIt!=vTimes1.end();++tIt){     
        Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
        if (timeDiff>-2000 && timeDiff<2000){
          hTofScintDiff1N_1->Fill(timeDiff);
          hTofScintDiffN_1->Fill(timeDiff);
        }
      }
      for (vector<Float_t>::iterator tIt=vTimes2.begin();
           tIt!=vTimes2.end();++tIt){
        Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
        if (timeDiff>-2000 && timeDiff<2000){
          hTofScintDiff2N_1->Fill(timeDiff);
          hTofScintDiffN_1->Fill(timeDiff);
        }
      }
      hTofScintDiffLow1N_1->Fill(lowTimeDiff1);
      hTofScintDiffUp1N_1->Fill(upTimeDiff1);
      hTofScintDiffLow2N_1->Fill(lowTimeDiff2);
      hTofScintDiffUp2N_1->Fill(upTimeDiff2);
      
      //now look at effect of time cut
      for (Int_t t=-500;t<500;t+=20){
        
        if (t<fLowScint_Tof) pMeuVsLowTimeCutN_1->Fill(t,meu);
        if (t>fUpScint_Tof) pMeuVsUpTimeCutN_1->Fill(t,meu);
        
        Float_t lowTimeCut=-1e9;
        Float_t upTimeCut=1e9;
        this->GetLowUpTimeCuts(lowTimeCut,upTimeCut);
        
        //fill the N cuts histos
        if (fLowScint_Tof>lowTimeCut && fUpScint_Tof<upTimeCut){//NF
          //if (lowTimeDiff>-175 && upTimeDiff<135){//FF
          if (t<fLowScint_Tof) pMeuVsLowTimeCutN->Fill(t,meu);
          if (t>fUpScint_Tof) pMeuVsUpTimeCutN->Fill(t,meu);
        }
      }
    }

    //fill the N_1 histos for PS muon cut
    if (passesPidCut &&
        passesEventLengthCut &&
        passesFiducialVolumeCut && 
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesNumHitsPerPlane10Cut &&
        passesNumHitsPerPlaneCut){
      hAvStripN_1->Fill(fAvStrip);
      if (!passesPSMuonsCut) eventsTxtFilePSMu<<event<<endl;
      hMeuNoPSMuCut->Fill(meu);
    }

    //fill the N_1 histos for hits per plane cut 10
    if (passesPidCut &&
        passesEventLengthCut &&
        passesFiducialVolumeCut && 
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesPSMuonsCut &&
        passesNumHitsPerPlaneCut){
      hHitsPerPlPeCut10N_1->Fill(numHitsPerPlanePeCut10);
      hMeuNoHitsPerPlane10Cut->Fill(meu);
      if (!passesNumHitsPerPlane10Cut) eventsTxtFileHpp10<<event<<endl;
    }

    //fill the N_1 histos for hits per plane cut
    if (passesPidCut &&
        passesEventLengthCut &&
        passesFiducialVolumeCut && 
        passesTrackQualityCut &&
        passesScint_TofDiffCut &&
        passesPSMuonsCut &&
        passesNumHitsPerPlane10Cut){
      hHitsPerPlN_1->Fill(numHitsPerPlane);
      hMeuNoHitsPerPlaneCut->Fill(meu);
      if (!passesNumHitsPerPlaneCut) eventsTxtFileHpp<<event<<endl;
    }
    

    //::Stopping cuts
    //cut on the pid (this is not always done above)
    if (!passesPidCut) continue;
    //make event length cuts
    if (!passesEventLengthCut) continue;
    //cut on fid
    if (!passesFiducialVolumeCut) continue;
    //make track quality cuts
    if (!passesTrackQualityCut) continue;
    //cut on the time difference between scint hits and tof hit
    if (!passesScint_TofDiffCut) continue;
    //cut out ps muons
    if (!passesPSMuonsCut) continue;
    //cut on the number of hits per plane 10
    if (!passesNumHitsPerPlane10Cut) continue;
    //cut on the number of hits per plane
    if (!passesNumHitsPerPlaneCut) continue;

    //count total events passing cuts
    NCutsCounter++;
    //write event to txt file
    eventsTxtFile<<event<<endl;


    //pid cut N
    hKovADC1N->Fill(fKovADC1);
    hKovADC2N->Fill(fKovADC2);
    hKovADC3N->Fill(fKovADC3);
    hTofDiffN->Fill(fTofTDC2-fTofTDC0);

    //event length cut N
    hEventLengthN->Fill(eventLength);

    //fiducial volume cut N
    hStripsFromCentrePeCutN->Fill(stripsFromCentrePeCut);

    //track quality cut N
    hFirstPlaneN->Fill(fFirstPlane);

    //timing cut N
    hTofScintDiffLow1N->Fill(lowTimeDiff1);
    hTofScintDiffUp1N->Fill(upTimeDiff1);
    hTofScintDiffLow2N->Fill(lowTimeDiff2);
    hTofScintDiffUp2N->Fill(upTimeDiff2);
    for (vector<Float_t>::iterator tIt=vTimes1.begin();
         tIt!=vTimes1.end();++tIt){
      Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
      if (timeDiff>-2000 && timeDiff<2000){
        hTofScintDiff1N->Fill(timeDiff);
        hTofScintDiffN->Fill(timeDiff);
      }
    }
    for (vector<Float_t>::iterator tIt=vTimes2.begin();
         tIt!=vTimes2.end();++tIt){
      Float_t timeDiff=((*tIt)*1e9)-(fTofADCTimeStamp1*25./16);
      if (timeDiff>-2000 && timeDiff<2000){
        hTofScintDiff2N->Fill(timeDiff);
        hTofScintDiffN->Fill(timeDiff);
      }
    }

    //ps muon cut N
    hAvStripN->Fill(fAvStrip);
    
    //hits per plane 10 cut N
    hHitsPerPlPeCut10N->Fill(numHitsPerPlanePeCut10);

    //hits per plane cut N
    hHitsPerPlN->Fill(numHitsPerPlane);


    //calc average temperature, using weighted mean
    static Int_t avTempCounter=0;
    avTempCounter++;
    
    //get a calibrator
    Calibrator& cal=Calibrator::Instance();
    //VldTimeStamp (const time_t &t, const Int_t nsec)
    VldTimeStamp vldts(fSec,0);
    VldContext vc(Detector::kCalDet,fSimFlag,vldts);
    cal.ReInitialise(vc);
    fTemperature=cal.GetTemperature();

    fAvTemperature=fTemperature*(1./avTempCounter)+
      fAvTemperature*((avTempCounter-1.)/avTempCounter);
    MAXMSG("CDAnalysis",Msg::kInfo,10)
      <<"fTemperature="<<fTemperature
      <<", fAvTemperature="<<fAvTemperature
      <<", avTempCounter="<<avTempCounter<<endl;

    //see if any events would have been cut out
    if (this->CutOnOverlap()) {
      eventsTxtFileOL<<event<<endl;
    }
    else hOLChi2N->Fill(fOLChi2);

    if (fResultEven==1 && fResultOdd==1){
      if (meu<=0 || meuPLCorrected<=0){
        cout<<"Ahhhhhh MEU less than zero"<<endl;
      }
      else{
        hMeu->Fill(meu);
        hMeuPLCor->Fill(meuPLCorrected);
        hMeuTruePLCor->Fill(meuTruePLCorrected);
      }
    }
    else{
      MAXMSG("CDAnalysis",Msg::kDebug,100)
        <<"Track not good in both views"<<endl;
    }
    hNumPlanesN->Fill(numPlanesHit);
    hHitsPerPl25N_1->Fill(numHitsPerPlane25);
    if (numHitsPerPlane25>3) {
      MAXMSG("CDAnalysis",Msg::kDebug,100)
        <<"*******hpp25="<<numHitsPerPlane25
        <<", event="<<event<<", size="<<fNumPlanesHit25.size()
        <<", numh="<<numHits25<<", size2="<<numPlanesHit25<<endl;
      eventsTxtFileStrips25<<event<<endl;
    }

    Float_t highEn=-1;
    Float_t lowEn=-1;
    this->TrueHighLowEn(highEn,lowEn);
    hHighEn->Fill(highEn);
    hLowEn->Fill(lowEn);
    MAXMSG("CDAnalysis",Msg::kInfo,100)
      <<"HighEn="<<highEn<<", lowEn="<<lowEn<<endl;

    //look at straightness of tracky events
    Double_t radiusCut=0.2;
    Bool_t straightTrk=StraightTrack_Radius(radiusCut);
    if (straightTrk) straightTrackCounter++;
    map<Float_t,Bool_t> mStraightTrk;
    for (Float_t r=0.05;r<0.51;r+=0.05){
      mStraightTrk[r]=StraightTrack_Radius(r);
    }

    //section for response
    const Int_t os=eventLength;

    //must fill the profs before looping over the maps because
    //zeros will get added to the maps at the window stage!
    //use "Orig" maps - made before doing nasty hack!
    //fill profs for all stripends
    this->FillProfHisto(pSigCorVsPlane,num,planeSigCorOrig);
    this->FillProfHisto(pSigCorVsPlaneX,numX,planeSigCorX);
    this->FillProfHisto(pSigCorVsPlaneT,numT,planeSigCorTOrig);
    //offset
    this->FillProfHisto(pSigCorVsOsPlane,numOs,planeSigCorOrig,os);
    this->FillProfHisto(pSigCorVsOsPlaneX,numOsX,planeSigCorX,os);
    this->FillProfHisto(pSigCorVsOsPlaneT,numOsT,planeSigCorTOrig,os);

    //fill non-offset profs for individual stripends
    this->FillProfHisto(pSigCorVsPlaneO1,numO1,planeSigCorO1);
    this->FillProfHisto(pSigCorVsPlaneO1X,numO1X,planeSigCorO1X);
    this->FillProfHisto(pSigCorVsPlaneO1T,numO1T,planeSigCorO1TOrig);
    this->FillProfHisto(pSigCorVsPlaneO2,numO2,planeSigCorO2);
    this->FillProfHisto(pSigCorVsPlaneO2X,numO2X,planeSigCorO2X);
    this->FillProfHisto(pSigCorVsPlaneO2T,numO2T,planeSigCorO2TOrig);
    this->FillProfHisto(pSigCorVsPlaneE1,numE1,planeSigCorE1);
    this->FillProfHisto(pSigCorVsPlaneE1X,numE1X,planeSigCorE1X);
    this->FillProfHisto(pSigCorVsPlaneE1T,numE1T,planeSigCorE1TOrig);
    this->FillProfHisto(pSigCorVsPlaneE2,numE2,planeSigCorE2);
    this->FillProfHisto(pSigCorVsPlaneE2X,numE2X,planeSigCorE2X);
    this->FillProfHisto(pSigCorVsPlaneE2T,numE2T,planeSigCorE2TOrig);

    //fill offset profs for individual stripends
    this->FillProfHisto(pSigCorVsOsPlaneO1,numOsO1,planeSigCorO1,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1X,numOsO1X,planeSigCorO1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO1T,numOsO1T,planeSigCorO1TOrig,
                        os);
    this->FillProfHisto(pSigCorVsOsPlaneO2,numOsO2,planeSigCorO2,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2X,numOsO2X,planeSigCorO2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneO2T,numOsO2T,planeSigCorO2TOrig,
                        os);
    this->FillProfHisto(pSigCorVsOsPlaneE1,numOsE1,planeSigCorE1,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1X,numOsE1X,planeSigCorE1X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE1T,numOsE1T,planeSigCorE1TOrig,
                        os);
    this->FillProfHisto(pSigCorVsOsPlaneE2,numOsE2,planeSigCorE2,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2X,numOsE2X,planeSigCorE2X,os);
    this->FillProfHisto(pSigCorVsOsPlaneE2T,numOsE2T,planeSigCorE2TOrig,
                        os);

    //section for total event sigcor and mips
    Float_t localSumSigCorTotal=0;
    Float_t localSumSigCorTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeSigCorT.begin();
         sig!=planeSigCorT.end();++sig){
      localSumSigCorTotal+=sig->second;
      localSumSigCorTotalCounter++;
      
      //fill histos of all hits. Added June/2007
      Int_t pl=sig->first;
      if (pl<60) sigCorNoPLCorHistos[pl]->Fill(sig->second);
      else cout<<"Ahhhh, plane>=60!!!!!"<<endl;
    }

    //add total of this event to the sum of all events 
    if (localSumSigCorTotalCounter!=0){
      sumSigCorTotal+=localSumSigCorTotal;
      sumSigCorTotalCounter++;
    }

    Float_t localSumMipTotal=0;
    Float_t localSumMipTotalCounter=0;
    for (map<Int_t,Float_t>::iterator sig=planeMipT.begin();
         sig!=planeMipT.end();++sig){
      localSumMipTotal+=sig->second;
      localSumMipTotalCounter++;
    }

    //add total of this event to the sum of all events 
    if (localSumMipTotalCounter!=0){
      sumMipTotal+=localSumMipTotal;
      sumMipTotalCounter++;
    }

    //work out event length
    Int_t lastPlNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();
    hEvLenFe->Fill(lastPlNoXTalk);
    pSigCorVsRange->Fill(lastPlNoXTalk,localSumSigCorTotal);

    //section for sliding window
    //Int_t minEventLength=30;

    //initialise the profile histos
    static Bool_t firstTime=true;
    if (firstTime){
      for (Int_t p=18;p>1;p--){
        vWindowSize.push_back(p);
        bigAv.push_back(0);
        bigAvCounter.push_back(0);
      }

      for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
           windowSize!=vWindowSize.end();++windowSize){
        
        string sName=Form("%d",*windowSize);
        pSigCorVsDist.push_back
          (new TProfile(("pSigCorVsDist"+sName).c_str(),
                        ("pSigCorVsDist"+sName).c_str(),100,-2,40));
        pSigCorVsDistN.push_back
          (new TProfile(("pSigCorVsDistN"+sName).c_str(),
                        ("pSigCorVsDistN"+sName).c_str(),100,-2,40));
      }
    }
    firstTime=false;

    vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
    vector<TProfile*>::iterator profN=pSigCorVsDistN.begin();
    vector<Float_t>::iterator av=bigAv.begin();
    vector<Int_t>::iterator count=bigAvCounter.begin();
    Float_t localSum15_18=0;
    Float_t localSum15_18Counter=0;
    Float_t localSum15_18Mip=0;
    Float_t localSum15_18MipCounter=0;

    Float_t localSum10_16=0;
    Float_t localSum10_16Counter=0;
    Float_t localSum10_10=0;
    Float_t localSum10_10Counter=0;
    Float_t localSum14_16=0;
    Float_t localSum14_16Counter=0;
    Float_t localSum14_10=0;
    Float_t localSum14_10Counter=0;
    Float_t localSum18_16=0;
    Float_t localSum18_16Counter=0;
    Float_t localSum18_10=0;
    Float_t localSum18_10Counter=0;

    Float_t localSum14_16NoXTalk=0;
    Float_t localSum14_16NoXTalkCounter=0;

    //loop over the different window sizes
    for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
         windowSize!=vWindowSize.end();++windowSize){
      
      //slide the window along from the end to 40-windowSize
      //for (Int_t p=0;p<minEventLength-*windowSize;p++){
      for (Int_t p=0;p<60;p++){
        Int_t windowStart=eventLength-p;
        Int_t windowStartNoXTalk=lastPlNoXTalk-p;

        //don't do unphysical windows
        if (windowStart-(*windowSize)<0) continue;

        MAXMSG("CDAnalysis",Msg::kDebug,500)
          <<"Window size="<<*windowSize<<", window start="<<windowStart
          <<", eventLength-18="<<eventLength-18<<endl;
 
        //loop through the hits in the window
        for (Int_t i=0;i<*windowSize;i++){
          Int_t plane=windowStart-i;
          Int_t planeNoXTalk=windowStartNoXTalk-i;
          
          //sum up energy based on track length with no xtalk
          if (*windowSize==14 && windowStartNoXTalk==lastPlNoXTalk-16){
            localSum14_16NoXTalk+=planeSigCorT[planeNoXTalk];
            localSum14_16NoXTalkCounter++;
            MAXMSG("CDAnalysis",Msg::kDebug,500)
              <<"Win size="<<*windowSize
              <<", win start="<<windowStart
              <<" (NoXTalk="<<windowStartNoXTalk<<")"
              <<", pl="<<plane
              <<", plNoXTalk="<<planeNoXTalk
              <<", sc="<<planeSigCorT[plane]
              <<", scNXT="<<planeSigCorT[planeNoXTalk]
              <<endl;
          }

          //calculate the best window value
          //if fLP=48 then the first plane included is 30
          //this is actually the 19th from the end of the track
          if (*windowSize==15 && windowStart==eventLength-18){
            localSum15_18+=planeSigCorT[plane];//total including xtalk
            localSum15_18Counter++;
            localSum15_18Mip+=planeMipT[plane];//total including xtalk
            localSum15_18MipCounter++;
          }

          if (*windowSize==10 && windowStart==eventLength-16){
            localSum10_16+=planeSigCorT[plane];//total including xtalk
            localSum10_16Counter++;
          }
          if (*windowSize==10 && windowStart==eventLength-10){
            localSum10_10+=planeSigCorT[plane];//total including xtalk
            localSum10_10Counter++;
          }
          if (*windowSize==14 && windowStart==eventLength-16){
            Double_t localSigCorT=planeSigCorT[plane];
            localSum14_16+=localSigCorT;
            localSum14_16Counter++;
            meuHistos[plane]->Fill(localSigCorT);

            //fill strip vs plane maps (per strip, not stripend)
            map<Int_t,Float_t>::iterator sc=(stplSigCor[plane]).begin();
            for (map<Int_t,Float_t>::iterator i=
                   (stplNum[plane]).begin();
                 i!=(stplNum[plane]).end();++i){
              Int_t strip=i->first;
              Float_t num=i->second;
              Float_t sigCor=sc->second;
              MAXMSG("CDAnalysis",Msg::kDebug,500)
                <<"st="<<i->first<<", num="<<i->second<<endl
                <<"st="<<sc->first<<", sc="<<sc->second<<endl;
              pStVsPlWin->Fill(plane,strip,sigCor);
              hStVsPlNum->Fill(plane,strip,num);

              //iterate to the next
              ++sc;
            }
          }
          if (*windowSize==14 && windowStart==eventLength-10){
            localSum14_10+=planeSigCorT[plane];//total including xtalk
            localSum14_10Counter++;
          }
          if (*windowSize==18 && windowStart==eventLength-16){
            localSum18_16+=planeSigCorT[plane];//total including xtalk
            localSum18_16Counter++;
          }
          if (*windowSize==18 && windowStart==eventLength-10){
            localSum18_10+=planeSigCorT[plane];//total including xtalk
            localSum18_10Counter++;
          }
          
          (*prof)->Fill(p,planeSigCorT[plane]);
          (*profN)->Fill(p,planeSigCorT[plane]);
          (*av)+=planeSigCorT[plane];
          (*count)++;
        }

      }
      av++;
      count++;
      prof++;
      profN++;
    }

    if (localSum15_18Counter!=0){
      h15_18->Fill(localSum15_18/15);
      sum15_18+=localSum15_18;//add this event's energy on to total
      sum15_18Counter++;
      sum15_18Mip+=localSum15_18Mip;
      sum15_18MipCounter++;
    }

    //fill the no xtalk histo
    if (localSum14_16NoXTalkCounter!=0) {
      h14_16NoXTalk->Fill(localSum14_16NoXTalk/14);
    }

    if (localSum10_16Counter!=0) h10_16->Fill(localSum10_16/10);
    if (localSum10_10Counter!=0) h10_10->Fill(localSum10_10/10);
    if (localSum14_16Counter!=0) {
      h14_16->Fill(localSum14_16/14);
      if (straightTrk) h14_16Straight->Fill(localSum14_16/14);
      //loop and fill prof with different straightnesses
      for (map<Float_t,Bool_t>::iterator sTrk=mStraightTrk.begin();
           sTrk!=mStraightTrk.end();++sTrk){
        if (sTrk->second){
          pMeuVsStraightness->Fill(sTrk->first,localSum14_16/14);
          pMeuVsStraightnessN->Fill(sTrk->first,localSum14_16/14);
        }
        MAXMSG("CDAnalysis",Msg::kVerbose,500)
          <<"r="<<sTrk->first<<", straight="<<sTrk->second<<endl;
      }
    }
    if (localSum14_10Counter!=0) h14_10->Fill(localSum14_10/14);
    if (localSum18_16Counter!=0) h18_16->Fill(localSum18_16/18);
    if (localSum18_10Counter!=0) h18_10->Fill(localSum18_10/18);

    Float_t meu2=localSum14_16/14;
    if (fabs(meu-meu2)/(0.5*(meu+meu2+0.0001))>0.001){
      MAXMSG("CDAnalysis",Msg::kError,2000)
        <<"MEUs differ: meu="<<meu<<", meu2="<<meu2<<endl;
    }

    //section to look at the fraction of meu contributed by each strip
    if (meu>0){
      Int_t minPlane=-1;
      Int_t maxPlane=-1;
      this->GetEvLenMinMax(minPlane,maxPlane);
      MAXMSG("CDAnalysis",Msg::kDebug,20)
        <<"size="<<stplSigCor.size()<<endl;
      //loop over all possible strips and planes in the track window
      for (Int_t p=minPlane-16-14;p<=maxPlane-16;p++){
        //get an iterator to the strips for this plane
        map<Int_t,map<Int_t,Float_t> >::iterator pIt=stplSigCor.find(p);
        for (Int_t s=0;s<24;s++){
          Float_t sigCor=0;

          Int_t winLower=eventLength-16-14;
          Int_t winUpper=eventLength-16;
          MAXMSG("CDAnalysis",Msg::kDebug,2000)
            <<"winLower="<<winLower<<", winUpper="<<winUpper<<endl;
          //only get the sigcor value if it's in the window
          //14 planes, if last==50, then 20<p<=34 = 14 all together
          if (p>winLower && p<=winUpper){
            MAXMSG("CDAnalysis",Msg::kDebug,2000)
              <<"Plane was in window="<<p
              <<", winLower="<<winLower<<", winUpper="<<winUpper<<endl;
            //check if there were hits in pl
            if (pIt!=stplSigCor.end()){
              MAXMSG("CDAnalysis",Msg::kDebug,2000)
                <<"Plane had strips hit="<<p<<endl;
              map<Int_t,Float_t>::iterator sIt=pIt->second.find(s);
              //check if strip has hit
              if (sIt!=pIt->second.end()){
                sigCor=sIt->second;
                MAXMSG("CDAnalysis",Msg::kDebug,2000)
                  <<"Strip was hit, getting sigCor="<<sigCor<<endl;
              }
            }
          }
          Float_t fract=(sigCor/14)/meu;
          MAXMSG("CDAnalysis",Msg::kDebug,2000)
            <<"p="<<p<<", s="<<s<<", sigCor="<<sigCor
            <<", fract="<<fract<<endl;
          pStVsPlWinFract->Fill(p,s,fract);
        }
      }
    }//end of if meu

    //look at OLChi2
    //else cout<<"event="<<event<<endl;
    //make plot of how meu varies with OLChi2
    for (Float_t olc=0;olc<10;olc+=0.05){
      if (olc>fOLChi2){
        MAXMSG("CDAnalysis",Msg::kDebug,2000)
          <<"Filling: olc="<<olc<<", fOLChi2="<<fOLChi2<<endl;
        pSigCorVsOLChi2Sum->Fill(olc,meu);
      }
      else {
        MAXMSG("CDAnalysis",Msg::kDebug,200)
          <<"Not filled: olc="<<olc<<", fOLChi2="<<fOLChi2<<endl;
      }
    }

    if (1.*numPlanesHit/eventLength<0.9){
      MAXMSG("CDAnalysis",Msg::kDebug,100)
        <<"low hit planes="<<1.*numPlanesHit/eventLength
        <<", event="<<event
        <<", TimeDiff=("<<fLowScint_Tof
        <<" -> "<<fUpScint_Tof<<")"<<endl
        <<"       Time=("<<lowTime
        <<" -> "<<upTime<<")"
        <<", sec="<<fSec
        <<endl;
      eventsTxtFileLowPlanesHit<<event<<endl;
    }
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);

  //all stripends
  string sTitle="Energy Deposition (SigCor, all Stripends)";
  string sXTitle="Distance from end of track (planes)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlane,pSigCorVsPlaneX,
                         pSigCorVsPlaneT,num,numX,numT);
  sTitle="Energy Deposition Vs Distance (SigCor, all Stripends)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlane,pSigCorVsOsPlaneX,
                         pSigCorVsOsPlaneT,numOs,numOsX,numOsT,sXTitle);

  //non-offset planes
  sTitle="Energy Deposition (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO1,pSigCorVsPlaneO1X,
                         pSigCorVsPlaneO1T,numO1,numO1X,numO1T);

  sTitle="Energy Deposition (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneO2,pSigCorVsPlaneO2X,
                         pSigCorVsPlaneO2T,numO2,numO2X,numO2T);

  sTitle="Energy Deposition (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE1,pSigCorVsPlaneE1X,
                         pSigCorVsPlaneE1T,numE1,numE1X,numE1T);

  sTitle="Energy Deposition (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsPlaneE2,pSigCorVsPlaneE2X,
                         pSigCorVsPlaneE2T,numE2,numE2X,numE2T);

  //offset planes
  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO1,pSigCorVsOsPlaneO1X,
                         pSigCorVsOsPlaneO1T,numOsO1,numOsO1X,numOsO1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Odd Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneO2,pSigCorVsOsPlaneO2X,
                         pSigCorVsOsPlaneO2T,numOsO2,numOsO2X,numOsO2T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes FD stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE1,pSigCorVsOsPlaneE1X,
                         pSigCorVsOsPlaneE1T,numOsE1,numOsE1X,numOsE1T,
                         sXTitle);

  sTitle="Energy Deposition Vs Distance (SigCor in Even Planes ND stripend)";
  this->DrawResponsePlot(sTitle,pSigCorVsOsPlaneE2,pSigCorVsOsPlaneE2X,
                         pSigCorVsOsPlaneE2T,numOsE2,numOsE2X,numOsE2T,
                         sXTitle);

  //normalise the prof
  for (vector<TProfile*>::iterator profN=pSigCorVsDistN.begin();
       profN!=pSigCorVsDistN.end();++profN){
    static vector<Float_t>::iterator av=bigAv.begin();
    static vector<Int_t>::iterator count=bigAvCounter.begin();
    static vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
    
    //normalise the prof and scale the axes
    MSG("CDAnalysis",Msg::kDebug)
      <<"bigCounter="<<*count<<", bigAv="<<*av<<endl;
    if (*av>0) (*profN)->Scale((*count)/(*av));
    (*profN)->SetMaximum(1.2);
    (*profN)->SetMinimum(0.8);      
    (*profN)->SetTitle("Normalised Av. SigCor in Sliding Window");
    (*profN)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*profN)->GetYaxis()->SetTitle("Normalised Av. SigCor");
    (*profN)->GetXaxis()->CenterTitle();
    (*profN)->GetYaxis()->CenterTitle();
    fS=(*profN)->GetName();
    Int_t pos=fS.find("14");
    //get the gradient for the chosen track-window
    if (pos>=0){
      (*profN)->Fit("pol1","q","",5,14);
      fSigCorVsDistM=(*profN)->GetFunction("pol1")->GetParameter(1);
      MSG("CDAnalysis",Msg::kDebug)<<"m="<<fSigCorVsDistM<<endl;
    }

    //now set the titles for the other one
    (*prof)->SetTitle("Average SigCor in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Average SigCor");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();

    av++;
    count++;
    prof++;
  }

  //normalise the pMeuVsLowEvLenCutNormN
  if (h14_16->GetMean()>0){
    pMeuVsLowEvLenCutNormN->Scale(1./h14_16->GetMean());
    pMeuVsLowEvLenCutNormN_1->Scale(1./h14_16->GetMean());
    pMeuVsUpEvLenCutNormN->Scale(1./h14_16->GetMean());
    pMeuVsUpEvLenCutNormN_1->Scale(1./h14_16->GetMean());
    pMeuVsStraightnessN->Scale(1./h14_16->GetMean());
  }

  Int_t lEvLenCutMin=-1;
  Int_t lEvLenCutMax=-1;
  this->GetEvLenMinMax(lEvLenCutMin,lEvLenCutMax);
  pMeuVsLowEvLenCutNormN->Fit
    ("pol1","q","",lEvLenCutMin,lEvLenCutMin+4);
  //<<"m="<<pMeuVsLowEvLenCutNormN->
  //GetFunction("pol1")->GetParameter(1)<<endl;
  fMeuVsEvLenCutM=pMeuVsLowEvLenCutNormN->
    GetFunction("pol1")->GetParameter(1);

  //create graphs
  TGraphErrors* gMeuVsWin=new TGraphErrors(6);
  TGraphErrors* gMeuVsWinCor=new TGraphErrors(6);
  TGraphErrors* gCorVsWin=new TGraphErrors(6);
  TGraphErrors* gMeuVsWinN=new TGraphErrors(6);
  TGraphErrors* gMeuVsWinCorN=new TGraphErrors(6);
  
  //MC correction factors relative to 14_16 MEU
  Float_t MCCor10_10=1.012;//0.988;
  Float_t MCCor10_16=1.007;//0.993;
  Float_t MCCor14_10=1.010;//0.990;
  Float_t MCCor14_16=1.0;//by definition
  Float_t MCCor18_10=1.007;//0.993;
  Float_t MCCor18_16=0.996;//1.004;
  
  gMeuVsWin->SetPoint(0,1,h10_10->GetMean());
  gMeuVsWin->SetPoint(1,2,h10_16->GetMean());
  gMeuVsWin->SetPoint(2,3,h14_10->GetMean());
  gMeuVsWin->SetPoint(3,4,h14_16->GetMean());
  gMeuVsWin->SetPoint(4,5,h18_10->GetMean());
  gMeuVsWin->SetPoint(5,6,h18_16->GetMean());
  
  gMeuVsWinCor->SetPoint(0,1,h10_10->GetMean()*MCCor10_10);
  gMeuVsWinCor->SetPoint(1,2,h10_16->GetMean()*MCCor10_16);
  gMeuVsWinCor->SetPoint(2,3,h14_10->GetMean()*MCCor14_10);
  gMeuVsWinCor->SetPoint(3,4,h14_16->GetMean()*MCCor14_16);
  gMeuVsWinCor->SetPoint(4,5,h18_10->GetMean()*MCCor18_10);
  gMeuVsWinCor->SetPoint(5,6,h18_16->GetMean()*MCCor18_16);

  vector<TGraph*> v(2);
  v[0]=dynamic_cast<TGraph*>(gMeuVsWin);
  v[1]=dynamic_cast<TGraph*>(gMeuVsWinCor);
  this->TGraphMinMax(v);
  
  gCorVsWin->SetPoint(0,1,1/MCCor10_10);
  gCorVsWin->SetPoint(1,2,1/MCCor10_16);
  gCorVsWin->SetPoint(2,3,1/MCCor14_10);
  gCorVsWin->SetPoint(3,4,1/MCCor14_16);
  gCorVsWin->SetPoint(4,5,1/MCCor18_10);
  gCorVsWin->SetPoint(5,6,1/MCCor18_16);

  Float_t av=(h10_10->GetMean()+h10_16->GetMean()+
              h14_10->GetMean()+h14_16->GetMean()+
              h18_10->GetMean()+h18_16->GetMean())/6;
  Float_t avC=(h10_10->GetMean()*MCCor10_10+
               h10_16->GetMean()*MCCor10_16+
               h14_10->GetMean()*MCCor14_10+
               h14_16->GetMean()*MCCor14_16+
               h18_10->GetMean()*MCCor18_10+
               h18_16->GetMean()*MCCor18_16)/6;

  if (av>0){
    gMeuVsWinN->SetPoint(0,1,h10_10->GetMean()/av);
    gMeuVsWinN->SetPoint(1,2,h10_16->GetMean()/av);
    gMeuVsWinN->SetPoint(2,3,h14_10->GetMean()/av);
    gMeuVsWinN->SetPoint(3,4,h14_16->GetMean()/av);
    gMeuVsWinN->SetPoint(4,5,h18_10->GetMean()/av);
    gMeuVsWinN->SetPoint(5,6,h18_16->GetMean()/av);
  }
  if (avC>0){
    gMeuVsWinCorN->SetPoint(0,1,h10_10->GetMean()*MCCor10_10/avC);
    gMeuVsWinCorN->SetPoint(1,2,h10_16->GetMean()*MCCor10_16/avC);
    gMeuVsWinCorN->SetPoint(2,3,h14_10->GetMean()*MCCor14_10/avC);
    gMeuVsWinCorN->SetPoint(3,4,h14_16->GetMean()*MCCor14_16/avC);
    gMeuVsWinCorN->SetPoint(4,5,h18_10->GetMean()*MCCor18_10/avC);
    gMeuVsWinCorN->SetPoint(5,6,h18_16->GetMean()*MCCor18_16/avC);      
  }
  v[0]=dynamic_cast<TGraph*>(gMeuVsWinN);
  v[1]=dynamic_cast<TGraph*>(gMeuVsWinCorN);
  this->TGraphMinMax(v);

  //have to explicitly write graphs to file with a name
  if (fOutFile){
    gMeuVsWin->Write("gMeuVsWin");
    gMeuVsWinCor->Write("gMeuVsWinCor");
    gCorVsWin->Write("gCorVsWin");
    gMeuVsWinN->Write("gMeuVsWinN");
    gMeuVsWinCorN->Write("gMeuVsWinCorN");
  }

  //turn on the stats box printing
  gStyle->SetOptStat(111111);

  TCanvas *cMeu=new TCanvas("cMeu","Meu",0,0,1200,800);
  cMeu->SetFillColor(0);
  cMeu->Divide(3,3);
  cMeu->cd(1);
  h15_18->Draw();
  cMeu->cd(2);
  h10_16->Draw();
  cMeu->cd(3);
  h10_10->Draw();
  cMeu->cd(4);
  h14_16->Draw();
  cMeu->cd(5);
  h14_10->Draw();
  cMeu->cd(6);
  h18_16->Draw();
  cMeu->cd(7);
  h18_10->Draw();

  TCanvas *cEvLen=new TCanvas("cEvLen","EvLen",0,0,1200,800);
  cEvLen->SetFillColor(0);
  cEvLen->Divide(2,3);
  cEvLen->cd(1);
  hEvLenFe->Draw();
  cEvLen->cd(2);
  pSigCorVsRange->Draw();
  
  TCanvas *cStVsPl=new TCanvas("cStVsPl","StVsPl",0,0,1200,800);
  cStVsPl->SetFillColor(0);
  cStVsPl->Divide(2,2);
  cStVsPl->cd(1);
  pStVsPl1->Draw("colz");
  cStVsPl->cd(3);
  pStVsPl2->Draw("colz");
  cStVsPl->cd(2);
  hStVsPl1->Draw("colz");
  cStVsPl->cd(4);
  hStVsPl2->Draw("colz");

  //find the peaks
  //this is really not a precise thing!!!
  //the resolution of simple "average of x planes" is only ~4% 
  //this can't be used to say anything about the beam energy
  //because every plane you add can pull the average about dramatically
  //a much more sophisticated technique is probably required
  fPeakPlaneSigCors=0;
  fPeakLastPlane=0;
  multimap<Int_t,Int_t> evLen;//plane,num
  for (Int_t i=0;i<60;i++){
    Float_t num=hEvLenFe->GetBinContent(i+1);
    //add to map
    evLen.insert(pair<Int_t,Int_t>(static_cast<Int_t>(num),i));
    MSG("CDAnalysis",Msg::kDebug)
      <<"plane="<<i<<", num="<<num
      <<", sigcor="<<pSigCorVsRange->GetBinContent(i+1)<<endl;
    static Float_t peakNum=0;
    if (num>peakNum){
      peakNum=num;
      fPeakLastPlane=i;
      fPeakPlaneSigCors=pSigCorVsRange->GetBinContent(i+1);
    }
  }
  /*give up, no useful info can be deduced
  multimap<Int_t,Int_t>::iterator evit=evLen.end();
  for (Int_t i=0;i<5;i++){
    evit--;
    static Float_t totNum=0;
    static Float_t avPl=0;
    Float_t pl=evit->second;
    Float_t oldNum=totNum;
    Float_t newNum=evit->first;
    totNum+=newNum;
    avPl=avPl*(oldNum/totNum)+pl*(newNum/totNum);//weighted av
    MSG("CDAnalysis",Msg::kDebug)
      <<"pl="<<pl<<", newNum="<<newNum<<", avPl="<<avPl<<endl;
    //evit--;
  }
  */

  MSG("CDAnalysis",Msg::kInfo) 
    <<"fPeakLastPlanePeak="<<fPeakLastPlane
    <<", fPeakPlaneSigCors="<<fPeakPlaneSigCors<<endl;

  if (sum15_18Counter!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** Calibration Summary **"<<endl
      <<"SigCor in sliding window 15_18:"<<endl
      <<"    SigCor dep="<<sum15_18<<" (N="<<sum15_18Counter<<")"<<endl
      <<"    Av SigCor dep="<<sum15_18/sum15_18Counter
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"    Av SigCor dep per plane="<<(sum15_18/sum15_18Counter)/15
      <<" +/- "<<100*(h15_18->GetRMS()/sqrt(h15_18->GetEntries()))/
      h15_18->GetMean()<<"%"<<endl
      <<"MIPs in sliding window 15_18:"<<endl
      <<"    MIPs dep="<<sum15_18Mip
      <<" (N="<<sum15_18MipCounter<<")"<<endl
      <<"    Av MIPs dep="<<sum15_18Mip/sum15_18MipCounter
      <<endl;
    if (sumSigCorTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"SigCor of whole event:"<<endl
        <<"    Sum of SigCor dep="<<sumSigCorTotal
        <<" (N="<<sumSigCorTotalCounter<<")"<<endl
        <<"    Av sigCor dep="
        <<sumSigCorTotal/sumSigCorTotalCounter<<endl
        <<"    1 sigCor="
        <<1800/(sumSigCorTotal/sumSigCorTotalCounter)<<" MeV"
        <<endl;
    }
    if (sumMipTotalCounter!=0){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"MIPs of whole event:"<<endl
        <<"    Sum of MIPs dep="<<sumMipTotal
        <<" (N="<<sumMipTotalCounter<<")"<<endl
        <<"    Av MIPs dep="
        <<sumMipTotal/sumMipTotalCounter<<endl
        <<"    1 MIP="
        <<1800/(sumMipTotal/sumMipTotalCounter)<<" MeV"<<endl
        <<"    1 GeV="
        <<(sumMipTotal/sumMipTotalCounter)/1.8<<" MIPs"
        <<endl<<endl;
    }
  }

  if (hMeuPLCor->GetEntries()>0){
    Double_t quantile=0.5;//quantile to compute
    Double_t median=-1;
    hMeuPLCor->GetQuantiles(1,&median,&quantile);

    Float_t meuPLCor=median;
    Float_t meuPLCorErr=hMeuPLCor->GetRMS()/
      sqrt(hMeuPLCor->GetEntries());
    Float_t meuPLCorErrRel=meuPLCorErr/meuPLCor;
    
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** New MEU (Median) Calibration Summary **"<<endl
      <<"SigCor in sliding window 14_16:"<<endl
      <<"    SigCors/MEU="<<meuPLCor
      <<" +/- "<<meuPLCorErr<<" ("<<100*meuPLCorErrRel<<"%)"<<endl
      <<endl;
  }

  string percentStraight="fpe";
  if (NCutsCounter>0){
    percentStraight=Form("%.1f",100.*straightTrackCounter/
                         NCutsCounter);
  }
  MSG("CDAnalysis",Msg::kInfo) 
    <<"PassPidCounter="<<passPidCounter<<endl
    <<"NCutsCounter="<<NCutsCounter<<endl
    <<"StraightTrackCounter="<<straightTrackCounter
    <<" ("<<percentStraight<<"% of NCuts)"<<endl;

  if (ts.GetSec()>minRunTime){
    //print the stats
    this->PrintPIDStats();
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished StoppingMuonCalibration method **"<<endl;
}

//......................................................................

void CDAnalysis::MuonCalorimetry()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonCalorimetry method... **"<<endl;

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"MuonCal");

  TH1F *hSigCorTotal=new TH1F("hSigCorTotal","hSigCorTotal",1000,-2,75);
  hSigCorTotal->GetXaxis()->SetTitle("SigCors");
  hSigCorTotal->GetXaxis()->CenterTitle();
  hSigCorTotal->GetYaxis()->SetTitle("");
  hSigCorTotal->GetYaxis()->CenterTitle();
  hSigCorTotal->SetFillColor(0);
  hSigCorTotal->SetBit(TH1::kCanRebin);

  TH1F *hSigCorTotalTight=new TH1F("hSigCorTotalTight",
                                   "hSigCorTotalTight",1000,-2,75);
  hSigCorTotalTight->GetXaxis()->SetTitle("SigCors");
  hSigCorTotalTight->GetXaxis()->CenterTitle();
  hSigCorTotalTight->GetYaxis()->SetTitle("");
  hSigCorTotalTight->GetYaxis()->CenterTitle();
  hSigCorTotalTight->SetFillColor(0);
  hSigCorTotalTight->SetBit(TH1::kCanRebin);

  TH1F *hSigCorTotalPeak=new TH1F("hSigCorTotalPeak",
                                  "hSigCorTotalPeak",1000,-2,75);
  hSigCorTotalPeak->GetXaxis()->SetTitle("SigCors");
  hSigCorTotalPeak->GetXaxis()->CenterTitle();
  hSigCorTotalPeak->GetYaxis()->SetTitle("");
  hSigCorTotalPeak->GetYaxis()->CenterTitle();
  hSigCorTotalPeak->SetFillColor(0);
  hSigCorTotalPeak->SetBit(TH1::kCanRebin);

  TH1F *hEventLength=new TH1F("hEventLength","hEventLength hit",
                              77,-2,75);
  hEventLength->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hEventLength2=new TH1F("hEventLength2","hEventLength",77,-2,75);
  hEventLength2->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength2->GetXaxis()->CenterTitle();
  hEventLength2->GetYaxis()->SetTitle("");
  hEventLength2->GetYaxis()->CenterTitle();
  hEventLength2->SetFillColor(0);
  hEventLength2->SetBit(TH1::kCanRebin);

  TH1F *hEventLength3=new TH1F("hEventLength3","hEventLength",77,-2,75);
  hEventLength3->SetTitle("Event Track Length");
  hEventLength3->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength3->GetXaxis()->CenterTitle();
  hEventLength3->GetYaxis()->SetTitle("");
  hEventLength3->GetYaxis()->CenterTitle();
  hEventLength3->SetFillColor(0);
  hEventLength3->SetBit(TH1::kCanRebin);

  TH1F *hMainEn=new TH1F("hMainEn","hMainEn",2000,-1,2);
  hMainEn->GetXaxis()->SetTitle("Beam Energy");
  hMainEn->GetXaxis()->CenterTitle();
  hMainEn->GetYaxis()->SetTitle("");
  hMainEn->GetYaxis()->CenterTitle();
  hMainEn->SetFillColor(0);
  hMainEn->SetBit(TH1::kCanRebin);

  TProfile* pEnVsRange=new TProfile("pEnVsRange","pEnVsRange",
                                    62,0,62);
  pEnVsRange->SetTitle
    ("Beam Energy from Calorimetry vs Range");
  pEnVsRange->GetXaxis()->SetTitle("Range (planes)");
  pEnVsRange->GetXaxis()->CenterTitle();
  pEnVsRange->GetYaxis()->SetTitle("Beam Energy");
  pEnVsRange->GetYaxis()->CenterTitle();
  pEnVsRange->SetFillColor(0);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;

    Double_t sigCorTotal=0;

    //get the main particle energy
    hMainEn->Fill(this->GetMainParticleEnergy());

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
    //TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=0;
    if (fTruthHitInfo) numTruthHits=fTruthHitInfo->GetEntries();

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      if (fPlane==0) continue;
      //sum the sigcor in the event
      //make up for no plane 0 with 2 times plane 1
      else if (fPlane==1) sigCorTotal+=2*fChargeSigCor;
      else sigCorTotal+=fChargeSigCor;
    }
    //end of loop over the tracked hits

    hEventLength->Fill(fLastPlane+1);

    //make sure that the first plane makes sense and was actually set
    if (fFirstPlane<0 || fFirstPlane>59) continue;

    //calculate the event energy
    Double_t eventEn=(fScEnDepPerMEU/fSigCorPerMEU)*sigCorTotal*
      (1/fRatioScEnToBeamEn);
    //calc the last plane on the track with no xtalk
    Int_t lastPlaneNoXTalk=this->CalcLastPlaneOnTrkNoXTalk();
    hEventLength3->Fill(lastPlaneNoXTalk+1);

    //fill the prof
    pEnVsRange->Fill(lastPlaneNoXTalk+1,eventEn);

    //make event length cuts
    if (this->CutOnEventLength()) continue;
    //make track quality cuts
    if (this->CutOnTrackQuality()) continue;

    //fill the total sigcor histo
    hSigCorTotal->Fill(sigCorTotal);

    //fill event length plots for those passing cuts
    hEventLength2->Fill(fLastPlane+1);

    //look at a certain part of the spectrum
    if (lastPlaneNoXTalk+1>=50 && lastPlaneNoXTalk+1<53){//50,51,52
      //fill the total sigcor histo
      hSigCorTotalTight->Fill(sigCorTotal);
    }
    
    if (lastPlaneNoXTalk+1==51){
      //fill the total sigcor histo
      hSigCorTotalPeak->Fill(sigCorTotal);
    }
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);


  //turn off the stats box printing
  //gStyle->SetOptStat(0);
  gStyle->SetOptStat(1111111);

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hEventLength->Draw();
  cGeom->cd(2);
  hEventLength2->Draw();
  cGeom->cd(3);
  hEventLength3->Draw();
  cGeom->cd(3);

  TCanvas *cEnVsRange=new TCanvas("cEnVsRange","EnVsRange",
                                  0,0,1200,800);
  cEnVsRange->SetFillColor(0);
  cEnVsRange->Divide(1,2);
  cEnVsRange->cd(1);
  pEnVsRange->Draw();
  cEnVsRange->cd(2);
  hEventLength3->Draw();

  TCanvas *cSigCor=new TCanvas("cSigCor","SigCor",0,0,1200,800);
  cSigCor->SetFillColor(0);
  cSigCor->Divide(2,2);
  cSigCor->cd(1);
  hSigCorTotal->Draw();
  cSigCor->cd(2);
  hSigCorTotalTight->Draw();
  cSigCor->cd(3);
  hSigCorTotalPeak->Draw();
  cSigCor->cd(4);
  hMainEn->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<endl
    <<"Mean sigCorTotal="<<hSigCorTotal->GetMean()<<endl
    <<"Ratio ScEn to BeamEn="<<fRatioScEnToBeamEn
    <<" ("<<1/fRatioScEnToBeamEn<<")"<<endl
    <<"GeV per SigCor="<<fScEnDepPerMEU/fSigCorPerMEU<<endl
    <<"Beam energy from Calorimetry (lose)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotal->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl
    <<"Beam energy from Calorimetry (tight)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotalTight->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl
    <<"Beam energy from Calorimetry (peak)="
    <<((fScEnDepPerMEU/fSigCorPerMEU)*
    hSigCorTotalPeak->GetMean()*(1/fRatioScEnToBeamEn))/
    Munits::gigaelectronvolt<<" "<<Munits::base_energy_name<<endl<<endl;

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonCalorimetry method **"<<endl;
}

//......................................................................

void CDAnalysis::MuonSampleCuts()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonSampleCuts method... **"<<endl;

  //open the output file for the histograms
  //fOutFile=this->OpenFile(fRunNumber,"MuonSampleCuts");

  TH1F *hNumPlanesAll=new TH1F("hNumPlanesAll","NumPlanesAll hit",
                               77,-2,75);
  hNumPlanesAll->SetTitle("Number of Planes Hit");
  hNumPlanesAll->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesAll->GetXaxis()->CenterTitle();
  hNumPlanesAll->GetYaxis()->SetTitle("");
  hNumPlanesAll->GetYaxis()->CenterTitle();
  hNumPlanesAll->SetFillColor(0);
  hNumPlanesAll->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesN_Qual=new TH1F("hNumPlanesN_Qual",
                                  "hNumPlanesN_Qual",
                                  77,-2,75);
  hNumPlanesN_Qual->SetTitle("Number of Planes Hit");
  hNumPlanesN_Qual->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesN_Qual->GetXaxis()->CenterTitle();
  hNumPlanesN_Qual->GetYaxis()->SetTitle("");
  hNumPlanesN_Qual->GetYaxis()->CenterTitle();
  hNumPlanesN_Qual->SetFillColor(0);
  hNumPlanesN_Qual->SetLineColor(2);
  hNumPlanesN_Qual->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesN=new TH1F("hNumPlanesN",
                                  "hNumPlanesN",
                                  77,-2,75);
  hNumPlanesN->SetTitle("Number of Planes Hit");
  hNumPlanesN->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesN->GetXaxis()->CenterTitle();
  hNumPlanesN->GetYaxis()->SetTitle("");
  hNumPlanesN->GetYaxis()->CenterTitle();
  hNumPlanesN->SetFillColor(0);
  hNumPlanesN->SetLineColor(3);
  hNumPlanesN->SetBit(TH1::kCanRebin);

  TH1F *hEventLength=new TH1F("hEventLength","hEventLength hit",
                              77,-2,75);
  hEventLength->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hEventLength2=new TH1F("hEventLength2","hEventLength",77,-2,75);
  hEventLength2->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength2->GetXaxis()->CenterTitle();
  hEventLength2->GetYaxis()->SetTitle("");
  hEventLength2->GetYaxis()->CenterTitle();
  hEventLength2->SetFillColor(0);
  hEventLength2->SetBit(TH1::kCanRebin);

  TH1F *hEventLength3=new TH1F("hEventLength3","hEventLength",77,-2,75);
  hEventLength3->SetTitle("Event Track Length");
  hEventLength3->GetXaxis()->SetTitle("Event Length (planes)");
  hEventLength3->GetXaxis()->CenterTitle();
  hEventLength3->GetYaxis()->SetTitle("");
  hEventLength3->GetYaxis()->CenterTitle();
  hEventLength3->SetFillColor(0);
  hEventLength3->SetBit(TH1::kCanRebin);

  TProfile* pMeuVsEvLenCut=new TProfile("pMeuVsEvLenCut",
                                        "pMeuVsEvLenCut",
                                        62,0,62);
  pMeuVsEvLenCut->SetTitle("MEU Number vs Event Length Cut");
  pMeuVsEvLenCut->GetXaxis()->SetTitle("Lower Event Length Cut");
  pMeuVsEvLenCut->GetXaxis()->CenterTitle();
  pMeuVsEvLenCut->GetYaxis()->SetTitle("SigCors per MEU");
  pMeuVsEvLenCut->GetYaxis()->CenterTitle();
  pMeuVsEvLenCut->SetFillColor(0);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;

    map<Int_t,Float_t> planeSigCorT;
    map<Int_t,Int_t> numPlanesHitAll;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      if (fPlane==0) continue;
      //add up the total sigcor per plane
      planeSigCorT[fPlane]+=fChargeSigCor;
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      if (fPlane==0) continue;
      //add up the total sigcor per plane
      planeSigCorT[fPlane]+=fChargeSigCor;
    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      //count the number of planes hit
      numPlanesHitAll[fPlane]++;

      if (fPlane==0) continue;
      //add up the total sigcor per plane
      planeSigCorT[fPlane]+=fChargeSigCor;
    }
    //end of loop over the tracked hits

    hEventLength->Fill(fLastPlane+1);
    hNumPlanesAll->Fill(numPlanesHitAll.size());

    //make sure that the first plane makes sense and was actually set
    if (fFirstPlane<0 || fFirstPlane>59) continue;

    //do nasty hack for plane 40 - very nasty!!!!
    //if (fRunNumber==70709 || fRunNumber==70705){
    //planeSigCorT[40]=planeSigCorT[38];
    //}

    hNumPlanesN_Qual->Fill(numPlanesHitAll.size());

    //make event length cuts
    //if (this->CutOnEventLength()) continue;
    //make track quality cuts
    //if (this->CutOnTrackQuality()) continue;

    hNumPlanesN->Fill(numPlanesHitAll.size());

    //fill event length plots for those passing cuts
    hEventLength2->Fill(fLastPlane+1);

    //section for 15_18 window
    Int_t minEventLength=15+18+1;//+1 because don't want plane zero
    Int_t maxEvLen=57;//cut out muons ending in pl 58 or 59
    if (fLastPlane<minEventLength || fLastPlane>maxEvLen) continue;

    Float_t localSum15_18=0;
    Float_t localSum15_18Counter=0;

    Int_t windowStart=fLastPlane-18;
    Int_t windowSize=15;
    
    //loop through the hits in the window
    for (Int_t i=0;i<windowSize;i++){
      Int_t plane=windowStart-i;
      
      //calculate the best window value
      //if fLP=48 then the first plane included is 30
      //this is actually the 19th from the end of the track
      localSum15_18+=planeSigCorT[plane];//total including xtalk
      localSum15_18Counter++;
    }

    for (Int_t lowerPlCut=57;lowerPlCut>minEventLength;lowerPlCut--){

      if (localSum15_18Counter!=0 && fLastPlane>=lowerPlCut){

        MSG("CDAnalysis",Msg::kVerbose)
          <<"Filling prof: lowerPlCut="<<lowerPlCut
          <<", 15_18="<<localSum15_18/windowSize<<endl;

        pMeuVsEvLenCut->Fill(lowerPlCut,localSum15_18/windowSize);
      }
    }

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);


  //turn off the stats box printing
  //gStyle->SetOptStat(0);
  gStyle->SetOptStat(1111111);

  TCanvas *cGeom=new TCanvas("cGeom","cGeom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hEventLength->Draw();
  cGeom->cd(2);
  hEventLength2->Draw();
  cGeom->cd(3);
  hEventLength3->Draw();
  cGeom->cd(3);

  TCanvas *cNumPl=new TCanvas("cNumPl","cNumPl",0,0,1200,800);
  cNumPl->SetFillColor(0);
  cNumPl->Divide(2,2);
  cNumPl->cd(1);
  hNumPlanesAll->Draw();
  cNumPl->cd(2);
  hNumPlanesN_Qual->Draw();
  cNumPl->cd(3);
  hNumPlanesN->Draw();
  cNumPl->cd(4);
  hNumPlanesAll->Draw();
  hNumPlanesN_Qual->Draw("sames");
  hNumPlanesN->Draw("sames");

  TCanvas *cMeuVsEvLenCut=new TCanvas("cMeuVsEvLenCut",
                                      "cMeuVsEvLenCut",0,0,1200,800);
  cMeuVsEvLenCut->SetFillColor(0);
  //cMeuVsEvLenCut->Divide(1,1);
  //cMeuVsEvLenCut->cd(1);
  pMeuVsEvLenCut->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonSampleCuts method **"<<endl;
}

//......................................................................

void CDAnalysis::ElectronResponse()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ElectronResponse method... **"<<endl;

  //open the output file for the histograms if not already done
  if (!fOutFile) fOutFile=this->OpenFile(fRunNumber,"ElecRes");

  TH1F *hNumPlanesAll_Elec=new TH1F("hNumPlanesAll_Elec",
                                    "NumPlanesAll_Elec hit",77,-2,75);
  hNumPlanesAll_Elec->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesAll_Elec->GetXaxis()->CenterTitle();
  hNumPlanesAll_Elec->GetYaxis()->SetTitle("");
  hNumPlanesAll_Elec->GetYaxis()->CenterTitle();
  hNumPlanesAll_Elec->SetFillColor(0);
  hNumPlanesAll_Elec->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanesAllN_Elec=new TH1F("hNumPlanesAllN_Elec",
                                    "NumPlanesAllN_Elec hit",77,-2,75);
  hNumPlanesAllN_Elec->GetXaxis()->SetTitle("Number of Planes Hit");
  hNumPlanesAllN_Elec->GetXaxis()->CenterTitle();
  hNumPlanesAllN_Elec->GetYaxis()->SetTitle("");
  hNumPlanesAllN_Elec->GetYaxis()->CenterTitle();
  hNumPlanesAllN_Elec->SetFillColor(0);
  hNumPlanesAllN_Elec->SetBit(TH1::kCanRebin);
  
  TH1F *hSumSigCor_Elec=new TH1F("hSumSigCor_Elec","hSumSigCor_Elec",
                                 500,-2,100000);
  hSumSigCor_Elec->SetTitle("Sum of Corrected ADCs in Event");
  hSumSigCor_Elec->GetXaxis()->
    SetTitle("Sum of Corrected ADCs in Event");
  hSumSigCor_Elec->GetXaxis()->CenterTitle();
  hSumSigCor_Elec->GetYaxis()->SetTitle("");
  hSumSigCor_Elec->GetYaxis()->CenterTitle();
  hSumSigCor_Elec->SetFillColor(0);
  //hSumSigCor_Elec->SetBit(TH1::kCanRebin);

  TH1F *hSumMeu_Elec=new TH1F("hSumMeu_Elec","hSumMeu_Elec",500,-2,400);
  hSumMeu_Elec->SetTitle("Sum of MEUs in Event");
  hSumMeu_Elec->GetXaxis()->SetTitle("Sum of MEUs in Event");
  hSumMeu_Elec->GetXaxis()->CenterTitle();
  hSumMeu_Elec->GetYaxis()->SetTitle("");
  hSumMeu_Elec->GetYaxis()->CenterTitle();
  hSumMeu_Elec->SetFillColor(0);
  //hSumMeu_Elec->SetBit(TH1::kCanRebin);

  TH1F *hSumMip_Elec=new TH1F("hSumMip_Elec","hSumMip_Elec",500,-2,400);
  hSumMip_Elec->SetTitle("Sum of Cosmic-MIPs in Event");
  hSumMip_Elec->GetXaxis()->SetTitle("Sum of Cosmic-MIPs in Event");
  hSumMip_Elec->GetXaxis()->CenterTitle();
  hSumMip_Elec->GetYaxis()->SetTitle("");
  hSumMip_Elec->GetYaxis()->CenterTitle();
  hSumMip_Elec->SetFillColor(0);
  //hSumMip_Elec->SetBit(TH1::kCanRebin);

  TH1F *hSigCor_Elec=new TH1F("hSigCor_Elec","hSigCor_Elec",
                              5000,-2,10000);
  hSigCor_Elec->SetTitle("Corrected ADCs");
  hSigCor_Elec->GetXaxis()->SetTitle("Corrected ADCs");
  hSigCor_Elec->GetXaxis()->CenterTitle();
  hSigCor_Elec->GetYaxis()->SetTitle("");
  hSigCor_Elec->GetYaxis()->CenterTitle();
  hSigCor_Elec->SetFillColor(0);
  hSigCor_Elec->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2_Elec=new TH1F("hOLChi2_Elec","hOLChi2_Elec",
                               200,0,10);
  hOLChi2_Elec->GetXaxis()->SetTitle("OLChi2");
  hOLChi2_Elec->GetXaxis()->CenterTitle();
  hOLChi2_Elec->GetYaxis()->SetTitle("");
  hOLChi2_Elec->GetYaxis()->CenterTitle();
  hOLChi2_Elec->SetFillColor(0);
  hOLChi2_Elec->SetLineWidth(3);
  //hOLChi2_Elec->SetBit(TH1::kCanRebin);
  
  TH1F *hOLChi2_ElecN_1=new TH1F("hOLChi2_ElecN_1","hOLChi2_ElecN_1",
                               200,0,10);
  hOLChi2_ElecN_1->GetXaxis()->SetTitle("OLChi2");
  hOLChi2_ElecN_1->GetXaxis()->CenterTitle();
  hOLChi2_ElecN_1->GetYaxis()->SetTitle("");
  hOLChi2_ElecN_1->GetYaxis()->CenterTitle();
  hOLChi2_ElecN_1->SetFillColor(0);
  hOLChi2_ElecN_1->SetLineWidth(3);
  hOLChi2_ElecN_1->SetLineColor(2);
  //hOLChi2_ElecN_1->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2_ElecN=new TH1F("hOLChi2_ElecN","hOLChi2_ElecN",
                               200,0,10);
  hOLChi2_ElecN->GetXaxis()->SetTitle("OLChi2");
  hOLChi2_ElecN->GetXaxis()->CenterTitle();
  hOLChi2_ElecN->GetYaxis()->SetTitle("");
  hOLChi2_ElecN->GetYaxis()->CenterTitle();
  hOLChi2_ElecN->SetFillColor(0);
  hOLChi2_ElecN->SetLineWidth(3);
  hOLChi2_ElecN->SetLineColor(4);
  //hOLChi2_ElecN->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1_Elec=new TH1F("hKovADC1_Elec","KovADC1_Elec",
                               400,-5,10000);
  hKovADC1_Elec->GetXaxis()->SetTitle("KovADC1");
  hKovADC1_Elec->GetXaxis()->CenterTitle();
  hKovADC1_Elec->GetYaxis()->SetTitle("");
  hKovADC1_Elec->GetYaxis()->CenterTitle();
  hKovADC1_Elec->SetFillColor(0);
  hKovADC1_Elec->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1_ElecN_1=new TH1F("hKovADC1_ElecN_1","KovADC1_ElecN_1",
                                400,-5,10000);
  hKovADC1_ElecN_1->GetXaxis()->SetTitle("KovADC1");
  hKovADC1_ElecN_1->GetXaxis()->CenterTitle();
  hKovADC1_ElecN_1->GetYaxis()->SetTitle("");
  hKovADC1_ElecN_1->GetYaxis()->CenterTitle();
  hKovADC1_ElecN_1->SetFillColor(0);
  hKovADC1_ElecN_1->SetLineColor(2);
  hKovADC1_ElecN_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1_ElecN=new TH1F("hKovADC1_ElecN","KovADC1_ElecN",
                                400,-5,10000);
  hKovADC1_ElecN->GetXaxis()->SetTitle("KovADC1");
  hKovADC1_ElecN->GetXaxis()->CenterTitle();
  hKovADC1_ElecN->GetYaxis()->SetTitle("");
  hKovADC1_ElecN->GetYaxis()->CenterTitle();
  hKovADC1_ElecN->SetFillColor(0);
  hKovADC1_ElecN->SetLineColor(4);
  hKovADC1_ElecN->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2_Elec=new TH1F("hKovADC2_Elec","KovADC2_Elec",
                               400,-5,10000);
  hKovADC2_Elec->GetXaxis()->SetTitle("KovADC2");
  hKovADC2_Elec->GetXaxis()->CenterTitle();
  hKovADC2_Elec->GetYaxis()->SetTitle("");
  hKovADC2_Elec->GetYaxis()->CenterTitle();
  hKovADC2_Elec->SetFillColor(0);
  hKovADC2_Elec->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2_ElecN_1=new TH1F("hKovADC2_ElecN_1","KovADC2_ElecN_1",
                                400,-5,10000);
  hKovADC2_ElecN_1->GetXaxis()->SetTitle("KovADC2");
  hKovADC2_ElecN_1->GetXaxis()->CenterTitle();
  hKovADC2_ElecN_1->GetYaxis()->SetTitle("");
  hKovADC2_ElecN_1->GetYaxis()->CenterTitle();
  hKovADC2_ElecN_1->SetFillColor(0);
  hKovADC2_ElecN_1->SetLineColor(2);
  hKovADC2_ElecN_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2_ElecN=new TH1F("hKovADC2_ElecN","KovADC2_ElecN",
                                400,-5,10000);
  hKovADC2_ElecN->GetXaxis()->SetTitle("KovADC2");
  hKovADC2_ElecN->GetXaxis()->CenterTitle();
  hKovADC2_ElecN->GetYaxis()->SetTitle("");
  hKovADC2_ElecN->GetYaxis()->CenterTitle();
  hKovADC2_ElecN->SetFillColor(0);
  hKovADC2_ElecN->SetLineColor(4);
  hKovADC2_ElecN->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3_Elec=new TH1F("hKovADC3_Elec","KovADC3_Elec",
                               400,-5,10000);
  hKovADC3_Elec->GetXaxis()->SetTitle("KovADC3");
  hKovADC3_Elec->GetXaxis()->CenterTitle();
  hKovADC3_Elec->GetYaxis()->SetTitle("");
  hKovADC3_Elec->GetYaxis()->CenterTitle();
  hKovADC3_Elec->SetFillColor(0);
  hKovADC3_Elec->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3_ElecN_1=new TH1F("hKovADC3_ElecN_1","KovADC3_ElecN_1",
                                400,-5,10000);
  hKovADC3_ElecN_1->GetXaxis()->SetTitle("KovADC3");
  hKovADC3_ElecN_1->GetXaxis()->CenterTitle();
  hKovADC3_ElecN_1->GetYaxis()->SetTitle("");
  hKovADC3_ElecN_1->GetYaxis()->CenterTitle();
  hKovADC3_ElecN_1->SetFillColor(0);
  hKovADC3_ElecN_1->SetLineColor(2);
  hKovADC3_ElecN_1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3_ElecN=new TH1F("hKovADC3_ElecN","KovADC3_ElecN",
                                400,-5,10000);
  hKovADC3_ElecN->GetXaxis()->SetTitle("KovADC3");
  hKovADC3_ElecN->GetXaxis()->CenterTitle();
  hKovADC3_ElecN->GetYaxis()->SetTitle("");
  hKovADC3_ElecN->GetYaxis()->CenterTitle();
  hKovADC3_ElecN->SetFillColor(0);
  hKovADC3_ElecN->SetLineColor(4);
  hKovADC3_ElecN->SetBit(TH1::kCanRebin);

  TH1F *hTofDiff_Elec=new TH1F("hTofDiff_Elec","hTofDiff_Elec",
                               400,-4000,4000);
  hTofDiff_Elec->GetXaxis()->SetTitle("TOF");
  hTofDiff_Elec->GetXaxis()->CenterTitle();
  hTofDiff_Elec->GetYaxis()->SetTitle("");
  hTofDiff_Elec->GetYaxis()->CenterTitle();
  hTofDiff_Elec->SetFillColor(0);
  hTofDiff_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofDiff_ElecN_1=new TH1F("hTofDiff_ElecN_1","hTofDiff_ElecN_1",
                                400,-4000,4000);
  hTofDiff_ElecN_1->GetXaxis()->SetTitle("TOF");
  hTofDiff_ElecN_1->GetXaxis()->CenterTitle();
  hTofDiff_ElecN_1->GetYaxis()->SetTitle("");
  hTofDiff_ElecN_1->GetYaxis()->CenterTitle();
  hTofDiff_ElecN_1->SetFillColor(0);
  hTofDiff_ElecN_1->SetLineColor(2);
  hTofDiff_ElecN_1->SetBit(TH1::kCanRebin);

  TH1F *hTofDiff_ElecN=new TH1F("hTofDiff_ElecN","hTofDiff_ElecN",
                                400,-4000,4000);
  hTofDiff_ElecN->GetXaxis()->SetTitle("TOF");
  hTofDiff_ElecN->GetXaxis()->CenterTitle();
  hTofDiff_ElecN->GetYaxis()->SetTitle("");
  hTofDiff_ElecN->GetYaxis()->CenterTitle();
  hTofDiff_ElecN->SetFillColor(0);
  hTofDiff_ElecN->SetLineColor(4);
  hTofDiff_ElecN->SetBit(TH1::kCanRebin);

  TH1F *hTofKov1Diff_Elec=new TH1F("hTofKov1Diff_Elec",
                                   "hTofKov1Diff_Elec",4000,-2,3);
  hTofKov1Diff_Elec->GetXaxis()->SetTitle("Tof-Ckv time");
  hTofKov1Diff_Elec->GetXaxis()->CenterTitle();
  hTofKov1Diff_Elec->GetYaxis()->SetTitle("");
  hTofKov1Diff_Elec->GetYaxis()->CenterTitle();
  hTofKov1Diff_Elec->SetFillColor(0);
  hTofKov1Diff_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofKov1DiffN_1_Elec=new TH1F("hTofKov1DiffN_1_Elec",
                                   "hTofKov1DiffN_1_Elec",4000,-2,3);
  hTofKov1DiffN_1_Elec->GetXaxis()->SetTitle("Tof-Ckv time");
  hTofKov1DiffN_1_Elec->GetXaxis()->CenterTitle();
  hTofKov1DiffN_1_Elec->GetYaxis()->SetTitle("");
  hTofKov1DiffN_1_Elec->GetYaxis()->CenterTitle();
  hTofKov1DiffN_1_Elec->SetFillColor(0);
  hTofKov1DiffN_1_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofKov1DiffN_Elec=new TH1F("hTofKov1DiffN_Elec",
                                   "hTofKov1DiffN_Elec",4000,-2,3);
  hTofKov1DiffN_Elec->GetXaxis()->SetTitle("Tof-Ckv time");
  hTofKov1DiffN_Elec->GetXaxis()->CenterTitle();
  hTofKov1DiffN_Elec->GetYaxis()->SetTitle("");
  hTofKov1DiffN_Elec->GetYaxis()->CenterTitle();
  hTofKov1DiffN_Elec->SetFillColor(0);
  hTofKov1DiffN_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofKov3Diff_Elec=new TH1F("hTofKov3Diff_Elec",
                                   "hTofKov3Diff_Elec",4000,-2,3);
  hTofKov3Diff_Elec->GetXaxis()->SetTitle("Tof - Ckv time");
  hTofKov3Diff_Elec->GetXaxis()->CenterTitle();
  hTofKov3Diff_Elec->GetYaxis()->SetTitle("");
  hTofKov3Diff_Elec->GetYaxis()->CenterTitle();
  hTofKov3Diff_Elec->SetFillColor(0);
  hTofKov3Diff_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofKov3DiffN_1_Elec=new TH1F("hTofKov3DiffN_1_Elec",
                                   "hTofKov3DiffN_1_Elec",4000,-2,3);
  hTofKov3DiffN_1_Elec->GetXaxis()->SetTitle("Tof - Ckv time");
  hTofKov3DiffN_1_Elec->GetXaxis()->CenterTitle();
  hTofKov3DiffN_1_Elec->GetYaxis()->SetTitle("");
  hTofKov3DiffN_1_Elec->GetYaxis()->CenterTitle();
  hTofKov3DiffN_1_Elec->SetFillColor(0);
  hTofKov3DiffN_1_Elec->SetBit(TH1::kCanRebin);

  TH1F *hTofKov3DiffN_Elec=new TH1F("hTofKov3DiffN_Elec",
                                   "hTofKov3DiffN_Elec",4000,-2,3);
  hTofKov3DiffN_Elec->GetXaxis()->SetTitle("Tof - Ckv time");
  hTofKov3DiffN_Elec->GetXaxis()->CenterTitle();
  hTofKov3DiffN_Elec->GetYaxis()->SetTitle("");
  hTofKov3DiffN_Elec->GetYaxis()->CenterTitle();
  hTofKov3DiffN_Elec->SetFillColor(0);
  hTofKov3DiffN_Elec->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //do this cut before everything
    if (this->CutOnDeadChips()) continue;
    //don't cut on pid here anymore

    //fill histos before any cuts
    hOLChi2_Elec->Fill(fOLChi2);
    hKovADC1_Elec->Fill(fKovADC1);
    hKovADC2_Elec->Fill(fKovADC2);
    hKovADC3_Elec->Fill(fKovADC3);
    hTofDiff_Elec->Fill(fTofTDC2-fTofTDC0); 
    hTofKov1Diff_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp1);
    hTofKov3Diff_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp3);
 
    Double_t sumSigCor=0;
    Double_t sumMip=0;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();
      
      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      sumSigCor+=fChargeSigCor;
      sumMip+=fChargeMip;
      hSigCor_Elec->Fill(fChargeSigCor);
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      sumSigCor+=fChargeSigCor;
      sumMip+=fChargeMip;
      hSigCor_Elec->Fill(fChargeSigCor);
    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calc the scint hits time difference compared to tof
      this->CalcLowUpScint_TofDiff(fTime);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);
      this->CalcNumPlanesHit(fPlane,fChargePe);

      //cut out the channels not to be used in calorimetry
      if (this->CutOnBadCalorimetry(fPlane,fStrip,fStripend)) continue;

      //do the calibration again with latest tables, temperatures,etc
      fChargeSigCor=this->ReCalibrate(fChargeAdc,
                                      fPlane,fStrip,fStripend);

      sumSigCor+=fChargeSigCor;
      sumMip+=fChargeMip;
      hSigCor_Elec->Fill(fChargeSigCor);
    }
    //end of loop over the tracked hits

    //fill histos for all data
    hNumPlanesAll_Elec->Fill(fNumPlanesHitAll.size());

    if (!this->CutOnPidForElec() &&
        !this->CutOnEventLengthForElec() && 
        !this->CutOnScint_TofDiff()){
      hOLChi2_ElecN_1->Fill(fOLChi2);
    }

    if (!this->CutOnEventLengthForElec() && 
        !this->CutOnOverlapForElec() &&
        !this->CutOnScint_TofDiff()){
      hKovADC1_ElecN_1->Fill(fKovADC1);
      hKovADC2_ElecN_1->Fill(fKovADC2);
      hKovADC3_ElecN_1->Fill(fKovADC3);
      hTofDiff_ElecN_1->Fill(fTofTDC2-fTofTDC0); 
      hTofKov1DiffN_1_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp1);
      hTofKov3DiffN_1_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp3);
    }

    //::elec cuts 
    //cut on pid for electrons
    if (this->CutOnPidForElec()) continue;
    //make event length cuts
    if (this->CutOnEventLengthForElec()) continue;
    //make overlap cut
    if (this->CutOnOverlapForElec()) continue;
    //cut on the time difference between scint hits and tof hit
    if (this->CutOnScint_TofDiff()) continue;
    
    //fill pid histos
    hOLChi2_ElecN->Fill(fOLChi2);
    hKovADC1_ElecN->Fill(fKovADC1);
    hKovADC2_ElecN->Fill(fKovADC2);
    hKovADC3_ElecN->Fill(fKovADC3);
    hTofDiff_ElecN->Fill(fTofTDC2-fTofTDC0); 
    hTofKov1DiffN_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp1);
    hTofKov3DiffN_Elec->Fill(fTofADCTimeStamp1-fKovTimeStamp3);

    //fill histo after cuts
    hNumPlanesAllN_Elec->Fill(fNumPlanesHitAll.size());
    
    MAXMSG("CDAnalysis",Msg::kDebug,10)
      <<"Event passing plane cuts="<<event<<endl;

    //fill when one-sided (near-only) readout in a sensible way
    if (fRunNumber>=100000) hSumMip_Elec->Fill(sumMip);
    if (fRunNumber<100000) hSumMip_Elec->Fill(sumMip/2);

    hSumSigCor_Elec->Fill(sumSigCor);
    hSumMeu_Elec->Fill(sumSigCor/fSigCorPerMEU);

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  //gStyle->SetOptStat(0);
  gStyle->SetOptStat(1111111);

  TCanvas *cGeom_Elec=new TCanvas("cGeom_Elec","cGeom_Elec",
                                  0,0,1200,800);
  cGeom_Elec->SetFillColor(0);
  //cGeom_Elec->Divide(2,3);
  cGeom_Elec->cd(1);
  hNumPlanesAll_Elec->Draw();
  hNumPlanesAllN_Elec->SetLineColor(2);
  hNumPlanesAllN_Elec->Draw("sames");

  TCanvas *cEnDep_Elec=new TCanvas("cEnDep_Elec","cEnDep_Elec",
                                   0,0,1200,800);
  cEnDep_Elec->SetFillColor(0);
  cEnDep_Elec->Divide(2,3);
  cEnDep_Elec->cd(1);
  hSigCor_Elec->Draw();
  cEnDep_Elec->cd(2);
  hSumSigCor_Elec->Draw();
  cEnDep_Elec->cd(3);
  hSumMeu_Elec->Draw();
  cEnDep_Elec->cd(4);
  hSumMip_Elec->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ElectronResponse method **"<<endl;
}

//......................................................................

void CDAnalysis::MuonScatter()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonScatter method... **"<<endl;

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"MuonScat");

  //fS="Transverse hits in last plane";
  //TProfile* transLastPl=new TProfile(fS.c_str(),fS.c_str(),25,-1,24);

  vector<TProfile*> pTransAvEnDep;
  vector<TH1F*> hTransSumEnDep;
  vector<TH1F*> hTransHits;

  for (Int_t pl=0;pl<70;pl++){
    string sPl=Form("%d",pl);
    string sName="";
    
    sName="pTransAvEnDep";
    fS="Transverse Average Energy Deposition, plane=";
    fS+=sPl;
    sName+=sPl;
    pTransAvEnDep.push_back(new TProfile(sName.c_str(),fS.c_str(),
                                         27,-1,26));
    vector<TProfile*>::iterator prof=pTransAvEnDep.begin();
    (*prof)->GetXaxis()->SetTitle("Strip");
    (*prof)->GetYaxis()->SetTitle("Average Energy");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    
    sName="hTransSumEnDep";
    fS="Transverse Sum of Energy Deposition, plane=";
    fS+=sPl;
    sName+=sPl;
    hTransSumEnDep.push_back(new TH1F(sName.c_str(),fS.c_str(),
                                      27,-1,26));
    vector<TH1F*>::iterator hist=hTransSumEnDep.begin();
    (*hist)->GetXaxis()->SetTitle("Strip");
    (*hist)->GetYaxis()->SetTitle("Summed Energy");
    (*hist)->GetXaxis()->CenterTitle();
    (*hist)->GetYaxis()->CenterTitle();

    sName="hTransHits";
    fS="Transverse Hits, plane=";
    fS+=sPl;
    sName+=sPl;
    hTransHits.push_back(new TH1F(sName.c_str(),fS.c_str(),27,-1,26));
    hist=hTransHits.end();
    --hist;
    (*hist)->GetXaxis()->SetTitle("Strip");
    (*hist)->GetYaxis()->SetTitle("Num Hits");
    (*hist)->GetXaxis()->CenterTitle();
    (*hist)->GetYaxis()->CenterTitle();
  }

  TH1F *hLastPlane=new TH1F("hLastPlane","hLastPlane",66,-1,65);
  hLastPlane->GetXaxis()->SetTitle("Plane");
  hLastPlane->GetXaxis()->CenterTitle();
  hLastPlane->GetYaxis()->SetTitle("");
  hLastPlane->GetYaxis()->CenterTitle();
  hLastPlane->SetFillColor(0);
  hLastPlane->SetBit(TH1::kCanRebin);

  TH1F *hLastPlaneCut=new TH1F("hLastPlaneCut","hLastPlaneCut",
                               66,-1,65);
  hLastPlaneCut->GetXaxis()->SetTitle("Plane");
  hLastPlaneCut->GetXaxis()->CenterTitle();
  hLastPlaneCut->GetYaxis()->SetTitle("");
  hLastPlaneCut->GetYaxis()->CenterTitle();
  hLastPlaneCut->SetFillColor(0);
  hLastPlaneCut->SetLineColor(2);
  hLastPlaneCut->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){

    this->SetLoopVariables(event);

    //calculate the last plane no xtalk
    Int_t lastPl=this->CalcLastPlaneOnTrkNoXTalk();
    hLastPlane->Fill(lastPl);
    if (lastPl<48 || lastPl>51) continue;
    hLastPlaneCut->Fill(lastPl);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
          
    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      pTransAvEnDep[fPlane]->Fill(fStrip,fChargeMip);
      hTransSumEnDep[fPlane]->Fill(fStrip,fChargeMip);
      hTransHits[fPlane]->Fill(fStrip,1);
    }
    //end of loop over the tracked hits
  }


  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //turn off the stats box printing
  gStyle->SetOptStat(0);

  //turn on the stats box printing
  gStyle->SetOptStat(1111111);

  TCanvas *cTransHits=new TCanvas("cTransHits","cTransHits",
                                  0,0,1200,800);
  cTransHits->SetFillColor(0);
  cTransHits->Divide(4,4);
  Int_t i=0;
  vector<TH1F*>::iterator hist=hTransHits.begin();
  cTransHits->cd(++i);//1
  (*(hist+1))->Draw();
  cTransHits->cd(++i);
  (*(hist+4))->Draw();
  cTransHits->cd(++i);
  (*(hist+8))->Draw();
  cTransHits->cd(++i);//4
  (*(hist+12))->Draw();
  cTransHits->cd(++i);
  (*(hist+16))->Draw();
  cTransHits->cd(++i);//6
  (*(hist+20))->Draw();
  cTransHits->cd(++i);
  (*(hist+24))->Draw();
  cTransHits->cd(++i);//8
  (*(hist+28))->Draw();
  cTransHits->cd(++i);
  (*(hist+32))->Draw();
  cTransHits->cd(++i);//10
  (*(hist+36))->Draw();
  cTransHits->cd(++i);
  (*(hist+40))->Draw();
  cTransHits->cd(++i);//12
  (*(hist+44))->Draw();
  cTransHits->cd(++i);
  (*(hist+48))->Draw();
  cTransHits->cd(++i);//14
  (*(hist+52))->Draw();
  cTransHits->cd(++i);
  (*(hist+56))->Draw();
  cTransHits->cd(++i);//16
  (*(hist+59))->Draw();

  TCanvas *cPlCut=new TCanvas("cPlCut","cPlCut",0,0,1200,800);
  cPlCut->SetFillColor(0);
  hLastPlane->Draw();
  hLastPlaneCut->Draw("sames");

  Bool_t printPs=false;
  if (printPs){
    TCanvas *cProf=new TCanvas("cProf","cProf",0,0,1200,800);
    cProf->SetFillColor(0);
    string sName="TransverseEnergyDep.ps";
    cProf->Print((sName+"[").c_str());
    gErrorIgnoreLevel=1;
    //plot the prof 
    for (vector<TProfile*>::iterator prof=pTransAvEnDep.begin();
         prof!=pTransAvEnDep.end();++prof){      
      cProf->Clear();
      (*prof)->Draw();
      //(*prof)->SetTitle("Transverse Hits in Plane");
      (*prof)->GetXaxis()->SetTitle("Strip");
      (*prof)->GetYaxis()->SetTitle("Average MIPs");
      (*prof)->GetXaxis()->CenterTitle();
      (*prof)->GetYaxis()->CenterTitle();
      cProf->Print(sName.c_str());
    }
    cProf->Print((sName+"]").c_str());
    
    //plot second
    TCanvas *cProf2=new TCanvas("cProf2","cProf2",0,0,1200,800);
    cProf2->SetFillColor(0);
    sName="TransverseSumEnergyDep.ps";
    gErrorIgnoreLevel=0;
    cProf2->Print((sName+"[").c_str());
    gErrorIgnoreLevel=1;
    //plot
    for (vector<TH1F*>::iterator hist=hTransSumEnDep.begin();
         hist!=hTransSumEnDep.end();++hist){      
      cProf2->Clear();
      (*hist)->Draw();
      //(*hist)->SetTitle("Transverse Hits in Plane");
      (*hist)->GetXaxis()->SetTitle("Strip");
      (*hist)->GetYaxis()->SetTitle("Summed Energy");
      (*hist)->GetXaxis()->CenterTitle();
      (*hist)->GetYaxis()->CenterTitle();
      cProf2->Print(sName.c_str());
    }
    cProf2->Print((sName+"]").c_str());
    
    //plot
    sName="TransverseHits.ps";
    gErrorIgnoreLevel=0;
    cProf2->Print((sName+"[").c_str());
    gErrorIgnoreLevel=1;
    //plot
    for (vector<TH1F*>::iterator hist=hTransHits.begin();
         hist!=hTransHits.end();++hist){      
      cProf2->Clear();
      (*hist)->Draw();
    }
    cProf2->Print((sName+"]").c_str());
  }

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonScatter method **"<<endl;
}

//......................................................................

void CDAnalysis::MuonStVsPl()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running MuonStVsPl method... **"<<endl;
  
  vector<TH1F*> hAdc(4); 

  for (UInt_t i=0;i<hAdc.size();i++){
    string sNum=Form("%d",i);
    fS="Adc distribution"+sNum;
    hAdc[i]=new TH1F(fS.c_str(),fS.c_str(),4000,-20,20000);
    hAdc[i]->GetXaxis()->SetTitle("Adc");
    hAdc[i]->GetXaxis()->CenterTitle();
    hAdc[i]->GetYaxis()->SetTitle("");
    hAdc[i]->GetYaxis()->CenterTitle();
    hAdc[i]->SetFillColor(0);
    hAdc[i]->SetBit(TH1::kCanRebin);
  }

  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  fS="Strip Vs Plane EnergyDep Map";
  TProfile2D* pStVsPlEnDep=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDep->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDep->GetXaxis()->CenterTitle();
  pStVsPlEnDep->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDep->GetYaxis()->CenterTitle();
  pStVsPlEnDep->SetFillColor(0);
  //pStVsPlEnDep->SetMaximum(15000);

  fS="Strip Vs Plane SigCor Map";
  TProfile2D* pStVsPlSigCor=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlSigCor->GetXaxis()->SetTitle("Plane");
  pStVsPlSigCor->GetXaxis()->CenterTitle();
  pStVsPlSigCor->GetYaxis()->SetTitle("Strip");
  pStVsPlSigCor->GetYaxis()->CenterTitle();
  pStVsPlSigCor->SetFillColor(0);
  //pStVsPlSigCor->SetMaximum(15000);

  fS="Strip Vs Plane Adc Map";
  TProfile2D* pStVsPlAdc=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlAdc->GetXaxis()->SetTitle("Plane");
  pStVsPlAdc->GetXaxis()->CenterTitle();
  pStVsPlAdc->GetYaxis()->SetTitle("Strip");
  pStVsPlAdc->GetYaxis()->CenterTitle();
  pStVsPlAdc->SetFillColor(0);
  //pStVsPlAdc->SetMaximum(15000);

  fS="Strip Vs Plane Num Hits Map";
  TH2F* hStVsPlNum=new TH2F(fS.c_str(),fS.c_str(),64,-2,62,30,-3,27);
  hStVsPlNum->GetXaxis()->SetTitle("Plane");
  hStVsPlNum->GetXaxis()->CenterTitle();
  hStVsPlNum->GetYaxis()->SetTitle("Strip");
  hStVsPlNum->GetYaxis()->CenterTitle();
  hStVsPlNum->SetFillColor(0);
  //hStVsPlNum->SetMaximum(15000);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();

    //loop over the tracked hits
    //to calc first and last planes
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);
      this->CalcNumPlanesHitTrk(fPlane);
    }
    //end of loop over the tracked hits

    //check track length and composition
    if (fLastPlane<40 || fNumPlanesHitTrk.size()<35) continue;

    //loop over the tracked hits again...
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      if (fPlane==2 && fStrip==19) {
        hAdc[0]->Fill(fChargeAdc);
        MSG("CDAnalysis",Msg::kInfo)
          <<"e="<<event<<", adc="<<fChargeAdc<<endl;
        
      }
      else if (fPlane==5 && fStrip==19) hAdc[1]->Fill(fChargeAdc);
      else if (fPlane==13 && fStrip==11) hAdc[2]->Fill(fChargeAdc);
      else if (fPlane==5 && fStrip==19) hAdc[3]->Fill(fChargeAdc);

      if (fChargeAdc>2500 && fPlane>0){
        MSG("CDAnalysis",Msg::kInfo)
          <<"e="<<event<<", adc="<<fChargeAdc<<endl;
      

      //fill histos
      hPlane->Fill(fPlane);
      hStrip->Fill(fStrip);
      pStVsPlSigCor->Fill(fPlane,fStrip,fChargeMip);
      pStVsPlAdc->Fill(fPlane,fStrip,fChargeAdc);
      hStVsPlNum->Fill(fPlane,fStrip,1);
      }
    }
    //end of loop over the tracked hits

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);

  cGeom->cd(4);

  TCanvas *cAdc=new TCanvas("cAdc","Adc",0,0,1200,800);
  cAdc->SetFillColor(0);
  cAdc->Divide(2,2);
  cAdc->cd(1);
  hAdc[0]->Draw();
  cAdc->cd(2);
  hAdc[1]->Draw();
  cAdc->cd(3);
  hAdc[2]->Draw();
  cAdc->cd(4);
  hAdc[3]->Draw();

  TCanvas *cStVsPlSigCor=new TCanvas("cStVsPlSigCor","StVsPlSigCor",
                                    0,0,1200,800);
  cStVsPlSigCor->SetFillColor(0);
  pStVsPlSigCor->Draw("colz");

  TCanvas *cStVsPlAdc=new TCanvas("cStVsPlAdc","StVsPlAdc",
                                    0,0,1200,800);
  cStVsPlAdc->SetFillColor(0);
  pStVsPlAdc->Draw("colz");

  TCanvas *cStVsPlNum=new TCanvas("cStVsPlNum","StVsPlNum",
                                  0,0,1200,800);
  cStVsPlNum->SetFillColor(0);
  hStVsPlNum->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished MuonStVsPl method **"<<endl;
}

//......................................................................

void CDAnalysis::Template2()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running Template2 method... **"<<endl;

  map<Int_t,Int_t> numPlanesHit;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;
    if (this->CutOnPid()) continue;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
          
    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=
        dynamic_cast<CDXTalkHitInfo*>(cXTalk[hit]);

      this->ReadInHitInfo(hitInfo);
      
      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //cut out the bad channels
      if (this->CutOnBadPedestals(fPlane,fStrip,fStripend)) continue;

      //check the channel's sanity
      this->StandardSanityChecks();

      if (fPlane<fFirstPlane) fFirstPlane=fPlane;
      if (fPlane>fLastPlane) fLastPlane=fPlane;
      if (fPlane>fLastPlaneOdd && fPlane%2!=0) fLastPlaneOdd=fPlane;
      if (fPlane>fLastPlaneEven && fPlane%2==0) fLastPlaneEven=fPlane;

      //count the number of planes hit
      numPlanesHit[fPlane]++;

    }
    //end of loop over the tracked hits

    //check that a first plane was actually found
    if (fFirstPlane<0 || fFirstPlane>59) continue;

    //make cuts
    if (numPlanesHit.size()<40) continue;
    if (fFirstPlane<0 || fFirstPlane>59) continue;
    if (fLastPlane>57) continue;//cut out through going muons, no 58,59

  }


  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished Template2 method **"<<endl;
}

//......................................................................
 
string CDAnalysis::Pct(Double_t top,Double_t bottom) const
{
  Double_t percent=-1;
  string sPercent="notset";
  if (bottom!=0){
    percent=top/bottom;
    percent*=100;
    sPercent=Form("%.1f",percent);
  }
  else{
    sPercent="fpe!";
  }
  return sPercent;
}

//......................................................................

Double_t CDAnalysis::dE_dxIterative(MuEnergyLoss& mat,
                                    Double_t energyRemaining,
                                    Double_t totalThk,Double_t rho,
                                    Double_t energyCutOff,
                                    Int_t slices) const
{

  Double_t totalEnergyDeposited=0;
  Double_t sliceThk=totalThk/slices;

  for (Int_t s=0;s<slices;s++){

    if (energyRemaining<energyCutOff){
      MSG("CDAnalysis",Msg::kInfo) 
        <<"All energy lost at slice "<<s+1<<"/"<<slices
        <<" ("<<100.*s*sliceThk/totalThk<<"% through material)"<<endl;
      return -1;
    }

    //calculate energy deposited in the slice
    //Double_t energyDeposited=mat.dE_dx(energyRemaining)*rho*sliceThk;
    double e=energyRemaining;
    Double_t energyDeposited=mat.dE_dx
      (e,Process::eIonization)*rho*sliceThk;
    totalEnergyDeposited+=energyDeposited;

    //increment the energy remaining
    energyRemaining-=energyDeposited;
  }

  return totalEnergyDeposited;
}

//......................................................................
 
void CDAnalysis::Bb() const
{
  Float_t sum15_18=0;
  Float_t sum15_18Sc=0;
  Float_t av15PlanesSc=0;
  Float_t avPlanes0to14Sc=0;
  Float_t sum15_18Counter=0;
  vector<Double_t> eDepositedPl;
 
  //create simpleMC object
  CDSimpleMC mc;
  mc.SetThkFe(2.54);
  mc.SetParticleMomentum(5000);
  //run mc
  mc.RunMC();
  //get ratios too
  mc.CalcRatioScToFe();
  /*
//2.5
Using pl=0 in my extra special window, endep=2.00385
Using pl=1 in my extra special window, endep=1.99883
Using pl=2 in my extra special window, endep=1.99371
Using pl=3 in my extra special window, endep=1.98848
Using pl=4 in my extra special window, endep=1.98315
Using pl=5 in my extra special window, endep=1.97771
Using pl=6 in my extra special window, endep=1.97217
Using pl=7 in my extra special window, endep=1.96654
Using pl=8 in my extra special window, endep=1.96082
Using pl=9 in my extra special window, endep=1.95502
Using pl=10 in my extra special window, endep=1.94916
Using pl=11 in my extra special window, endep=1.94325
Using pl=12 in my extra special window, endep=1.93733
Using pl=13 in my extra special window, endep=1.93142
Using pl=14 in my extra special window, endep=1.92558

  //2.54
 Using pl=0 in my extra special window, endep=2.00385
Using pl=1 in my extra special window, endep=1.99876
Using pl=2 in my extra special window, endep=1.99355
Using pl=3 in my extra special window, endep=1.98824
Using pl=4 in my extra special window, endep=1.98283
Using pl=5 in my extra special window, endep=1.9773
Using pl=6 in my extra special window, endep=1.97168
Using pl=7 in my extra special window, endep=1.96595
Using pl=8 in my extra special window, endep=1.96014
Using pl=9 in my extra special window, endep=1.95425
Using pl=10 in my extra special window, endep=1.94829
Using pl=11 in my extra special window, endep=1.94229
Using pl=12 in my extra special window, endep=1.93628
Using pl=13 in my extra special window, endep=1.93029
Using pl=14 in my extra special window, endep=1.92439

//2.5
Using pl=17 in my special window, endep=2.0194
Using pl=18 in my special window, endep=2.01471
Using pl=19 in my special window, endep=2.00992
Using pl=20 in my special window, endep=2.00503
Using pl=21 in my special window, endep=2.00004
Using pl=22 in my special window, endep=1.99494
Using pl=23 in my special window, endep=1.98973
Using pl=24 in my special window, endep=1.98442
Using pl=25 in my special window, endep=1.97901
Using pl=26 in my special window, endep=1.9735
Using pl=27 in my special window, endep=1.96789
Using pl=28 in my special window, endep=1.96219
Using pl=29 in my special window, endep=1.95641
Using pl=30 in my special window, endep=1.95056
Using pl=31 in my special window, endep=1.94466

//2.54
Using pl=17 in my special window, endep=2.01823
Using pl=18 in my special window, endep=2.01345
Using pl=19 in my special window, endep=2.00856
Using pl=20 in my special window, endep=2.00357
Using pl=21 in my special window, endep=1.99847
Using pl=22 in my special window, endep=1.99326
Using pl=23 in my special window, endep=1.98794
Using pl=24 in my special window, endep=1.98252
Using pl=25 in my special window, endep=1.97699
Using pl=26 in my special window, endep=1.97136
Using pl=27 in my special window, endep=1.96563
Using pl=28 in my special window, endep=1.95981
Using pl=29 in my special window, endep=1.95391
Using pl=30 in my special window, endep=1.94795
Using pl=31 in my special window, endep=1.94195
  */



  for (UInt_t i=0;i<mc.fEnScDeposited.size();i++){
    if (i<=14){
      MSG("CDAnalysis",Msg::kInfo)
        <<"Using pl="<<i<<" in my extra special window, endep="
        <<mc.fEnScDeposited[i]<<endl; 
      avPlanes0to14Sc+=mc.fEnScDeposited[i];
    }

    if (i>=17 && i<=31){
      MSG("CDAnalysis",Msg::kInfo)
        <<"Using pl="<<i<<" in my special window, endep="
        <<mc.fEnScDeposited[i]<<endl; 
      av15PlanesSc+=mc.fEnScDeposited[i];
    }
  }
  //calc the average
  av15PlanesSc/=15;
  avPlanes0to14Sc/=15;
  MSG("CDAnalysis",Msg::kInfo)
    <<"Average scint en. dep. for planes 17-31 inclusive="
    <<av15PlanesSc<<endl
    <<"Average scint en. dep. for planes 0-14 inclusive="
    <<avPlanes0to14Sc<<endl;
  
  //section for sliding window
  
  vector<TProfile*> pSigCorVsDist;
  vector<Int_t> vWindowSize;
  vector<Float_t> bigAv;
  vector<Int_t> bigAvCounter;
  Int_t minEventLength=40;

  //need a new vector for this!!!!
  MSG("CDAnalysis",Msg::kInfo) 
    <<"size="<<mc.fEnScDeposited.size()<<endl;

  //initialise the profile histos
  for (Int_t p=20;p>1;p--){
    vWindowSize.push_back(p);
    bigAv.push_back(0);
    bigAvCounter.push_back(0);
  }
  
  for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
       windowSize!=vWindowSize.end();++windowSize){
    
    string sName=Form("%d",*windowSize);
    pSigCorVsDist.push_back
      (new TProfile(("pSigCorVsDist"+sName).c_str(),
                    ("pSigCorVsDist"+sName).c_str(),100,-2,40));
  }

  vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
  vector<Float_t>::iterator av=bigAv.begin();
  vector<Int_t>::iterator count=bigAvCounter.begin();
  
  //loop over the different window sizes
  for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
       windowSize!=vWindowSize.end();++windowSize){
    MSG("CDAnalysis",Msg::kDebug)
      <<"Window size="<<*windowSize<<endl;
 
    //slide the window along from the end to 40-windowSize
    for (Int_t p=0;p<minEventLength-*windowSize;p++){
      Int_t lastPlane=mc.fEnScDeposited.size()-1;
      Int_t windowStart=lastPlane-p;

      //loop through the hits in the window      
      for (Int_t i=0;i<*windowSize;i++){
        Int_t plane=windowStart-i;
        
        (*prof)->Fill(p,mc.fEnScDeposited[plane]);
        (*av)+=mc.fEnScDeposited[plane];
        (*count)++;

        //calculate the best window value
        if (*windowSize==15 && windowStart==lastPlane-18){
          MSG("CDAnalysis",Msg::kInfo)
            <<"Using pl="<<plane<<" in window"<<endl;
          sum15_18+=mc.fEnDepositedPl[plane];
          sum15_18Sc+=mc.fEnScDeposited[plane];
          sum15_18Counter++;
        }
      }

      

    }
    av++;
    count++;
    prof++;
  }

  //turn on the stats box printing
  gStyle->SetOptStat(11);

  TCanvas *cProf=new TCanvas("cProf","Prof",0,0,1200,800);
  cProf->SetFillColor(0);
  string sName="SlidingWindowBB.ps";
  cProf->Print((sName+"[").c_str());
  gErrorIgnoreLevel=1;
  //plot the unnormalised prof first
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Energy Deposited in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Energy Deposited (MeV)");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
  }

  //now normalise the prof
  av=bigAv.begin();
  count=bigAvCounter.begin();
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){
      
    //normalise the prof and scale the axes
    MSG("CDAnalysis",Msg::kInfo)
      <<"bigCounter="<<*count<<", bigAv="<<*av<<endl;
    if (*av>0) (*prof)->Scale((*count)/(*av));
    (*prof)->SetMaximum(1.2);
    (*prof)->SetMinimum(0.8);
      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Normalised Energy Deposited in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Normalised Energy Deposited");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
    av++;
    count++;
  }
  //close the file
  gErrorIgnoreLevel=0;
  cProf->Print((sName+"]").c_str());

  TLegend *legend = new TLegend(0.85, 0.7, 0.9, 0.9);
  legend->SetBorderSize(0);
  legend->SetFillColor(0);
  legend->SetTextSize(0.035);

  //now do a few profs on the same plot
  TCanvas *cProf2=new TCanvas("cProf2","Prof",0,0,1200,800);
  cProf2->SetFillColor(0);
  sName="SlidingWindowAll.ps";
  //cProf2->Print((sName+"[").c_str());
  Int_t counter=0;
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){

    (*prof)->SetMaximum(1.09);
    (*prof)->SetMinimum(0.96);

    //count which prof got to
    counter++;

    //decide which profs to draw
    static Bool_t firstTime=true;
    if (counter==1 || counter==6 || counter==11){ 
      if (firstTime) {
        (*prof)->Draw();
        firstTime=false;
      }
      else  (*prof)->Draw("sames");

      (*prof)->SetTitle("Normalised Energy Deposited in Sliding Window");
      (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
      (*prof)->GetYaxis()->SetTitle("Normalised Energy Deposition");
      (*prof)->GetXaxis()->CenterTitle();
      (*prof)->GetYaxis()->CenterTitle();
      static Int_t color=2;
      (*prof)->SetLineColor(color);
      color+=2;
      string sWindowSize=Form("%d",21-counter);
      string sGraph=" Window size = ";
      sGraph+=sWindowSize;
      sGraph+=" planes";
      legend->AddEntry((*prof),sGraph.c_str(),"l");
    }
  }
  legend->Draw();

  this->FlipVector(mc.fXScPlanes);
  TGraph* eLossSc=TGraphVect(mc.fXScPlanes,mc.fEnScDeposited);
  TCanvas *cELossSc=new TCanvas("cELossSc","ELossSc",
                                   0,0,1200,800);
  cELossSc->SetFillColor(0);
  eLossSc->Draw("AP");
  eLossSc->SetTitle("Energy Loss in Scintillator");
  eLossSc->GetXaxis()->SetTitle("Distance from end of track (planes)");
  eLossSc->GetYaxis()->SetTitle("Energy Loss (MeV)");
  eLossSc->GetXaxis()->CenterTitle();
  eLossSc->GetYaxis()->CenterTitle();
  eLossSc->SetMarkerStyle(3);
  eLossSc->SetMarkerColor(2);
  eLossSc->SetMarkerSize(0.8);

  this->FlipVector(mc.fX);
  TGraph* energyLoss=TGraphVect(mc.fX,mc.fEnDeposited);
  TCanvas *cEnergyLoss=new TCanvas("cEnergyLoss","EnergyLoss",
                                   0,0,1200,800);
  cEnergyLoss->SetFillColor(0);
  energyLoss->Draw("AP");
  energyLoss->SetTitle("Energy Loss in Scintillator and Iron");
  energyLoss->GetXaxis()->SetTitle("Distance from end of track (cm)");
  energyLoss->GetYaxis()->SetTitle("Energy Loss (MeV)");
  energyLoss->GetXaxis()->CenterTitle();
  energyLoss->GetYaxis()->CenterTitle();
  energyLoss->SetMarkerStyle(3);
  energyLoss->SetMarkerColor(2);
  energyLoss->SetMarkerSize(0.8);

  this->FlipVector(mc.fXPlanes);
  TGraph* energyloss2=TGraphVect(mc.fXPlanes,mc.fEnDeposited);
  TCanvas *cEnergyloss2=new TCanvas("cEnergyloss2","Energyloss2",
                                   0,0,1200,800);
  cEnergyloss2->SetFillColor(0);
  energyloss2->Draw("AP");
  energyloss2->SetTitle("Energy Loss in Scintillator and Iron");
  energyloss2->GetXaxis()->SetTitle("Distance from end of track (planes)");
  energyloss2->GetYaxis()->SetTitle("Energy Loss (MeV)");
  energyloss2->GetXaxis()->CenterTitle();
  energyloss2->GetYaxis()->CenterTitle();
  energyloss2->SetMarkerStyle(3);
  energyloss2->SetMarkerColor(2);
  energyloss2->SetMarkerSize(0.8);

  this->FlipVector(mc.fXFe);
  TGraph* gXFevsEn=TGraphVect(mc.fXFe,mc.fEnFeDeposited);
  this->FlipVector(mc.fXSc);
  TGraph* gXScvsEn=TGraphVect(mc.fXSc,mc.fEnScDeposited);
  this->FlipVector(mc.fXAlx2);
  TGraph* gXAlx2vsEn=TGraphVect(mc.fXAlx2,mc.fEnAlx2Deposited);
  this->FlipVector(mc.fXTiO2x2);
  TGraph* gXTiO2x2vsEn=TGraphVect(mc.fXTiO2x2,mc.fEnTiO2x2Deposited);
  TCanvas *cEnergyloss3=new TCanvas("cEnergyloss3","Energyloss3",
                                    0,0,1200,800);
  cEnergyloss3->SetFillColor(0);
  cEnergyloss3->Divide(2,1);
  cEnergyloss3->cd(1);
  gXFevsEn->Draw("AP");
  gXFevsEn->SetTitle("Energy Loss in Iron");
  gXFevsEn->GetXaxis()->SetTitle("Distance from end of track (cm)");
  gXFevsEn->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gXFevsEn->GetXaxis()->CenterTitle();
  gXFevsEn->GetYaxis()->CenterTitle();
  gXFevsEn->SetMarkerStyle(3);
  gXFevsEn->SetMarkerColor(2);
  gXFevsEn->SetMarkerSize(0.8);
  gXFevsEn->SetMinimum(0.00001);
  gXFevsEn->SetMaximum(50);

  gXScvsEn->Draw("P");
  gXScvsEn->SetTitle("Energy Loss in Scintillator");
  gXScvsEn->GetXaxis()->SetTitle("Distance from end of track (cm)");
  gXScvsEn->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gXScvsEn->GetXaxis()->CenterTitle();
  gXScvsEn->GetYaxis()->CenterTitle();
  gXScvsEn->SetMarkerStyle(3);
  gXScvsEn->SetMarkerColor(3);
  gXScvsEn->SetMarkerSize(0.8);

  gXAlx2vsEn->Draw("P");
  gXAlx2vsEn->SetTitle("Energy Loss in Aluminium");
  gXAlx2vsEn->GetXaxis()->SetTitle("Distance from end of track (cm)");
  gXAlx2vsEn->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gXAlx2vsEn->GetXaxis()->CenterTitle();
  gXAlx2vsEn->GetYaxis()->CenterTitle();
  gXAlx2vsEn->SetMarkerStyle(3);
  gXAlx2vsEn->SetMarkerColor(4);
  gXAlx2vsEn->SetMarkerSize(0.8);

  gXTiO2x2vsEn->Draw("P");
  gXTiO2x2vsEn->SetTitle("Energy Loss in TiO2");
  gXTiO2x2vsEn->GetXaxis()->SetTitle("Distance from end of track (cm)");
  gXTiO2x2vsEn->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gXTiO2x2vsEn->GetXaxis()->CenterTitle();
  gXTiO2x2vsEn->GetYaxis()->CenterTitle();
  gXTiO2x2vsEn->SetMarkerStyle(3);
  gXTiO2x2vsEn->SetMarkerColor(6);
  gXTiO2x2vsEn->SetMarkerSize(0.8);
  cEnergyloss3->SetLogy();
  
  cEnergyloss3->cd(2);
  TGraph* gXScvsEn2=TGraphVect(mc.fXSc,mc.fEnScDeposited);
  gXScvsEn2->Draw("AP");
  gXScvsEn2->SetTitle("Energy Loss in Scintillator");
  gXScvsEn2->GetXaxis()->SetTitle("Distance from end of track (cm)");
  gXScvsEn2->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gXScvsEn2->GetXaxis()->CenterTitle();
  gXScvsEn2->GetYaxis()->CenterTitle();
  gXScvsEn2->SetMarkerStyle(3);
  gXScvsEn2->SetMarkerColor(3);
  gXScvsEn2->SetMarkerSize(0.8);

  TGraph* bbFe=TGraphVect(mc.fEn,mc.fdE_dxFe);
  //TGraph* bbAl=TGraphVect(mc.fEn,mc.fdE_dxAl);
  TGraph* bbSc=TGraphVect(mc.fEn,mc.fdE_dxSc);
  TGraph* bbSc2=TGraphVect(mc.fMomGeV,mc.fdE_dxSc);
  TGraph* bbSc3=TGraphVect(mc.fMomScGeV,mc.fEnScDeposited);
  TGraph* bbMomVsRange=TGraphVect(mc.fXSc,mc.fMomSc);
  TCanvas *cBb=new TCanvas("cBb","Bb",0,0,1200,800);
  cBb->SetFillColor(0);
  cBb->Divide(2,2);
  cBb->cd(1);
  bbFe->Draw("AP");
  bbFe->SetTitle("dE/dx in Iron");
  bbFe->GetXaxis()->SetTitle("Particle Energy");
  bbFe->GetYaxis()->SetTitle("dE/dx MeV/(g/cm2)");
  bbFe->GetXaxis()->CenterTitle();
  bbFe->GetYaxis()->CenterTitle();
  bbFe->SetMarkerStyle(3);
  bbFe->SetMarkerColor(2);
  bbFe->SetMarkerSize(0.8);
  cBb->cd(2);
  bbMomVsRange->Draw("AP");
  bbMomVsRange->SetTitle("Muom Momentum vs Range");
  bbMomVsRange->GetXaxis()->SetTitle("Range (cm)");
  bbMomVsRange->GetYaxis()->SetTitle("Muon Momentum (MeV/c)");
  bbMomVsRange->GetXaxis()->CenterTitle();
  bbMomVsRange->GetYaxis()->CenterTitle();
  bbMomVsRange->SetMarkerStyle(3);
  bbMomVsRange->SetMarkerColor(2);
  bbMomVsRange->SetMarkerSize(0.8);
      /*
  bbAl->Draw("AP");
  bbAl->SetTitle("dE/dx in Aluminium");
  bbAl->GetXaxis()->SetTitle("Particle Energy");
  bbAl->GetYaxis()->SetTitle("dE/dx MeV/(g/cm2)");
  bbAl->GetXaxis()->CenterTitle();
  bbAl->GetYaxis()->CenterTitle();
  bbAl->SetMarkerStyle(3);
  bbAl->SetMarkerColor(2);
  bbAl->SetMarkerSize(0.8);
      */
  cBb->cd(3);
  bbSc->Draw("AP");
  bbSc->SetTitle("dE/dx in Scintillator");
  bbSc->GetXaxis()->SetTitle("Particle Energy");
  bbSc->GetYaxis()->SetTitle("dE/dx MeV/(g/cm2)");
  bbSc->GetXaxis()->CenterTitle();
  bbSc->GetYaxis()->CenterTitle();
  bbSc->SetMarkerStyle(3);
  bbSc->SetMarkerColor(2);
  bbSc->SetMarkerSize(0.8);
  cBb->cd(4);
  bbSc2->Draw("AP");
  bbSc2->SetTitle("Bethe-Bloch Curve in Scintillator");
  bbSc2->GetXaxis()->SetTitle("Muon Momentum");
  bbSc2->GetYaxis()->SetTitle("dE/dx MeV/(g/cm2)");
  bbSc2->GetXaxis()->CenterTitle();
  bbSc2->GetYaxis()->CenterTitle();
  bbSc2->SetMarkerStyle(3);
  bbSc2->SetMarkerColor(2);
  bbSc2->SetMarkerSize(0.8);
  bbSc3->Draw("P");
  bbSc3->SetMarkerStyle(8);
  bbSc3->SetMarkerColor(3);

  this->FlipVector(mc.fXPlanesRatio);
  TGraph* eLossRatio=TGraphVect(mc.fXPlanesRatio,mc.fEnRatio);
  TCanvas *cELossRatio=new TCanvas("cELossRatio","ELossRatio",
                                   0,0,1200,800);
  cELossRatio->SetFillColor(0);
  eLossRatio->Draw("AP");
  eLossRatio->SetTitle("Energy Loss Ratio Fe/Scint");
  eLossRatio->GetXaxis()->SetTitle("Distance from end of track (planes)");
  eLossRatio->GetYaxis()->SetTitle("Energy Loss Ratio Fe/Scint");
  eLossRatio->GetXaxis()->CenterTitle();
  eLossRatio->GetYaxis()->CenterTitle();
  eLossRatio->SetMarkerStyle(3);
  eLossRatio->SetMarkerColor(2);
  eLossRatio->SetMarkerSize(0.8);

  if (sum15_18Counter!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** Calibration Summary **"<<endl
      <<"Sliding Window 15_18:"<<endl
      <<"    Total energy dep in scint and Fe="<<sum15_18<<endl
      <<"    Av total energy dep in scint and Fe="
      <<sum15_18/sum15_18Counter<<" MeV"
      <<endl
      <<"    Total energy dep in just scint="<<sum15_18Sc<<endl
      <<"    Av total energy dep in just scint="
      <<sum15_18Sc/sum15_18Counter<<" MeV"
      <<endl;
  }

  Double_t totPlanesHit=mc.GetTotalNumScPlanesHit();
  MSG("CDAnalysis",Msg::kInfo) 
    <<"Total number planes hit="<<totPlanesHit<<endl;
}

//......................................................................
 
void CDAnalysis::BbVsGminos()
{
  //create simpleMC object
  CDSimpleMC mc;
  //run mc
  mc.RunMC();

  Float_t sum15_18=0;
  Float_t sum15_18Sc=0;
  Float_t sum15_18NotSc=0;
  Float_t sum15_18All=0;
  Float_t sum15_18ScGminos=0;
  Float_t sum15_18NotScGminos=0;
  Float_t sum15_18AllGminos=0;
  Float_t sum15_18Counter=0;
  vector<Double_t> eDepositedPl;

  vector<Double_t> tempEnDep(60,0);
  vector<Double_t> tempEnDepNotSc(60,0);
  vector<Double_t> tempNumDsh(60,0);
  vector<Double_t> tempNum(60,0);
  vector<TH1F*> hEnDepNotSc;

  for (Int_t pl=0;pl<60;pl++){
    fS="Energy Deposition in Iron, plane=";
    string sPl=Form("%d",pl);
    fS+=sPl;
    hEnDepNotSc.push_back(new TH1F(fS.c_str(),fS.c_str(),600,-2,200));
    hEnDepNotSc[pl]->SetBit(TH1::kCanRebin);
  }


  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //cut on not straight tracks
    Double_t mainX1Cut=0.5;
    if (!this->IsStraightTrack(mainX1Cut)){
      continue;
    }

    for (Int_t p=0;p<60;p++){
      Double_t enDep=this->TrueEnDep(p,event);
      Double_t enDepNotSc=this->TrueEnDepNotSc(p,event);
      Int_t numDsh=this->TrueNumDigiScintHits(p,event);
      //const Double_t latestT2=hitInfo->GetLatestT2();
      //fill the histo
      hEnDepNotSc[p]->Fill(1000*enDepNotSc);
      
      MSG("CDAnalysis",Msg::kVerbose) 
        <<", eDepNotSc="<<1000*enDepNotSc<<endl;
      
      //I'm not averaging zeros here - this is wrong!
      if (enDep>0 && enDepNotSc>0){
        tempEnDep[p]+=enDep;
        tempEnDepNotSc[p]+=enDepNotSc;
        tempNumDsh[p]+=numDsh;
        tempNum[p]++;
      }
    }
  }//end of for                                       
  

  TCanvas *cEnDep=new TCanvas("cEnDep","EnDep",0,0,1200,800);
  cEnDep->SetFillColor(0);
  cEnDep->Divide(2,3);
  cEnDep->cd(1);
  hEnDepNotSc[0]->Draw();
  cEnDep->cd(2);
  hEnDepNotSc[1]->Draw();
  cEnDep->cd(3);
  hEnDepNotSc[2]->Draw();
  cEnDep->cd(4);
  hEnDepNotSc[3]->Draw();
  cEnDep->cd(5);
  hEnDepNotSc[4]->Draw();
  cEnDep->cd(6);
  hEnDepNotSc[5]->Draw();

  vector<Double_t> eScGminos(60,0);
  vector<Double_t> eNotScGminos(60,0);
  vector<Double_t> numDshScGminos(60,0);
  vector<Double_t> xScGminos(60,0);
  Double_t totalEnDep=0;

  for (Int_t p=0;p<60;p++){
    if (tempNum[p]>0){
      eScGminos[p]=1000.*tempEnDep[p]/tempNum[p];
      eNotScGminos[p]=1000.*tempEnDepNotSc[p]/tempNum[p];
      numDshScGminos[p]=tempNumDsh[p]/tempNum[p];
    }
    xScGminos[p]=p;

    //keep a running total
    totalEnDep+=eScGminos[p]+eNotScGminos[p];

    MSG("CDAnalysis",Msg::kInfo) 
      <<"plane="<<xScGminos[p]
      <<", enDep="<<eScGminos[p]
      <<", enDepNotSc="<<eNotScGminos[p]
      <<", totalEnDep="<<totalEnDep<<endl;
  }

  //section for sliding window
  
  vector<TProfile*> pSigCorVsDist;
  vector<Int_t> vWindowSize;
  vector<Float_t> bigAv;
  vector<Int_t> bigAvCounter;
  Int_t minEventLength=40;

  //need a new vector for this!!!!
  MSG("CDAnalysis",Msg::kInfo) 
    <<"size="<<mc.fEnScDeposited.size()<<endl;

  //initialise the profile histos
  for (Int_t p=20;p>1;p--){
    vWindowSize.push_back(p);
    bigAv.push_back(0);
    bigAvCounter.push_back(0);
  }
  
  for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
       windowSize!=vWindowSize.end();++windowSize){
    
    string sName=Form("%d",*windowSize);
    pSigCorVsDist.push_back
      (new TProfile(("pSigCorVsDist"+sName).c_str(),
                    ("pSigCorVsDist"+sName).c_str(),100,-2,40));
  }

  vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
  vector<Float_t>::iterator av=bigAv.begin();
  vector<Int_t>::iterator count=bigAvCounter.begin();
  
  //loop over the different window sizes
  for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
       windowSize!=vWindowSize.end();++windowSize){
    MSG("CDAnalysis",Msg::kDebug)
      <<"Window size="<<*windowSize<<endl;
 
    //slide the window along from the end to 40-windowSize
    for (Int_t p=0;p<minEventLength-*windowSize;p++){
      Int_t lastPlane=mc.fEnScDeposited.size()-1;
      Int_t windowStart=lastPlane-p;

      //loop through the hits in the window      
      for (Int_t i=0;i<*windowSize;i++){
        Int_t plane=windowStart-i;
        
        (*prof)->Fill(p,mc.fEnScDeposited[plane]);
        (*av)+=mc.fEnScDeposited[plane];
        (*count)++;

        //calculate the best window value
        if (*windowSize==15 && windowStart==lastPlane-18){
          //BB
          sum15_18+=mc.fEnDepositedPl[plane];
          sum15_18Sc+=mc.fEnScDeposited[plane];
          sum15_18NotSc+=mc.fEnNotScDeposited[plane];
          sum15_18All+=mc.fEnScDeposited[plane]+
            mc.fEnNotScDeposited[plane];

          //gminos
          sum15_18ScGminos+=eScGminos[plane];
          sum15_18NotScGminos+=eNotScGminos[plane];
          sum15_18AllGminos+=eScGminos[plane]+eNotScGminos[plane];

          //general counter
          sum15_18Counter++;
        }
      }
    }
    av++;
    count++;
    prof++;
  }

  //turn on the stats box printing
  gStyle->SetOptStat(11);

  TCanvas *cProf=new TCanvas("cProf","Prof",0,0,1200,800);
  cProf->SetFillColor(0);
  string sName="SlidingWindowBB.ps";
  cProf->Print((sName+"[").c_str());
  gErrorIgnoreLevel=1;
  //plot the unnormalised prof first
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Energy Deposited in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Energy Deposited (MeV)");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
  }

  //now normalise the prof
  av=bigAv.begin();
  count=bigAvCounter.begin();
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){
      
    //normalise the prof and scale the axes
    MSG("CDAnalysis",Msg::kInfo)
      <<"bigCounter="<<*count<<", bigAv="<<*av<<endl;
    if (*av>0) (*prof)->Scale((*count)/(*av));
    (*prof)->SetMaximum(1.2);
    (*prof)->SetMinimum(0.8);
      
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Normalised Energy Deposited in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Normalised Energy Deposited");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
    av++;
    count++;
  }
  //close the file
  gErrorIgnoreLevel=0;
  cProf->Print((sName+"]").c_str());

  TLegend *legend = new TLegend(0.85, 0.7, 0.9, 0.9);
  legend->SetBorderSize(0);
  legend->SetFillColor(0);
  legend->SetTextSize(0.035);

  //now do a few profs on the same plot
  TCanvas *cProf2=new TCanvas("cProf2","Prof",0,0,1200,800);
  cProf2->SetFillColor(0);
  sName="SlidingWindowAll.ps";
  //cProf2->Print((sName+"[").c_str());
  Int_t counter=0;
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){

    (*prof)->SetMaximum(1.09);
    (*prof)->SetMinimum(0.96);

    //count which prof got to
    counter++;

    //decide which profs to draw
    static Bool_t firstTime=true;
    if (counter==1 || counter==6 || counter==11){ 
      if (firstTime) {
        (*prof)->Draw();
        firstTime=false;
      }
      else  (*prof)->Draw("sames");

      (*prof)->SetTitle("Normalised Energy Deposited in Sliding Window");
      (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
      (*prof)->GetYaxis()->SetTitle("Normalised Energy Deposition");
      (*prof)->GetXaxis()->CenterTitle();
      (*prof)->GetYaxis()->CenterTitle();
      static Int_t color=2;
      (*prof)->SetLineColor(color);
      color+=2;
      string sWindowSize=Form("%d",21-counter);
      string sGraph=" Window size = ";
      sGraph+=sWindowSize;
      sGraph+=" planes";
      legend->AddEntry((*prof),sGraph.c_str(),"l");
    }
  }
  legend->Draw();

  //get the graphs
  TGraph* gScBb=TGraphVect(mc.fXScPlanes,mc.fEnScDeposited);
  TGraph* gScGminos=TGraphVect(xScGminos,eScGminos);
  TGraph* gNumDshScGminos=TGraphVect(xScGminos,numDshScGminos);
  
  //get canvas
  TCanvas *cBbVsGminos=new TCanvas("cBbVsGminos","BbVsGminos",
                                   0,0,1200,800);
  cBbVsGminos->SetFillColor(0);
  cBbVsGminos->Divide(1,3);
  cBbVsGminos->cd(1);
  gScBb->Draw("AP");
  gScBb->SetTitle("Energy Loss in Simple BB MC");
  gScBb->GetXaxis()->SetTitle("Plane");
  gScBb->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gScBb->GetXaxis()->CenterTitle();
  gScBb->GetYaxis()->CenterTitle();
  gScBb->SetMarkerStyle(3);
  gScBb->SetMarkerColor(2);
  gScBb->SetMarkerSize(0.8);
  cBbVsGminos->cd(2);
  gScGminos->Draw("AP");
  gScGminos->SetTitle("Energy Loss in GMINOS");
  gScGminos->GetXaxis()->SetTitle("Plane");
  gScGminos->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gScGminos->GetXaxis()->CenterTitle();
  gScGminos->GetYaxis()->CenterTitle();
  gScGminos->SetMarkerStyle(3);
  gScGminos->SetMarkerColor(2);
  gScGminos->SetMarkerSize(0.8);
  cBbVsGminos->cd(3);
  gNumDshScGminos->Draw("AP");
  gNumDshScGminos->SetTitle("Num DigiScintHits in GMINOS");
  gNumDshScGminos->GetXaxis()->SetTitle("Plane");
  gNumDshScGminos->GetYaxis()->SetTitle("Num DigiScintHits");
  gNumDshScGminos->GetXaxis()->CenterTitle();
  gNumDshScGminos->GetYaxis()->CenterTitle();
  gNumDshScGminos->SetMarkerStyle(3);
  gNumDshScGminos->SetMarkerColor(2);
  gNumDshScGminos->SetMarkerSize(0.8);

  //new graph
  TGraph* gNotScBb=TGraphVect(mc.fXNotScPlanes,mc.fEnNotScDeposited);
  TGraph* gFeBb=TGraphVect(mc.fXFePlanes,mc.fEnFeDeposited);
  TGraph* gNotScGminos=TGraphVect(xScGminos,eNotScGminos);
  TCanvas *cBbVsGminos2=new TCanvas("cBbVsGminos2","BbVsGminos2",
                                    0,0,1200,800);
  cBbVsGminos2->SetFillColor(0);
  cBbVsGminos2->Divide(1,2);
  cBbVsGminos2->cd(1);
  gNotScBb->Draw("AP");
  gNotScBb->SetTitle("Energy Loss in Non-Acive Material in BB");
  gNotScBb->GetXaxis()->SetTitle("Plane");
  gNotScBb->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gNotScBb->GetXaxis()->CenterTitle();
  gNotScBb->GetYaxis()->CenterTitle();
  gNotScBb->SetMarkerStyle(3);
  gNotScBb->SetMarkerColor(2);
  gNotScBb->SetMarkerSize(0.8);
  gFeBb->Draw("P");
  gFeBb->SetMarkerStyle(3);
  gFeBb->SetMarkerColor(3);
  gFeBb->SetMarkerSize(0.8);
  cBbVsGminos2->cd(2);
  gNotScGminos->Draw("AP");
  gNotScGminos->SetTitle("Energy Loss in Non-Acive Material in GMINOS");
  gNotScGminos->GetXaxis()->SetTitle("Plane");
  gNotScGminos->GetYaxis()->SetTitle("Energy Loss (MeV)");
  gNotScGminos->GetXaxis()->CenterTitle();
  gNotScGminos->GetYaxis()->CenterTitle();
  gNotScGminos->SetMarkerStyle(3);
  gNotScGminos->SetMarkerColor(2);
  gNotScGminos->SetMarkerSize(0.8);

  //new graph
  this->FlipVector(mc.fXScPlanes);
  TGraph* eLossSc=TGraphVect(mc.fXScPlanes,mc.fEnScDeposited);
  TCanvas *cELossSc=new TCanvas("cELossSc","ELossSc",
                                   0,0,1200,800);
  cELossSc->SetFillColor(0);
  eLossSc->Draw("AP");
  eLossSc->SetTitle("Energy Loss in Scintillator");
  eLossSc->GetXaxis()->SetTitle("Distance from end of track (planes)");
  eLossSc->GetYaxis()->SetTitle("Energy Loss (MeV)");
  eLossSc->GetXaxis()->CenterTitle();
  eLossSc->GetYaxis()->CenterTitle();
  eLossSc->SetMarkerStyle(3);
  eLossSc->SetMarkerColor(2);
  eLossSc->SetMarkerSize(0.8);

  this->FlipVector(mc.fX);
  TGraph* energyLoss=TGraphVect(mc.fX,mc.fEnDeposited);
  TCanvas *cEnergyLoss=new TCanvas("cEnergyLoss","EnergyLoss",
                                   0,0,1200,800);
  cEnergyLoss->SetFillColor(0);
  energyLoss->Draw("AP");
  energyLoss->SetTitle("Energy Loss in Scintillator and Iron");
  energyLoss->GetXaxis()->SetTitle("Distance from end of track (cm)");
  energyLoss->GetYaxis()->SetTitle("Energy Loss (MeV)");
  energyLoss->GetXaxis()->CenterTitle();
  energyLoss->GetYaxis()->CenterTitle();
  energyLoss->SetMarkerStyle(3);
  energyLoss->SetMarkerColor(2);
  energyLoss->SetMarkerSize(0.8);

  this->FlipVector(mc.fXPlanes);
  TGraph* energyloss2=TGraphVect(mc.fXPlanes,mc.fEnDeposited);
  TCanvas *cEnergyloss2=new TCanvas("cEnergyloss2","Energyloss2",
                                   0,0,1200,800);
  cEnergyloss2->SetFillColor(0);
  energyloss2->Draw("AP");
  energyloss2->SetTitle("Energy Loss in Scintillator and Iron");
  energyloss2->GetXaxis()->SetTitle("Distance from end of track (planes)");
  energyloss2->GetYaxis()->SetTitle("Energy Loss (MeV)");
  energyloss2->GetXaxis()->CenterTitle();
  energyloss2->GetYaxis()->CenterTitle();
  energyloss2->SetMarkerStyle(3);
  energyloss2->SetMarkerColor(2);
  energyloss2->SetMarkerSize(0.8);
  
  TGraph* bb=TGraphVect(mc.fEn,mc.fdE_dxFe);
  TCanvas *cBb=new TCanvas("cBb","Bb",0,0,1200,800);
  cBb->SetFillColor(0);
  bb->Draw("AP");
  bb->SetMarkerStyle(3);
  bb->SetMarkerColor(2);
  bb->SetMarkerSize(0.8);

  if (sum15_18Counter!=0){
    MSG("CDAnalysis",Msg::kInfo) 
      <<endl
      <<" ** Calibration Summary **"<<endl
      <<"Total number of planes hit in BB="<<mc.GetTotalNumScPlanesHit()
      <<endl
      <<"Sliding Window 15_18:"<<endl
      <<"BB Steel and Scintillator:"<<endl
      <<"    Total energy dep="<<sum15_18<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18/sum15_18Counter
      <<" MeV"<<endl
      <<"GMINOS:"<<endl
      <<"    Total energy dep="<<"?"<<" MeV"<<endl
      <<"    Av energy dep="<<"?"
      <<" MeV"<<endl
      <<endl<<endl
      <<"BB Non-Active Material:"<<endl
      <<"    Total energy dep="<<sum15_18NotSc<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18NotSc/sum15_18Counter
      <<" MeV"<<endl
      <<"GMINOS:"<<endl
      <<"    Total energy dep="<<sum15_18NotScGminos<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18NotScGminos/sum15_18Counter
      <<" MeV ("<<100*(sum15_18NotScGminos-sum15_18NotSc)/sum15_18NotSc
      <<"%)"<<endl
      <<endl<<endl
      <<"BB Just Scintillator:"<<endl
      <<"    Total energy dep="<<sum15_18Sc<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18Sc/sum15_18Counter
      <<" MeV"<<endl
      <<"GMINOS:"<<endl
      <<"    Total energy dep="<<sum15_18ScGminos<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18ScGminos/sum15_18Counter
      <<" MeV ("<<100*(sum15_18ScGminos-sum15_18Sc)/sum15_18Sc<<"%)"
      <<endl
      <<endl<<endl
      <<"BB Total (Active+Passive):"<<endl
      <<"    Total energy dep="<<sum15_18All<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18All/sum15_18Counter
      <<" MeV"<<endl
      <<"GMINOS:"<<endl
      <<"    Total energy dep="<<sum15_18AllGminos<<" MeV"<<endl
      <<"    Av energy dep="<<sum15_18AllGminos/sum15_18Counter
      <<" MeV ("<<100*(sum15_18AllGminos-sum15_18All)/sum15_18All<<"%)"
      <<endl<<endl; 
  }
}

//......................................................................

//just a simple function for use with ROOT's TF1
Double_t FitFunc(Double_t *x,Double_t *par)
{
  return par[0]*pow(x[0],par[1])+par[2];
}

//......................................................................
 
void CDAnalysis::BbThkFeVsRange() const
{
  //create simpleMC object
  CDSimpleMC mc;

  vector<Double_t> vPlanesHit;
  vector<Double_t> vThkFe;

  //loop over the different energies
  for (Double_t thkFe=2.4;thkFe<2.6;thkFe+=0.01){
    MSG("CDAnalysis",Msg::kInfo) 
      <<"thkFe="<<thkFe<<endl;
    
    //set up and run the MC
    mc.SetThkFe(thkFe);
    mc.RunMC();
    
    //fill the vectors
    vThkFe.push_back(mc.GetThkFe());
    vPlanesHit.push_back(mc.GetTotalNumScPlanesHit());
  }

  TGraph* gThkFeVsRange=TGraphVect(vPlanesHit,vThkFe);
  TCanvas *cThkFeVsRange=new TCanvas("cThkFeVsRange","ThkFeVsRange",
                                     0,0,1200,800);
  cThkFeVsRange->SetFillColor(0);
  gThkFeVsRange->Draw("AP");
  gThkFeVsRange->SetTitle("Iron Thickness Vs Range");
  gThkFeVsRange->GetXaxis()->SetTitle("Range (planes)");
  gThkFeVsRange->GetYaxis()->SetTitle("Fe Thk (cm)");
  gThkFeVsRange->GetXaxis()->CenterTitle();
  gThkFeVsRange->GetYaxis()->CenterTitle();
  gThkFeVsRange->SetMarkerStyle(3);
  gThkFeVsRange->SetMarkerColor(2);
  gThkFeVsRange->SetMarkerSize(0.8);
}

//......................................................................
 
void CDAnalysis::BbEnVsRange() const
{
  //create simpleMC object
  CDSimpleMC mc;

  vector<Double_t> lastPlane;
  vector<Double_t> energyBeam;
  vector<Double_t> sumEnDepSc;
  vector<Double_t> ratioScToBeam;

  //loop over the different energies
  for (Int_t beamP=1400;beamP<2010;beamP+=10){
    MSG("CDAnalysis",Msg::kInfo) 
      <<"Beam P="<<beamP<<endl;
    
    //set up and run the MC
    mc.SetParticleMomentum(beamP);
    mc.RunMC();
    
    //fill the vectors
    energyBeam.push_back(mc.GetParticleEnergy());
    lastPlane.push_back(mc.GetTotalNumScPlanesHit());
    sumEnDepSc.push_back(mc.GetTotalScEnLoss());
    ratioScToBeam.push_back(mc.GetTotalScEnLoss()/
                            mc.GetParticleEnergy());
  }

  MSG("CDAnalysis",Msg::kDebug)
    <<"Vpl size="<<lastPlane.size()
    <<", Ven size="<<energyBeam.size()<<endl;
  TGraph* gEnBeamVsRange=TGraphVect(lastPlane,energyBeam);
  TCanvas *cEnBeamVsRange=new TCanvas("cEnBeamVsRange","EnBeamVsRange",
                                   0,0,1200,800);
  cEnBeamVsRange->SetFillColor(0);
  gEnBeamVsRange->Draw("AP");
  gEnBeamVsRange->SetTitle("Energy Vs Range");
  gEnBeamVsRange->GetXaxis()->SetTitle("Range (planes)");
  gEnBeamVsRange->GetYaxis()->SetTitle("Beam Energy");
  gEnBeamVsRange->GetXaxis()->CenterTitle();
  gEnBeamVsRange->GetYaxis()->CenterTitle();
  gEnBeamVsRange->SetMarkerStyle(3);
  gEnBeamVsRange->SetMarkerColor(2);
  gEnBeamVsRange->SetMarkerSize(0.8);

  TGraph* gScToBeamVsBeam=TGraphVect(energyBeam,ratioScToBeam);
  TCanvas *cScToBeamVsBeam=new TCanvas("cScToBeamVsBeam",
                                       "cScToBeamVsBeam",
                                       0,0,1200,800);
  cScToBeamVsBeam->SetFillColor(0);
  gScToBeamVsBeam->Draw("AP");
  gScToBeamVsBeam->SetTitle("Ratio Sc to Beam Energy vs Beam Energy");
  gScToBeamVsBeam->GetXaxis()->SetTitle("Beam Energy");
  gScToBeamVsBeam->GetYaxis()->SetTitle("Ratio Sc to Beam Energy");
  gScToBeamVsBeam->GetXaxis()->CenterTitle();
  gScToBeamVsBeam->GetYaxis()->CenterTitle();
  gScToBeamVsBeam->SetMarkerStyle(3);
  gScToBeamVsBeam->SetMarkerColor(2);
  gScToBeamVsBeam->SetMarkerSize(0.8);

  vector<Double_t> enRange;
  vector<Double_t> gradient;

  MSG("CDAnalysis",Msg::kInfo)
    <<"First fit..."<<endl;
  for (vector<Double_t>::iterator r=lastPlane.begin();
       r!=lastPlane.end()-3;++r){
    //for (Float_t fitRangeMin=lastPlane[0];
    // fitRangeMin<lastPlane[lastPlane.size()-3]-1;fitRangeMin++){
    static Int_t counter=0;
    
    gEnBeamVsRange->Fit("pol1","q","",*r,1000);
    TF1* func=gEnBeamVsRange->GetFunction("pol1");
    Double_t funcM=func->GetParameter(1);
    MSG("CDAnalysis",Msg::kInfo)
      <<"fitMin="<<*r<<", en="<<energyBeam[counter]
      <<", m="<<funcM<<endl;

    enRange.push_back(energyBeam[counter]);
    gradient.push_back(funcM);

    counter++;
  }

  //now fit to a non-straight line
  TF1 *form = new TF1("form",FitFunc,0,70,3);
  //par[0]*TMath::Power(x[0],par[1]) + par[2];
  form->SetParameters(1,1,0);
  gEnBeamVsRange->Fit("form","q");

  TGraph* gFitGradVsRange=TGraphVect(enRange,gradient);
  TCanvas *cFitGradVsRange=new TCanvas("cFitGradVsRange",
                                       "FitGradVsRange",
                                       0,0,1200,800);
  cFitGradVsRange->SetFillColor(0);
  gFitGradVsRange->Draw("AP");
  gFitGradVsRange->SetTitle("Fit Gradient Vs Min Beam Energy in Fit");
  gFitGradVsRange->GetXaxis()->SetTitle("Min Beam Energy in Fit");
  gFitGradVsRange->GetYaxis()->SetTitle("Gradient of EnVsRange");
  gFitGradVsRange->GetXaxis()->CenterTitle();
  gFitGradVsRange->GetYaxis()->CenterTitle();
  gFitGradVsRange->SetMarkerStyle(3);
  gFitGradVsRange->SetMarkerColor(2);
  gFitGradVsRange->SetMarkerSize(0.8);

  //now plot the normalised one
  this->NormaliseVector(gradient);
  TGraph* gNormFitGradVsRange=TGraphVect(enRange,gradient);
  TCanvas *cNormFitGradVsRange=new TCanvas("cNormFitGradVsRange",
                                       "NormFitGradVsRange",
                                       0,0,1200,800);
  cNormFitGradVsRange->SetFillColor(0);
  gNormFitGradVsRange->Draw("AP");
  gNormFitGradVsRange->SetTitle("Fit Gradient Vs Min Beam Energy in Fit");
  gNormFitGradVsRange->GetXaxis()->SetTitle("Min Beam Energy in Fit");
  gNormFitGradVsRange->GetYaxis()->SetTitle("Gradient of EnVsRange");
  gNormFitGradVsRange->GetXaxis()->CenterTitle();
  gNormFitGradVsRange->GetYaxis()->CenterTitle();
  gNormFitGradVsRange->SetMarkerStyle(3);
  gNormFitGradVsRange->SetMarkerColor(2);
  gNormFitGradVsRange->SetMarkerSize(0.8);

  MSG("CDAnalysis",Msg::kDebug)
    <<"Vpl size="<<lastPlane.size()
    <<", Ven size="<<sumEnDepSc.size()<<endl;
  TGraph* gEnDepScVsRange=TGraphVect(lastPlane,sumEnDepSc);
  TCanvas *cEnDepScVsRange=new TCanvas("cEnDepScVsRange",
                                       "EnDepScVsRange",0,0,1200,800);
  cEnDepScVsRange->SetFillColor(0);
  gEnDepScVsRange->Draw("AP");
  gEnDepScVsRange->SetTitle("Energy Vs Range");
  gEnDepScVsRange->GetXaxis()->SetTitle("Range (planes)");
  gEnDepScVsRange->GetYaxis()->SetTitle("Energy Deposited in Sc (MeV)");
  gEnDepScVsRange->GetXaxis()->CenterTitle();
  gEnDepScVsRange->GetYaxis()->CenterTitle();
  gEnDepScVsRange->SetMarkerStyle(3);
  gEnDepScVsRange->SetMarkerColor(2);
  gEnDepScVsRange->SetMarkerSize(0.8);

  vector<Double_t> enRange2;
  vector<Double_t> gradient2;

  MSG("CDAnalysis",Msg::kInfo)
    <<"Second fit..."<<endl;
  for (vector<Double_t>::iterator r=lastPlane.begin();
       r!=lastPlane.end()-3;++r){
    //for (Float_t fitRangeMin=lastPlane[0];
    // fitRangeMin<lastPlane[lastPlane.size()-3]-1;fitRangeMin++){
    static Int_t counter=0;
    
    gEnDepScVsRange->Fit("pol1","q","",*r,1000);
    TF1* func=gEnDepScVsRange->GetFunction("pol1");
    Double_t funcM=func->GetParameter(1);
    MSG("CDAnalysis",Msg::kInfo)
      <<"fitMin="<<*r
      <<", m="<<funcM<<endl;

    enRange2.push_back(sumEnDepSc[counter]);
    gradient2.push_back(funcM);

    counter++;
  }
  MSG("CDAnalysis",Msg::kInfo)
    <<"Finished second fit..."<<endl;

  TGraph* gFitGradVsRange2=TGraphVect(enRange2,gradient2);
  TCanvas *cFitGradVsRange2=new TCanvas("cFitGradVsRange2",
                                       "FitGradVsRange2",
                                       0,0,1200,800);
  cFitGradVsRange2->SetFillColor(0);
  gFitGradVsRange2->Draw("AP");
  gFitGradVsRange2->SetTitle("Norm Fit Gradient Vs Min Energy Dep Sc in Fit");
  gFitGradVsRange2->GetXaxis()->SetTitle("Min Energy Dep Sc in Fit");
  gFitGradVsRange2->GetYaxis()->SetTitle("Gradient of EnDepScVsRange");
  gFitGradVsRange2->GetXaxis()->CenterTitle();
  gFitGradVsRange2->GetYaxis()->CenterTitle();
  gFitGradVsRange2->SetMarkerStyle(3);
  gFitGradVsRange2->SetMarkerColor(2);
  gFitGradVsRange2->SetMarkerSize(0.8);

  MSG("CDAnalysis",Msg::kInfo)
    <<"Plotting normalised one..."<<endl;

  //now plot the normalised one
  this->NormaliseVector(gradient2);
  TGraph* gNormFitGradVsRange2=TGraphVect(enRange2,gradient2);
  TCanvas *cNormFitGradVsRange2=new TCanvas("cNormFitGradVsRange2",
                                       "NormFitGradVsRange2",
                                       0,0,1200,800);
  cNormFitGradVsRange2->SetFillColor(0);
  gNormFitGradVsRange2->Draw("AP");
  gNormFitGradVsRange2->SetTitle("Norm Fit Gradient Vs Min Energy Dep Sc in Fit");
  gNormFitGradVsRange2->GetXaxis()->SetTitle("Min Energy Dep Sc in Fit");
  gNormFitGradVsRange2->GetYaxis()->SetTitle("Gradient of EnDepScVsRange");
  gNormFitGradVsRange2->GetXaxis()->CenterTitle();
  gNormFitGradVsRange2->GetYaxis()->CenterTitle();
  gNormFitGradVsRange2->SetMarkerStyle(3);
  gNormFitGradVsRange2->SetMarkerColor(2);
  gNormFitGradVsRange2->SetMarkerSize(0.8);

  TF1 *form2 = new TF1("form2",FitFunc,0,70,3);
  form2->SetParameters(1,1,0);
  form2->FixParameter(2,0);
  //gEnDepScVsRange->Fit("form2","q");
}

//......................................................................

void CDAnalysis::DrawResponsePlot(string& title,TProfile* prof,
                                  TProfile* profX,TProfile* profT,
                                  const std::map<Int_t,Float_t>& num,
                                  const std::map<Int_t,Float_t>& numX,
                                  const std::map<Int_t,Float_t>& numT,
                                  string sXTitle) const
{

  TLegend *legend = new TLegend(0.85, 0.7, 0.9, 0.9);
  legend->SetBorderSize(0);
  legend->SetFillColor(0);
  legend->SetTextSize(0.035);
  string sGraph="Tracked hits";
  legend->AddEntry(prof,sGraph.c_str(),"p");
  sGraph="Untracked hits";
  legend->AddEntry(profX,sGraph.c_str(),"p");
  sGraph="All hits";
  legend->AddEntry(profT,sGraph.c_str(),"p");

  //default x axis title
  if (sXTitle=="") sXTitle="Plane";

  //make the graphs
  TGraph* gNum=this->TGraphMap(num);
  TGraph* gNumX=this->TGraphMap(numX);
  TGraph* gNumT=this->TGraphMap(numT);

  //create the canvas and plot
  TCanvas *cResponse=new TCanvas(title.c_str(),title.c_str(),
                                 0,0,1200,800);
  cResponse->SetFillColor(0);
  cResponse->Divide(1,2);
  cResponse->cd(1);
  prof->Draw("AP");
  prof->SetTitle(title.c_str());
  prof->GetXaxis()->SetTitle(sXTitle.c_str());
  prof->GetYaxis()->SetTitle("Average SigCor");
  prof->GetXaxis()->CenterTitle();
  prof->GetYaxis()->CenterTitle();
  prof->SetMarkerStyle(3);
  prof->SetMarkerColor(2);
  prof->SetMarkerSize(0.8);
  profX->Draw("same");
  profX->SetMarkerStyle(3);
  profX->SetMarkerColor(3);
  profX->SetMarkerSize(0.8);
  profT->Draw("same");
  profT->SetMarkerStyle(3);
  profT->SetMarkerColor(4);
  profT->SetMarkerSize(0.8);

  //draw the legend
  legend->Draw();

  //do second canvas
  TLegend *legend2 = new TLegend(0.85, 0.7, 0.9, 0.9);
  legend2->SetBorderSize(0);
  legend2->SetFillColor(0);
  legend2->SetTextSize(0.035);
  sGraph="Tracked hits";
  legend2->AddEntry(gNum,sGraph.c_str(),"p");
  sGraph="Untracked hits";
  legend2->AddEntry(gNumX,sGraph.c_str(),"p");
  sGraph="All hits";
  legend2->AddEntry(gNumT,sGraph.c_str(),"p");

  cResponse->cd(2);
  gNumT->Draw("AP");
  gNumT->SetTitle("Number hits");
  gNumT->GetXaxis()->SetTitle(sXTitle.c_str());
  gNumT->GetYaxis()->SetTitle("Num hits");
  gNumT->GetXaxis()->CenterTitle();
  gNumT->GetYaxis()->CenterTitle();
  gNumT->SetMarkerStyle(3);
  gNumT->SetMarkerColor(4);
  gNumT->SetMarkerSize(0.8);
  gNumX->Draw("P");
  gNumX->SetMarkerStyle(3);
  gNumX->SetMarkerColor(3);
  gNumX->SetMarkerSize(0.8);
  gNum->Draw("P");
  gNum->SetMarkerStyle(3);
  gNum->SetMarkerColor(2);
  gNum->SetMarkerSize(0.8);

  //draw the legend
  legend2->Draw();
}

//......................................................................

void CDAnalysis::CleanMuons()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running CleanMuons method... **"<<endl;

  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"CleanMuons");

  TH1F *hTime=new TH1F("hTime","hTime",100000,-500-9,500e-9);
  hTime->GetXaxis()->SetTitle("Time");
  hTime->GetXaxis()->CenterTitle();
  hTime->GetYaxis()->SetTitle("");
  hTime->GetYaxis()->CenterTitle();
  hTime->SetFillColor(0);
  //hTime->SetBit(TH1::kCanRebin);

  TH1F *hTime2=new TH1F("hTime2","hTime2",1000000,-1,1);
  hTime2->GetXaxis()->SetTitle("Time2");
  hTime2->GetXaxis()->CenterTitle();
  hTime2->GetYaxis()->SetTitle("");
  hTime2->GetYaxis()->CenterTitle();
  hTime2->SetFillColor(0);
  //hTime2->SetBit(TH1::kCanRebin);

  TProfile2D *hStVsPl1=new TProfile2D("hStVsPl1","StVsPl1",
                         67,-2,65,27,-2,25);
  hStVsPl1->GetXaxis()->SetTitle("Plane");
  hStVsPl1->GetXaxis()->CenterTitle();
  hStVsPl1->GetYaxis()->SetTitle("Strip");
  hStVsPl1->GetYaxis()->CenterTitle();
  hStVsPl1->SetFillColor(0);
  hStVsPl1->SetBit(TH1::kCanRebin);

  TProfile2D *hStVsPl2=new TProfile2D("hStVsPl2","StVsPl2",
                         67,-2,65,27,-2,25);
  hStVsPl2->GetXaxis()->SetTitle("Plane");
  hStVsPl2->GetXaxis()->CenterTitle();
  hStVsPl2->GetYaxis()->SetTitle("Strip");
  hStVsPl2->GetYaxis()->CenterTitle();
  hStVsPl2->SetFillColor(0);
  hStVsPl2->SetBit(TH1::kCanRebin);

  TH1F *hTofKov1Diff=new TH1F("hTofKov1Diff",
                               "hTofKov1Diff",4000,-2,3);
  hTofKov1Diff->GetXaxis()->SetTitle("TofTimeStamp");
  hTofKov1Diff->GetXaxis()->CenterTitle();
  hTofKov1Diff->GetYaxis()->SetTitle("");
  hTofKov1Diff->GetYaxis()->CenterTitle();
  hTofKov1Diff->SetFillColor(0);
  hTofKov1Diff->SetBit(TH1::kCanRebin);

  TH1F *hTofKov3Diff=new TH1F("hTofKov3Diff",
                               "hTofKov3Diff",4000,-2,3);
  hTofKov3Diff->GetXaxis()->SetTitle("TofTimeStamp");
  hTofKov3Diff->GetXaxis()->CenterTitle();
  hTofKov3Diff->GetYaxis()->SetTitle("");
  hTofKov3Diff->GetYaxis()->CenterTitle();
  hTofKov3Diff->SetFillColor(0);
  hTofKov3Diff->SetBit(TH1::kCanRebin);

  TH1F *hTofKov1DiffWhole=new TH1F("hTofKov1DiffWhole",
                               "hTofKov1DiffWhole",4000,-2,3);
  hTofKov1DiffWhole->GetXaxis()->SetTitle("TofTimeStamp");
  hTofKov1DiffWhole->GetXaxis()->CenterTitle();
  hTofKov1DiffWhole->GetYaxis()->SetTitle("");
  hTofKov1DiffWhole->GetYaxis()->CenterTitle();
  hTofKov1DiffWhole->SetFillColor(0);
  hTofKov1DiffWhole->SetBit(TH1::kCanRebin);

  TH1F *hTofKov3DiffWhole=new TH1F("hTofKov3DiffWhole",
                               "hTofKov3DiffWhole",4000,-2,3);
  hTofKov3DiffWhole->GetXaxis()->SetTitle("TofTimeStamp");
  hTofKov3DiffWhole->GetXaxis()->CenterTitle();
  hTofKov3DiffWhole->GetYaxis()->SetTitle("");
  hTofKov3DiffWhole->GetYaxis()->CenterTitle();
  hTofKov3DiffWhole->SetFillColor(0);
  hTofKov3DiffWhole->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC0=new TH1F("hTofTDC0","TofTDC0",400,-2,4000);
  hTofTDC0->GetXaxis()->SetTitle("TofTDC0");
  hTofTDC0->GetXaxis()->CenterTitle();
  hTofTDC0->GetYaxis()->SetTitle("");
  hTofTDC0->GetYaxis()->CenterTitle();
  hTofTDC0->SetFillColor(0);
  hTofTDC0->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC2=new TH1F("hTofTDC2","TofTDC2",400,-2,4000);
  hTofTDC2->GetXaxis()->SetTitle("TofTDC2");
  hTofTDC2->GetXaxis()->CenterTitle();
  hTofTDC2->GetYaxis()->SetTitle("");
  hTofTDC2->GetYaxis()->CenterTitle();
  hTofTDC2->SetFillColor(0);
  hTofTDC2->SetBit(TH1::kCanRebin);

  TH1F *hTofDiff=new TH1F("hTofDiff","TofDiff",1000,0,1000);
  hTofDiff->GetXaxis()->SetTitle("TofDiff");
  hTofDiff->GetXaxis()->CenterTitle();
  hTofDiff->GetYaxis()->SetTitle("");
  hTofDiff->GetYaxis()->CenterTitle();
  hTofDiff->SetFillColor(0);
  //hTofDiff->SetBit(TH1::kCanRebin);

  TH1F *hTofDiffElec=new TH1F("hTofDiffElec","TofDiffElec",1000,0,1000);
  hTofDiffElec->GetXaxis()->SetTitle("TofDiff");
  hTofDiffElec->GetXaxis()->CenterTitle();
  hTofDiffElec->GetYaxis()->SetTitle("");
  hTofDiffElec->GetYaxis()->CenterTitle();
  hTofDiffElec->SetFillColor(0);
  //hTofDiffElec->SetBit(TH1::kCanRebin);

  TH1F *hTofDiffNotElec=new TH1F("hTofDiffNotElec","TofDiffNotElec",
                                 1000,0,1000);
  hTofDiffNotElec->GetXaxis()->SetTitle("TofDiff");
  hTofDiffNotElec->GetXaxis()->CenterTitle();
  hTofDiffNotElec->GetYaxis()->SetTitle("");
  hTofDiffNotElec->GetYaxis()->CenterTitle();
  hTofDiffNotElec->SetFillColor(0);
  //hTofDiffNotElec->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC0Whole=new TH1F("hTofTDC0Whole","TofTDC0Whole",
                               400,-2,4000);
  hTofTDC0Whole->GetXaxis()->SetTitle("TofTDC0");
  hTofTDC0Whole->GetXaxis()->CenterTitle();
  hTofTDC0Whole->GetYaxis()->SetTitle("");
  hTofTDC0Whole->GetYaxis()->CenterTitle();
  hTofTDC0Whole->SetFillColor(0);
  hTofTDC0Whole->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC2Whole=new TH1F("hTofTDC2Whole","TofTDC2Whole",
                               400,-2,4000);
  hTofTDC2Whole->GetXaxis()->SetTitle("TofTDC2");
  hTofTDC2Whole->GetXaxis()->CenterTitle();
  hTofTDC2Whole->GetYaxis()->SetTitle("");
  hTofTDC2Whole->GetYaxis()->CenterTitle();
  hTofTDC2Whole->SetFillColor(0);
  hTofTDC2Whole->SetBit(TH1::kCanRebin);

  TH1F *hTofDiffWhole=new TH1F("hTofDiffWhole","TofDiffWhole",
                               1000,-2000,4000);
  hTofDiffWhole->GetXaxis()->SetTitle("TofDiff");
  hTofDiffWhole->GetXaxis()->CenterTitle();
  hTofDiffWhole->GetYaxis()->SetTitle("");
  hTofDiffWhole->GetYaxis()->CenterTitle();
  hTofDiffWhole->SetFillColor(0);
  hTofDiffWhole->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1Whole=new TH1F("hKovADC1Whole","KovADC1Whole",
                               400,-5,15000);
  hKovADC1Whole->GetXaxis()->SetTitle("KovADC1Whole");
  hKovADC1Whole->GetXaxis()->CenterTitle();
  hKovADC1Whole->GetYaxis()->SetTitle("");
  hKovADC1Whole->GetYaxis()->CenterTitle();
  hKovADC1Whole->SetFillColor(0);
  hKovADC1Whole->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1=new TH1F("hKovADC1","KovADC1",400,-5,15000);
  hKovADC1->GetXaxis()->SetTitle("KovADC1");
  hKovADC1->GetXaxis()->CenterTitle();
  hKovADC1->GetYaxis()->SetTitle("");
  hKovADC1->GetYaxis()->CenterTitle();
  hKovADC1->SetFillColor(0);
  hKovADC1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1Cut=new TH1F("hKovADC1Cut","KovADC1Cut",400,-5,15000);
  hKovADC1Cut->GetXaxis()->SetTitle("KovADC1Cut");
  hKovADC1Cut->GetXaxis()->CenterTitle();
  hKovADC1Cut->GetYaxis()->SetTitle("");
  hKovADC1Cut->GetYaxis()->CenterTitle();
  hKovADC1Cut->SetFillColor(0);
  hKovADC1Cut->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3Whole=new TH1F("hKovADC3Whole","KovADC3Whole",
                               400,-5,15000);
  hKovADC3Whole->GetXaxis()->SetTitle("KovADC3Whole");
  hKovADC3Whole->GetXaxis()->CenterTitle();
  hKovADC3Whole->GetYaxis()->SetTitle("");
  hKovADC3Whole->GetYaxis()->CenterTitle();
  hKovADC3Whole->SetFillColor(0);
  hKovADC3Whole->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3=new TH1F("hKovADC3","KovADC3",400,-5,15000);
  hKovADC3->GetXaxis()->SetTitle("KovADC3");
  hKovADC3->GetXaxis()->CenterTitle();
  hKovADC3->GetYaxis()->SetTitle("");
  hKovADC3->GetYaxis()->CenterTitle();
  hKovADC3->SetFillColor(0);
  hKovADC3->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3Cut=new TH1F("hKovADC3Cut","KovADC3Cut",400,-5,15000);
  hKovADC3Cut->GetXaxis()->SetTitle("KovADC3Cut");
  hKovADC3Cut->GetXaxis()->CenterTitle();
  hKovADC3Cut->GetYaxis()->SetTitle("");
  hKovADC3Cut->GetYaxis()->CenterTitle();
  hKovADC3Cut->SetFillColor(0);
  hKovADC3Cut->SetBit(TH1::kCanRebin);

  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hStripend=new TH1F("hStripend","Stripend hit",120,-2,10);
  hStripend->GetXaxis()->SetTitle("Stripend");
  hStripend->GetXaxis()->CenterTitle();
  hStripend->GetYaxis()->SetTitle("");
  hStripend->GetYaxis()->CenterTitle();
  hStripend->SetFillColor(0);
  hStripend->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hNumPlanes=new TH1F("hNumPlanes","NumPlanes hit",200,-2,75);
  hNumPlanes->GetXaxis()->SetTitle("NumPlanes");
  hNumPlanes->GetXaxis()->CenterTitle();
  hNumPlanes->GetYaxis()->SetTitle("");
  hNumPlanes->GetYaxis()->CenterTitle();
  hNumPlanes->SetFillColor(0);
  hNumPlanes->SetBit(TH1::kCanRebin);

  TH1F *hEventLength=new TH1F("hEventLength","EventLength hit",200,-2,75);
  hEventLength->GetXaxis()->SetTitle("EventLength");
  hEventLength->GetXaxis()->CenterTitle();
  hEventLength->GetYaxis()->SetTitle("");
  hEventLength->GetYaxis()->CenterTitle();
  hEventLength->SetFillColor(0);
  hEventLength->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigCor=new TH1F("hChargeSigCor","ChargeSigCor",
                               1000,-2,15000);
  hChargeSigCor->GetXaxis()->SetTitle("ChargeSigCor");
  hChargeSigCor->GetXaxis()->CenterTitle();
  hChargeSigCor->GetYaxis()->SetTitle("");
  hChargeSigCor->GetYaxis()->CenterTitle();
  hChargeSigCor->SetFillColor(0);
  hChargeSigCor->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigLin=new TH1F("hChargeSigLin","ChargeSigLin",
                               1000,-2,15000);
  hChargeSigLin->GetXaxis()->SetTitle("ChargeSigLin");
  hChargeSigLin->GetXaxis()->CenterTitle();
  hChargeSigLin->GetYaxis()->SetTitle("");
  hChargeSigLin->GetYaxis()->CenterTitle();
  hChargeSigLin->SetFillColor(0);
  hChargeSigLin->SetBit(TH1::kCanRebin);

  TH1F *hChargePe=new TH1F("hChargePe","ChargePe",412,-12,400);
  hChargePe->GetXaxis()->SetTitle("ChargePe");
  hChargePe->GetXaxis()->CenterTitle();
  hChargePe->GetYaxis()->SetTitle("");
  hChargePe->GetYaxis()->CenterTitle();
  hChargePe->SetFillColor(0);
  hChargePe->SetBit(TH1::kCanRebin);

  TH1F *hGain=new TH1F("hGain","Gain",1000,-2,150);
  hGain->GetXaxis()->SetTitle("Gain");
  hGain->GetXaxis()->CenterTitle();
  hGain->GetYaxis()->SetTitle("");
  hGain->GetYaxis()->CenterTitle();
  hGain->SetFillColor(0);
  hGain->SetBit(TH1::kCanRebin);

  TH1F *hAdc=new TH1F("hAdc","Adc",1000,-2,150);
  hAdc->GetXaxis()->SetTitle("Adc");
  hAdc->GetXaxis()->CenterTitle();
  hAdc->GetYaxis()->SetTitle("");
  hAdc->GetYaxis()->CenterTitle();
  hAdc->SetFillColor(0);
  hAdc->SetBit(TH1::kCanRebin);

  TH1F *hdzds=new TH1F("hdzds","dzds",400,-2,2);
  hdzds->GetXaxis()->SetTitle("dzds");
  hdzds->GetXaxis()->CenterTitle();
  hdzds->GetYaxis()->SetTitle("");
  hdzds->GetYaxis()->CenterTitle();
  hdzds->SetFillColor(0);
  hdzds->SetBit(TH1::kCanRebin);

  TH1F *hdsdz=new TH1F("hdsdz","dsdz",400,-2,10);
  hdsdz->GetXaxis()->SetTitle("dsdz");
  hdsdz->GetXaxis()->CenterTitle();
  hdsdz->GetYaxis()->SetTitle("");
  hdsdz->GetYaxis()->CenterTitle();
  hdsdz->SetFillColor(0);
  hdsdz->SetBit(TH1::kCanRebin);

  TH1F *hdydz=new TH1F("hdydz","dydz",400,-5,5);
  hdydz->GetXaxis()->SetTitle("dydz");
  hdydz->GetXaxis()->CenterTitle();
  hdydz->GetYaxis()->SetTitle("");
  hdydz->GetYaxis()->CenterTitle();
  hdydz->SetFillColor(0);
  hdydz->SetBit(TH1::kCanRebin);

  TH1F *hdxdz=new TH1F("hdxdz","dxdz",400,-10,10);
  hdxdz->GetXaxis()->SetTitle("dxdz");
  hdxdz->GetXaxis()->CenterTitle();
  hdxdz->GetYaxis()->SetTitle("");
  hdxdz->GetYaxis()->CenterTitle();
  hdxdz->SetFillColor(0);
  hdxdz->SetBit(TH1::kCanRebin);

  TH1F *hdyds=new TH1F("hdyds","dyds",400,-3,3);
  hdyds->GetXaxis()->SetTitle("dyds");
  hdyds->GetXaxis()->CenterTitle();
  hdyds->GetYaxis()->SetTitle("");
  hdyds->GetYaxis()->CenterTitle();
  hdyds->SetFillColor(0);
  hdyds->SetBit(TH1::kCanRebin);

  TH1F *hdxds=new TH1F("hdxds","dxds",400,-3,3);
  hdxds->GetXaxis()->SetTitle("dxds");
  hdxds->GetXaxis()->CenterTitle();
  hdxds->GetYaxis()->SetTitle("");
  hdxds->GetYaxis()->CenterTitle();
  hdxds->SetFillColor(0);
  hdxds->SetBit(TH1::kCanRebin);

  TH1F *hTransPos=new TH1F("hTransPos","TransPos",1000,-2,35);
  hTransPos->GetXaxis()->SetTitle("TransPos");
  hTransPos->GetXaxis()->CenterTitle();
  hTransPos->GetYaxis()->SetTitle("");
  hTransPos->GetYaxis()->CenterTitle();
  hTransPos->SetFillColor(0);
  hTransPos->SetBit(TH1::kCanRebin);

  TH1F *hYPos=new TH1F("hYPos","YPos",1000,-8,8);
  hYPos->GetXaxis()->SetTitle("YPos");
  hYPos->GetXaxis()->CenterTitle();
  hYPos->GetYaxis()->SetTitle("");
  hYPos->GetYaxis()->CenterTitle();
  hYPos->SetFillColor(0);
  hYPos->SetBit(TH1::kCanRebin);

  TH1F *hEvenResult=new TH1F("hEvenResult","EvenResult",100,-5,5);
  hEvenResult->GetXaxis()->SetTitle("EvenResult");
  hEvenResult->GetXaxis()->CenterTitle();
  hEvenResult->GetYaxis()->SetTitle("");
  hEvenResult->GetYaxis()->CenterTitle();
  hEvenResult->SetFillColor(0);
  hEvenResult->SetBit(TH1::kCanRebin);

  TH1F *hOddResult=new TH1F("hOddResult","OddResult",100,-5,5);
  hOddResult->GetXaxis()->SetTitle("OddResult");
  hOddResult->GetXaxis()->CenterTitle();
  hOddResult->GetYaxis()->SetTitle("");
  hOddResult->GetYaxis()->CenterTitle();
  hOddResult->SetFillColor(0);
  hOddResult->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsPlane=new TProfile("pSigCorVsPlane",
                                        "pSigCorVsPlane",
                                        65,-1,64);
  TProfile* pSigCorVsOsPlane=new TProfile("pSigCorVsOsPlane",
                                         "pSigCorVsOsPlane",
                                         70,5,75);

  Bool_t triggerPMT;            //Did the triggerPMT fire?
  Bool_t fafErr;                //Faf errors?
  Bool_t sparseErr;             //sparse errors?
  Int_t trigSource;             //trigger source
  Int_t kovADC1;                //Cerenkov ADC value
  Int_t kovTimeStamp1;          //Cerenkov TimeStamp
  Int_t kovADC2;
  Int_t kovTimeStamp2;
  Int_t kovADC3;
  Int_t kovTimeStamp3;
  Int_t snarlTimeFrame;         //Event TimeFrame
  ULong_t snarlMinTimeStamp;  //event minimum timetimestamp
  ULong_t snarlMaxTimeStamp;  //event maximum timestamp
  Int_t tofTDC0;                //TOF tdc0 value
  Int_t tofTDC1;                //TOF tdc1 value
  Int_t tofTDC2;                //TOF tdc2 value
  Int_t tofADC0;                //TOF ADC0 value (not always present) 
                               //______Context depends on the run
  Int_t tofADC1;                //TOF ADC1 value (not always present) 
                               //Used for tof system testing
  Int_t tofADC2;                //TOF ADC1 value (not always present) 
                               //Used for tof system testing
  Int_t tofADCTimeStamp0;       //tof adc timestamps
  Int_t tofADCTimeStamp1;
  Int_t tofADCTimeStamp2;  
  Int_t tofTimeStamp;           //time stamp of TOF readout
  Int_t tickSinceLast;          //Ticks since last snarl

  map<Int_t,Float_t> totalSigCor;
  map<Int_t,Float_t> totalNum;
  map<Int_t,Float_t> totalSigCorOffSet;
  map<Int_t,Float_t> totalNumOffSet;
  map<Int_t,Float_t> totalSigCor2;
  map<Int_t,Float_t> totalNum2;
  map<Int_t,Float_t> totalSigCorOffSet2;
  map<Int_t,Float_t> totalNumOffSet2;
  map<Int_t,Float_t> totalSigCor3;
  map<Int_t,Float_t> totalNum3;
  map<Int_t,Float_t> totalSigCorOffSet3;
  map<Int_t,Float_t> totalNumOffSet3;
  vector<TProfile*> pSigCorVsDist;
  vector<Int_t> vWindowSize;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (!fPIDInfo){
      MAXMSG("CDAnalysis",Msg::kWarning,100)
        <<"No PID info: fPIDInfo="<<fPIDInfo<<endl;
      continue;
    }

    triggerPMT=fPIDInfo->GetTriggerPMT();
    fafErr=fPIDInfo->GetFafErr() ;
    sparseErr=fPIDInfo->GetSparseErr();
    trigSource=fPIDInfo->GetTrigSource();
    kovADC1=fPIDInfo->GetKovADC1() ;
    kovTimeStamp1=fPIDInfo->GetKovTimeStamp1();
    kovADC2=fPIDInfo->GetKovADC2();
    kovTimeStamp2=fPIDInfo->GetKovTimeStamp2();
    kovADC3=fPIDInfo->GetKovADC3();
    kovTimeStamp3=fPIDInfo->GetKovTimeStamp3(); 
    snarlTimeFrame=fPIDInfo->GetSnarlTimeFrame();
    snarlMinTimeStamp=fPIDInfo->GetSnarlMinTimeStamp();
    snarlMaxTimeStamp=fPIDInfo->GetSnarlMaxTimeStamp();
    tofTDC0=fPIDInfo->GetTofTDC0();
    tofTDC1=fPIDInfo->GetTofTDC1();
    tofTDC2=fPIDInfo->GetTofTDC2();
    tofADC0=fPIDInfo->GetTofADC0();
    tofADC1=fPIDInfo->GetTofADC1();
    tofADC2=fPIDInfo->GetTofADC2();
    tofADCTimeStamp0=fPIDInfo->GetTofADCTimeStamp0();
    tofADCTimeStamp1=fPIDInfo->GetTofADCTimeStamp1();
    tofADCTimeStamp2=fPIDInfo->GetTofADCTimeStamp2();
    tofTimeStamp=fPIDInfo->GetTofTimeStamp();//don't use
    tickSinceLast=fPIDInfo->GetTickSinceLast();
    
    hKovADC3Whole->Fill(kovADC3);
    hKovADC1Whole->Fill(kovADC1);
    hTofTDC0Whole->Fill(tofTDC0);
    hTofTDC2Whole->Fill(tofTDC2);
    hTofDiffWhole->Fill(tofTDC2-tofTDC0);
    hTofKov1DiffWhole->Fill(tofADCTimeStamp1-kovTimeStamp1);
    hTofKov3DiffWhole->Fill(tofADCTimeStamp1-kovTimeStamp3);

    //if (this->CutOnPidForElec()) continue;

    hEvenResult->Fill(fTrackInfo->GetResult(0));
    hOddResult->Fill(fTrackInfo->GetResult(1));

    hTofTDC0->Fill(tofTDC0);
    hTofTDC2->Fill(tofTDC2);
    hTofDiff->Fill(tofTDC2-tofTDC0);
    if (kovADC1>500 && kovADC3>500) hTofDiffElec->Fill(tofTDC2-tofTDC0);
    else hTofDiffNotElec->Fill(tofTDC2-tofTDC0);
    hTofKov1Diff->Fill(tofADCTimeStamp1-kovTimeStamp1);
    hTofKov3Diff->Fill(tofADCTimeStamp1-kovTimeStamp3);

    MSG("CDAnalysis",Msg::kVerbose)//diff is the lemo
      <<"ttof="<<tofTimeStamp
      <<", tofADCTimeStamp1="<<tofADCTimeStamp1<<endl;

    map<Int_t,Int_t> numPlanesHit;
    map<Int_t,Int_t> numPlanesHit1;
    map<Int_t,Int_t> numPlanesHit2;
    Int_t firstPlane=999999;
    Int_t lastPlane=-1;
    Int_t lastPlaneOdd=-1;
    Int_t lastPlaneEven=-1;
    map<Int_t,Float_t> planeSigCor;
    map<Int_t,Float_t> planeSigCorX;
    map<Int_t,Float_t> planeSigCorT;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
          
    //look for untracked big events
    if (numTrkHits<2 && numXTalkHits+numUnTrkHits>100){
      MSG("CDAnalysis",Msg::kDebug)
        <<"Event="<<event
        <<", Num hits: trk="<<numTrkHits<<", unTrk="<<numUnTrkHits
        <<", xtalk="<<numXTalkHits<<endl;
    }

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      CDTrackedHitInfo *hitInfo=(CDTrackedHitInfo*) cUnTrk[hit];

      this->ReadInHitInfo(hitInfo);

      Float_t chargeSigCor=hitInfo->GetCharge
        (CDTrackedHitInfo::kSigCorr);
      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();

      //cut out the strips with bad pedestals
      if ((plane==21 || plane==41) && strip==19) continue;
      //cut out the negative adcs
      if (strip==13 && plane==40) continue;

      hTime->Fill(fTime-tofTimeStamp);
      hTime2->Fill(fTime-tofTimeStamp);

      //add up the charge of the hits in each plane
      planeSigCorX[plane]+=chargeSigCor;
      planeSigCorT[plane]+=chargeSigCor;
    }

    //loop over xtalk hits in the snarl
    for (Int_t hit=0;hit<numXTalkHits;hit++){
      CDXTalkHitInfo *hitInfo=(CDXTalkHitInfo*) cXTalk[hit];

      this->ReadInHitInfo(hitInfo);      

      Float_t chargeSigCor=hitInfo->GetCharge
        (CDTrackedHitInfo::kSigCorr);
      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();
      
      //cut out the strips with bad pedestals
      if ((plane==21 || plane==41) && strip==19) continue;
      //cut out the negative adcs
      if (strip==13 && plane==40) continue;

      hTime->Fill(fTime-tofTimeStamp);
      hTime2->Fill(fTime-tofTimeStamp);

      //add up the charge of the hits in each plane
      planeSigCorX[plane]+=chargeSigCor;
      planeSigCorT[plane]+=chargeSigCor;
    }

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) cTrk[hit];
          
      this->ReadInHitInfo(trackedHitInfo);

      Int_t plane=trackedHitInfo->GetPlane();
      Int_t strip=trackedHitInfo->GetStrip();
      Int_t stripend=trackedHitInfo->GetEnd();

      Float_t chargeSigCor=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kSigCorr);
      Float_t chargeSigLin=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kSigLin);
      Float_t chargePe=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kPe);
      Float_t gain = chargeSigLin/chargePe;
      Float_t adc=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kAdc);

      hTime->Fill(fTime-tofTimeStamp);
      hTime2->Fill(fTime-tofTimeStamp);

      if (stripend==1) hStVsPl1->Fill(plane,strip,adc);
      if (stripend==2) hStVsPl2->Fill(plane,strip,adc);

      //cut out the strips with bad pedestals
      if ((plane==21 || plane==41) && strip==19) continue;
      //cut out the negative adcs
      if (strip==13 && plane==40) continue;

      if (adc<0 && !(strip==13 && plane==40)){
        MSG("CDAnalysis",Msg::kInfo)
          <<"Event="<<event<<", adc="<<adc<<" ("<<plane<<":"<<strip
          <<")"<<endl;
      }
      else if (adc<0){
        MSG("CDAnalysis",Msg::kInfo)
          <<"Event="<<event<<", adc="<<adc<<" ("<<plane<<":"<<strip
          <<")"<<endl;
      }

      hPlane->Fill(plane);
      hStrip->Fill(strip);
      hStripend->Fill(stripend);

      //count the number of planes hit
      numPlanesHit[plane]++;
      if (stripend==1) numPlanesHit1[plane]++;
      if (stripend==2) numPlanesHit2[plane]++;
      if (plane<firstPlane) firstPlane=plane;
      if (plane>lastPlane) lastPlane=plane;
      if (plane>lastPlaneOdd && plane%2!=0) lastPlaneOdd=plane;
      if (plane>lastPlaneEven && plane%2==0) lastPlaneEven=plane;

      //add up the charge of the tracked hits in each plane
      planeSigCor[plane]+=chargeSigCor;
      planeSigCorT[plane]+=chargeSigCor;

      hChargeSigCor->Fill(chargeSigCor);
      hChargeSigLin->Fill(chargeSigLin);
      hChargePe->Fill(chargePe);
      hGain->Fill(gain);
      hAdc->Fill(adc);

      Float_t dzds = trackedHitInfo->GetDzDs();
      Float_t dsdz = 1./dzds;
      Float_t dydz = trackedHitInfo->GetDyDz();
      Float_t dxdz = trackedHitInfo->GetDxDz();
      Float_t dyds = trackedHitInfo->GetDyDz()*
        trackedHitInfo->GetDzDs();
      Float_t dxds = trackedHitInfo->GetDxDz()*
        trackedHitInfo->GetDzDs();
      Float_t TransPos = trackedHitInfo->GetTransPos();
      Float_t YPos = trackedHitInfo->GetYPos();

      hdzds->Fill(dzds);
      hdsdz->Fill(dsdz);
      hdydz->Fill(dydz);
      hdxdz->Fill(dxdz);
      hdyds->Fill(dyds);
      hdxds->Fill(dxds);
      hTransPos->Fill(TransPos);
      hYPos->Fill(YPos);
    }
        
    if (firstPlane<0 || firstPlane>59) continue;

    hNumPlanes->Fill(numPlanesHit.size());

    if (firstPlane>=0 && firstPlane<60){
      hEventLength->Fill(lastPlane-firstPlane+1);
    }

    Float_t pl1Pl2=0;
    if (numPlanesHit2.size()>0) pl1Pl2=1.*numPlanesHit1.size()/
                                  numPlanesHit2.size();

    if (firstPlane<60 && numPlanesHit.size()>40 && planeSigCor[1]>800 && planeSigCor[2]>800){

      MSG("CDAnalysis",Msg::kVerbose)
        <<"Special: ev="<<event
        <<", firstPl="<<firstPlane
        <<", lastPl="<<lastPlane
        <<", nPl="<<numPlanesHit.size()
        <<", nPl1="<<numPlanesHit1.size()
        <<", nPl2="<<numPlanesHit2.size()
        <<", Pl1/Pl2="<<pl1Pl2<<endl;
    }

    if (pl1Pl2>2 || pl1Pl2<1./2){
      MSG("CDAnalysis",Msg::kVerbose)
        <<"1 sided: ev="<<event
        <<", firstPl="<<firstPlane
        <<", lastPl="<<lastPlane
        <<", nPl="<<numPlanesHit.size()
        <<", nPl1="<<numPlanesHit1.size()
        <<", nPl2="<<numPlanesHit2.size()
        <<", Pl1/Pl2="<<pl1Pl2<<endl;
    }

    static Int_t counter=0;
    counter++;

    if (counter<80){
      MSG("CDAnalysis",Msg::kDebug)
        <<"Event="<<event
        <<", numPlanes="<<numPlanesHit.size()
        <<", kov1="<<kovADC1
        <<", kov3="<<kovADC3
        <<endl;
    }

    if (kovADC1>100){
      MSG("CDAnalysis",Msg::kDebug)
        <<"High Kov Event="<<event
        <<", numPlanes="<<numPlanesHit.size()
        <<", kov1="<<kovADC1
        <<", kov3="<<kovADC3
        <<endl;
    }

    if (numPlanesHit.size()>40){
      hKovADC3->Fill(kovADC3);
      hKovADC1->Fill(kovADC1);
    }
    else{
      hKovADC3Cut->Fill(kovADC3);
      hKovADC1Cut->Fill(kovADC1);
    }

    //make cuts
    if (numPlanesHit.size()<40) continue;
    if (firstPlane<0 || firstPlane>59) continue;
    if (lastPlane>57) continue;//cut out through going muons, no 58,59

    if (numPlanesHit[lastPlane-1]==0){
      MSG("CDAnalysis",Msg::kDebug)
        <<"Missing lastPlane-1, event="<<event
        <<", numPlanes="<<numPlanesHit.size()
        <<", kov1="<<kovADC1
        <<", kov3="<<kovADC3
        <<endl;
    }

    //section for response

    const Int_t reNormPlane=70;
    Int_t planeOffset=reNormPlane-lastPlane;

    for (map<Int_t,Float_t>::iterator sig=planeSigCor.begin();
         sig!=planeSigCor.end();++sig){
      totalSigCor[sig->first]+=sig->second;
      totalNum[sig->first]++;
      pSigCorVsPlane->Fill(sig->first,sig->second);

      totalSigCorOffSet[sig->first+planeOffset]+=sig->second;
      totalNumOffSet[sig->first+planeOffset]++;
      pSigCorVsOsPlane->Fill(sig->first+planeOffset,sig->second);
    }

    for (map<Int_t,Float_t>::iterator sig=planeSigCorX.begin();
         sig!=planeSigCorX.end();++sig){
      totalSigCor2[sig->first]+=sig->second;
      totalNum2[sig->first]++;

      totalSigCorOffSet2[sig->first+planeOffset]+=sig->second;
      totalNumOffSet2[sig->first+planeOffset]++;
    }

    for (map<Int_t,Float_t>::iterator sig=planeSigCorT.begin();
         sig!=planeSigCorT.end();++sig){
      totalSigCor3[sig->first]+=sig->second;
      totalNum3[sig->first]++;

      totalSigCorOffSet3[sig->first+planeOffset]+=sig->second;
      totalNumOffSet3[sig->first+planeOffset]++;
    }

    //section for sliding window
    Int_t minEventLength=40;
    if (lastPlane<minEventLength) continue;

    MSG("CDAnalysis",Msg::kDebug)
      <<"Event="<<event
      <<", firstPl="<<firstPlane
      <<", lastPl="<<lastPlane
      <<", lastPlOdd="<<lastPlaneOdd
      <<", lastPlEven="<<lastPlaneEven
      <<", numPlanes="<<numPlanesHit.size()<<endl;

    //initialise the profile histos
    static Bool_t firstTime=true;
    if (firstTime){
      for (Int_t p=20;p>1;p--){
        vWindowSize.push_back(p);
      }

      for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
           windowSize!=vWindowSize.end();++windowSize){
        
        string sName=Form("%d",*windowSize);
        pSigCorVsDist.push_back
          (new TProfile(("pSigCorVsDist"+sName).c_str(),
                        ("pSigCorVsDist"+sName).c_str(),100,-2,40));
      }
    }
    firstTime=false;

    vector<TProfile*>::iterator prof=pSigCorVsDist.begin();

    for (vector<Int_t>::iterator windowSize=vWindowSize.begin();
         windowSize!=vWindowSize.end();++windowSize){
      
      for (Int_t p=0;p<minEventLength-*windowSize;p++){
        Int_t windowStart=lastPlane-p;

        Float_t avSigCor=0;
        Int_t numUsed=0;
        
        for (Int_t i=0;i<*windowSize;i++){
          Int_t plane=windowStart-i;
          
          MSG("CDAnalysis",Msg::kVerbose)
            <<"Event="<<event
            <<", winStart="<<windowStart
            <<", plane="<<plane<<endl;
          
          //cut out planes that are greater than the last plane
          //in the view - ie the zeros at the end
          Bool_t doZeroCorrection=false;
          if (doZeroCorrection && 
              ((plane%2==0 && plane>lastPlaneEven) || 
               (plane%2!=0 && plane>lastPlaneOdd))){
            MSG("CDAnalysis",Msg::kVerbose)
              <<"Not using: Event="<<event
              <<", pl="<<plane
              <<", sigCor="<<planeSigCor[plane]
              <<", lastPlane="<<lastPlane
              <<", lastPlSig="<<planeSigCor[lastPlane]
              <<", lastPlOdd="<<lastPlaneOdd
              <<", lastPlEven="<<lastPlaneEven
              <<endl;
          }
          else{
            avSigCor+=planeSigCor[plane];
            numUsed++;
            }
        }
        
        //find average
        if (numUsed>0) avSigCor/=numUsed;
        (*prof)->Fill(p,avSigCor);
        
        MSG("CDAnalysis",Msg::kDebug)
          <<"Event="<<event
          <<", winStart="<<windowStart
          <<", avSigCor="<<avSigCor<<endl;
      }
      prof++;
    }
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;
  
  TCanvas *cProf=new TCanvas("cProf","Prof",0,0,1200,800);
  cProf->SetFillColor(0);
  string sName="SlidingWindow.ps";
  cProf->Print((sName+"[").c_str());
  for (vector<TProfile*>::iterator prof=pSigCorVsDist.begin();
       prof!=pSigCorVsDist.end();++prof){
    cProf->Clear();
    (*prof)->Draw();
    (*prof)->SetTitle("Average SigCor in Sliding Window");
    (*prof)->GetXaxis()->SetTitle("Start of sliding window (planes from end of track)");
    (*prof)->GetYaxis()->SetTitle("Average SigCor");
    (*prof)->GetXaxis()->CenterTitle();
    (*prof)->GetYaxis()->CenterTitle();
    cProf->Print(sName.c_str());
  }
  cProf->Print((sName+"]").c_str());

  this->ScaleMap(totalSigCorOffSet,totalNumOffSet);
  TGraph* gPlaneVsAvSigCorOS=this->TGraphMap(totalSigCorOffSet);
  TGraph* gPlaneVsNumOS=this->TGraphMap(totalNumOffSet);
  this->ScaleMap(totalSigCor,totalNum);
  TGraph* gPlaneVsAvSigCor=this->TGraphMap(totalSigCor);
  TGraph* gPlaneVsNum=this->TGraphMap(totalNum);

  this->ScaleMap(totalSigCorOffSet2,totalNumOffSet2);
  TGraph* gPlaneVsAvSigCorOS2=this->TGraphMap(totalSigCorOffSet2);
  TGraph* gPlaneVsNumOS2=this->TGraphMap(totalNumOffSet2);
  this->ScaleMap(totalSigCor2,totalNum2);
  TGraph* gPlaneVsAvSigCor2=this->TGraphMap(totalSigCor2);
  TGraph* gPlaneVsNum2=this->TGraphMap(totalNum2);

  this->ScaleMap(totalSigCorOffSet3,totalNumOffSet3);
  TGraph* gPlaneVsAvSigCorOS3=this->TGraphMap(totalSigCorOffSet3);
  TGraph* gPlaneVsNumOS3=this->TGraphMap(totalNumOffSet3);
  this->ScaleMap(totalSigCor3,totalNum3);
  TGraph* gPlaneVsAvSigCor3=this->TGraphMap(totalSigCor3);
  TGraph* gPlaneVsNum3=this->TGraphMap(totalNum3);

  TCanvas *cSigCorVsPlane=new TCanvas("cSigCorVsPlane","SigCorVsPlane",
                                      0,0,1200,800);
  cSigCorVsPlane->SetFillColor(0);
  cSigCorVsPlane->Divide(1,2);
  cSigCorVsPlane->cd(1);
  pSigCorVsPlane->Draw();
  pSigCorVsPlane->SetTitle("Energy Deposition (SigCor)");
  pSigCorVsPlane->GetXaxis()->SetTitle("Plane");
  pSigCorVsPlane->GetYaxis()->SetTitle("Average SigCor");
  pSigCorVsPlane->GetXaxis()->CenterTitle();
  pSigCorVsPlane->GetYaxis()->CenterTitle();
  pSigCorVsPlane->SetMarkerStyle(3);
  pSigCorVsPlane->SetMarkerColor(2);
  pSigCorVsPlane->SetMarkerSize(0.2);
  pSigCorVsPlane->SetLineColor(2);
  cSigCorVsPlane->cd(2);
  gPlaneVsNum->Draw("AP");
  gPlaneVsNum->SetTitle("Number hits");
  gPlaneVsNum->GetXaxis()->SetTitle("Normalised plane");
  gPlaneVsNum->GetYaxis()->SetTitle("Num hits");
  gPlaneVsNum->GetXaxis()->CenterTitle();
  gPlaneVsNum->GetYaxis()->CenterTitle();
  gPlaneVsNum->SetMarkerStyle(3);
  gPlaneVsNum->SetMarkerColor(2);
  gPlaneVsNum->SetMarkerSize(0.8);

  TCanvas *cSigCorVsPlane2=new TCanvas("cSigCorVsPlane2",
                                       "SigCorVsPlane2",
                                       0,0,1200,800);
  cSigCorVsPlane2->SetFillColor(0);
  cSigCorVsPlane2->Divide(1,2);
  cSigCorVsPlane2->cd(1);
  pSigCorVsOsPlane->Draw();
  pSigCorVsOsPlane->SetTitle("Energy Deposition (SigCor)");
  pSigCorVsOsPlane->GetXaxis()->SetTitle("Plane");
  pSigCorVsOsPlane->GetYaxis()->SetTitle("Average SigCor");
  pSigCorVsOsPlane->GetXaxis()->CenterTitle();
  pSigCorVsOsPlane->GetYaxis()->CenterTitle();
  pSigCorVsOsPlane->SetMarkerStyle(3);
  pSigCorVsOsPlane->SetMarkerColor(3);
  pSigCorVsOsPlane->SetMarkerSize(0.4);
  pSigCorVsOsPlane->SetLineColor(3);
  cSigCorVsPlane2->cd(2);
  gPlaneVsNumOS->Draw("AP");
  gPlaneVsNumOS->SetTitle("Number hits");
  gPlaneVsNumOS->GetXaxis()->SetTitle("Normalised plane");
  gPlaneVsNumOS->GetYaxis()->SetTitle("Num hits");
  gPlaneVsNumOS->GetXaxis()->CenterTitle();
  gPlaneVsNumOS->GetYaxis()->CenterTitle();
  gPlaneVsNumOS->SetMarkerStyle(3);
  gPlaneVsNumOS->SetMarkerColor(2);
  gPlaneVsNumOS->SetMarkerSize(0.8);

  TCanvas *cResponseOS=new TCanvas("cResponseOS","ResponseOS",
                                   0,0,1200,800);
  cResponseOS->SetFillColor(0);
  cResponseOS->Divide(1,2);
  cResponseOS->cd(1);
  gPlaneVsAvSigCorOS->Draw("AP");
  gPlaneVsAvSigCorOS->SetTitle("Muon Energy Deposition");
  gPlaneVsAvSigCorOS->GetXaxis()->SetTitle("Normalised plane");
  gPlaneVsAvSigCorOS->GetYaxis()->SetTitle("Average SigCor");
  gPlaneVsAvSigCorOS->GetXaxis()->CenterTitle();
  gPlaneVsAvSigCorOS->GetYaxis()->CenterTitle();
  gPlaneVsAvSigCorOS->SetMarkerStyle(3);
  gPlaneVsAvSigCorOS->SetMarkerColor(2);
  gPlaneVsAvSigCorOS->SetMarkerSize(0.8);
  gPlaneVsAvSigCorOS2->Draw("P");
  gPlaneVsAvSigCorOS2->SetMarkerStyle(3);
  gPlaneVsAvSigCorOS2->SetMarkerColor(3);
  gPlaneVsAvSigCorOS2->SetMarkerSize(0.8);
  gPlaneVsAvSigCorOS3->Draw("P");
  gPlaneVsAvSigCorOS3->SetMarkerStyle(3);
  gPlaneVsAvSigCorOS3->SetMarkerColor(4);
  gPlaneVsAvSigCorOS3->SetMarkerSize(0.8);
  cResponseOS->cd(2);
  gPlaneVsNumOS->Draw("AP");
  gPlaneVsNumOS->SetTitle("Number hits");
  gPlaneVsNumOS->GetXaxis()->SetTitle("Normalised plane");
  gPlaneVsNumOS->GetYaxis()->SetTitle("Num hits");
  gPlaneVsNumOS->GetXaxis()->CenterTitle();
  gPlaneVsNumOS->GetYaxis()->CenterTitle();
  gPlaneVsNumOS->SetMarkerStyle(3);
  gPlaneVsNumOS->SetMarkerColor(2);
  gPlaneVsNumOS->SetMarkerSize(0.8);
  gPlaneVsNumOS2->Draw("P");
  gPlaneVsNumOS2->SetMarkerStyle(3);
  gPlaneVsNumOS2->SetMarkerColor(3);
  gPlaneVsNumOS2->SetMarkerSize(0.8);
  gPlaneVsNumOS3->Draw("P");
  gPlaneVsNumOS3->SetMarkerStyle(3);
  gPlaneVsNumOS3->SetMarkerColor(4);
  gPlaneVsNumOS3->SetMarkerSize(0.8);

  TCanvas *cResponse=new TCanvas("cResponse","Response",
                                   0,0,1200,800);
  cResponse->SetFillColor(0);
  cResponse->Divide(1,2);
  cResponse->cd(1);
  gPlaneVsAvSigCor->Draw("AP");
  gPlaneVsAvSigCor->SetTitle("Muon Energy Deposition");
  gPlaneVsAvSigCor->GetXaxis()->SetTitle("Plane");
  gPlaneVsAvSigCor->GetYaxis()->SetTitle("Average SigCor");
  gPlaneVsAvSigCor->GetXaxis()->CenterTitle();
  gPlaneVsAvSigCor->GetYaxis()->CenterTitle();
  gPlaneVsAvSigCor->SetMarkerStyle(3);
  gPlaneVsAvSigCor->SetMarkerColor(2);
  gPlaneVsAvSigCor->SetMarkerSize(0.8);
  gPlaneVsAvSigCor2->Draw("P");
  gPlaneVsAvSigCor2->SetMarkerStyle(3);
  gPlaneVsAvSigCor2->SetMarkerColor(3);
  gPlaneVsAvSigCor2->SetMarkerSize(0.8);
  gPlaneVsAvSigCor3->Draw("P");
  gPlaneVsAvSigCor3->SetMarkerStyle(3);
  gPlaneVsAvSigCor3->SetMarkerColor(4);
  gPlaneVsAvSigCor3->SetMarkerSize(0.8);
  cResponse->cd(2);
  gPlaneVsNum->Draw("AP");
  gPlaneVsNum->SetTitle("Number hits");
  gPlaneVsNum->GetXaxis()->SetTitle("Plane");
  gPlaneVsNum->GetYaxis()->SetTitle("Num hits");
  gPlaneVsNum->GetXaxis()->CenterTitle();
  gPlaneVsNum->GetYaxis()->CenterTitle();
  gPlaneVsNum->SetMarkerStyle(3);
  gPlaneVsNum->SetMarkerColor(2);
  gPlaneVsNum->SetMarkerSize(0.8);
  gPlaneVsNum2->Draw("P");
  gPlaneVsNum2->SetMarkerStyle(3);
  gPlaneVsNum2->SetMarkerColor(3);
  gPlaneVsNum2->SetMarkerSize(0.8);
  gPlaneVsNum3->Draw("P");
  gPlaneVsNum3->SetMarkerStyle(3);
  gPlaneVsNum3->SetMarkerColor(4);
  gPlaneVsNum3->SetMarkerSize(0.8);

  /*
  TCanvas *cResults=new TCanvas("cResults","Results",0,0,1200,800);
  cResults->SetFillColor(0);
  cResults->Divide(2,2);
  cResults->cd(1);
  hEvenResult->Draw();
  cResults->cd(2);
  hOddResult->Draw();
  */

  TCanvas *cKov=new TCanvas("cKov","Kov",0,0,1200,800);
  cKov->SetFillColor(0);
  cKov->Divide(3,2);
  cKov->cd(1);
  hKovADC3->Draw();
  cKov->cd(2);
  hKovADC3Cut->Draw();
  cKov->cd(5);
  hKovADC1->Draw();
  cKov->cd(4);
  hKovADC1Cut->Draw();
  cKov->cd(3);
  hKovADC3Whole->Draw();
  cKov->cd(6);
  hKovADC1Whole->Draw();

  TCanvas *cTof=new TCanvas("cTof","Tof",0,0,1200,800);
  cTof->SetFillColor(0);
  hTofDiffNotElec->Draw();
  hTofDiffNotElec->SetLineColor(2);
  hTofDiffNotElec->SetLineWidth(3);
  hTofDiffElec->Draw("sames");
  hTofDiffElec->SetLineWidth(3);

  TCanvas *cTofAll=new TCanvas("cTofAll","cTofAll",0,0,1200,800);
  cTofAll->SetFillColor(0);
  cTofAll->Divide(3,2);
  cTofAll->cd(1);
  hTofTDC0->Draw();
  cTofAll->cd(2);
  hTofTDC2->Draw();
  cTofAll->cd(3);
  hTofDiff->Draw();
  cTofAll->cd(4);
  hTofTDC0Whole->Draw();
  cTofAll->cd(5);
  hTofTDC2Whole->Draw();
  cTofAll->cd(6);
  hTofDiffWhole->Draw();

  TCanvas *cTofKovDiff=new TCanvas("cTofKovDiff","TofKovDiff",
                                   0,0,1200,800);
  cTofKovDiff->SetFillColor(0);
  cTofKovDiff->Divide(2,2);
  cTofKovDiff->cd(1);
  hTofKov1Diff->Draw();
  cTofKovDiff->cd(2);
  hTofKov3Diff->Draw();
  cTofKovDiff->cd(3);
  hTofKov1DiffWhole->Draw();
  cTofKovDiff->cd(4);
  hTofKov3DiffWhole->Draw();

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,3);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hStripend->Draw();
  cGeom->cd(4);
  hNumPlanes->Draw();
  cGeom->cd(5);
  hEventLength->Draw();

  /*
  TCanvas *cHits=new TCanvas("cHits","Hits",0,0,1200,800);
  cHits->SetFillColor(0);
  cHits->Divide(2,3);
  cHits->cd(1);
  hChargeSigCor->Draw();
  cHits->cd(2);
  hChargeSigLin->Draw();
  cHits->cd(3);
  hChargePe->Draw();
  cHits->cd(4);
  hGain->Draw();
  cHits->cd(5);
  hAdc->Draw();
  */

  TCanvas *cStVsPl=new TCanvas("cStVsPl","StVsPl",0,0,1200,800);
  cStVsPl->SetFillColor(0);
  cStVsPl->Divide(1,2);
  cStVsPl->cd(1);
  hStVsPl1->Draw("colz");
  cStVsPl->cd(2);
  hStVsPl2->Draw("colz");

  TCanvas *cTime=new TCanvas("cTime","Time",0,0,1200,800);
  cTime->SetFillColor(0);
  cTime->Divide(2,3);
  cTime->cd(1);
  hTime->Draw();
  cTime->cd(2);
  hTime2->Draw();
  cTime->cd(3);

  cTime->cd(4);

  cTime->cd(5);


  /*
 TCanvas *cAngles=new TCanvas("cAngles","Angles",0,0,1200,800);
  cAngles->SetFillColor(0);
  cAngles->Divide(3,2);
  cAngles->cd(1);
  hdzds->Draw();
  cAngles->cd(2);
  hdsdz->Draw();
  cAngles->cd(3);
  hdydz->Draw();
  cAngles->cd(4);
  hdxdz->Draw();
  cAngles->cd(5);
  hdyds->Draw();
  cAngles->cd(6);
  hdxds->Draw();

  TCanvas *cPos=new TCanvas("cPos","Pos",0,0,1200,800);
  cPos->SetFillColor(0);
  cPos->Divide(2,1);
  cPos->cd(1);
  hTransPos->Draw();
  cPos->cd(2);
  hYPos->Draw();
  */

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished CleanMuons method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidateTruth()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateTruth method... **"<<endl;
  
  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hNumDigiScintHits=new TH1F("hNumDigiScintHits",
                                   "NumDigiScintHits",800,-2,250);
  hNumDigiScintHits->GetXaxis()->SetTitle("NumDigiScintHits");
  hNumDigiScintHits->GetXaxis()->CenterTitle();
  hNumDigiScintHits->GetYaxis()->SetTitle("");
  hNumDigiScintHits->GetYaxis()->CenterTitle();
  hNumDigiScintHits->SetFillColor(0);
  hNumDigiScintHits->SetBit(TH1::kCanRebin);

  TH1F *hPmtTruth1=new TH1F("hPmtTruth1","PmtTruth1",400,-2,125);
  hPmtTruth1->GetXaxis()->SetTitle("PmtTruth1");
  hPmtTruth1->GetXaxis()->CenterTitle();
  hPmtTruth1->GetYaxis()->SetTitle("");
  hPmtTruth1->GetYaxis()->CenterTitle();
  hPmtTruth1->SetFillColor(0);
  hPmtTruth1->SetBit(TH1::kCanRebin);

  TH1F *hPmtTruth2=new TH1F("hPmtTruth2","PmtTruth2",400,-2,125);
  hPmtTruth2->GetXaxis()->SetTitle("PmtTruth2");
  hPmtTruth2->GetXaxis()->CenterTitle();
  hPmtTruth2->GetYaxis()->SetTitle("");
  hPmtTruth2->GetYaxis()->CenterTitle();
  hPmtTruth2->SetFillColor(0);
  hPmtTruth2->SetBit(TH1::kCanRebin);

  TH1F *hVaChip1=new TH1F("hVaChip1","VaChip1",50,-2,5);
  hVaChip1->GetXaxis()->SetTitle("VaChip1");
  hVaChip1->GetXaxis()->CenterTitle();
  hVaChip1->GetYaxis()->SetTitle("");
  hVaChip1->GetYaxis()->CenterTitle();
  hVaChip1->SetFillColor(0);
  hVaChip1->SetBit(TH1::kCanRebin);

  TH1F *hVaChip2=new TH1F("hVaChip2","VaChip2",50,-2,5);
  hVaChip2->GetXaxis()->SetTitle("VaChip2");
  hVaChip2->GetXaxis()->CenterTitle();
  hVaChip2->GetYaxis()->SetTitle("");
  hVaChip2->GetYaxis()->CenterTitle();
  hVaChip2->SetFillColor(0);
  hVaChip2->SetBit(TH1::kCanRebin);

  TH1F *hMainParticle=new TH1F("hMainParticle","MainParticle",200,-20,20);
  hMainParticle->GetXaxis()->SetTitle("MainParticle");
  hMainParticle->GetXaxis()->CenterTitle();
  hMainParticle->GetYaxis()->SetTitle("");
  hMainParticle->GetYaxis()->CenterTitle();
  hMainParticle->SetFillColor(0);
  hMainParticle->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDep=new TH1F("hTotalEnDep","TotalEnDep",
                             500,-5./1000,15./1000);
  hTotalEnDep->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDep->GetXaxis()->CenterTitle();
  hTotalEnDep->GetYaxis()->SetTitle("");
  hTotalEnDep->GetYaxis()->CenterTitle();
  hTotalEnDep->SetFillColor(0);
  hTotalEnDep->SetBit(TH1::kCanRebin);

  TH1F *hMainPartEn=new TH1F("hMainPartEn","MainPartEn",500,-0.5,2);
  hMainPartEn->GetXaxis()->SetTitle("MainPartEn");
  hMainPartEn->GetXaxis()->CenterTitle();
  hMainPartEn->GetYaxis()->SetTitle("");
  hMainPartEn->GetYaxis()->CenterTitle();
  hMainPartEn->SetFillColor(0);
  hMainPartEn->SetBit(TH1::kCanRebin);

  TH1F *hMainPathLength=new TH1F("hMainPathLength","MainPathLength",
                                 500,-0.01,0.1);
  hMainPathLength->GetXaxis()->SetTitle("MainPathLength");
  hMainPathLength->GetXaxis()->CenterTitle();
  hMainPathLength->GetYaxis()->SetTitle("");
  hMainPathLength->GetYaxis()->CenterTitle();
  hMainPathLength->SetFillColor(0);
  hMainPathLength->SetBit(TH1::kCanRebin);
  
  TH1F *hEarliestT1=new TH1F("hEarliestT1","EarliestT1",
                             2000,-2e-9,20e-9);
  hEarliestT1->GetXaxis()->SetTitle("T1");
  hEarliestT1->GetXaxis()->CenterTitle();
  hEarliestT1->GetYaxis()->SetTitle("");
  hEarliestT1->GetYaxis()->CenterTitle();
  hEarliestT1->SetFillColor(0);
  hEarliestT1->SetBit(TH1::kCanRebin);

  TH1F *hLatestT2=new TH1F("hLatestT2","LatestT2",2000,-2e-9,20e-9);
  hLatestT2->GetXaxis()->SetTitle("T1");
  hLatestT2->GetXaxis()->CenterTitle();
  hLatestT2->GetYaxis()->SetTitle("");
  hLatestT2->GetYaxis()->CenterTitle();
  hLatestT2->SetFillColor(0);
  hLatestT2->SetBit(TH1::kCanRebin);

  TH1F *hMainT1=new TH1F("hMainT1","MainT1",2000,-1e-9,20e-9);
  hMainT1->GetXaxis()->SetTitle("T1");
  hMainT1->GetXaxis()->CenterTitle();
  hMainT1->GetYaxis()->SetTitle("");
  hMainT1->GetYaxis()->CenterTitle();
  hMainT1->SetFillColor(0);
  hMainT1->SetBit(TH1::kCanRebin);

  TH1F *hMainT1b=new TH1F("hMainT1b","MainT1b",2000,-1e-9,20e-9);
  hMainT1b->GetXaxis()->SetTitle("T1");
  hMainT1b->GetXaxis()->CenterTitle();
  hMainT1b->GetYaxis()->SetTitle("");
  hMainT1b->GetYaxis()->CenterTitle();
  hMainT1b->SetFillColor(0);
  //hMainT1b->SetBit(TH1::kCanRebin);

  TH1F *hMainX1=new TH1F("hMainX1","MainX1",2000,-0.6,0.6);
  hMainX1->GetXaxis()->SetTitle("X1");
  hMainX1->GetXaxis()->CenterTitle();
  hMainX1->GetYaxis()->SetTitle("");
  hMainX1->GetYaxis()->CenterTitle();
  hMainX1->SetFillColor(0);
  hMainX1->SetBit(TH1::kCanRebin);

  TH1F *hMainY1=new TH1F("hMainY1","MainY1",8000,-0.025,0.025);
  hMainY1->GetXaxis()->SetTitle("Y1");
  hMainY1->GetXaxis()->CenterTitle();
  hMainY1->GetYaxis()->SetTitle("");
  hMainY1->GetYaxis()->CenterTitle();
  hMainY1->SetFillColor(0);
  hMainY1->SetBit(TH1::kCanRebin);

  TH1F *hMainZ1=new TH1F("hMainZ1","MainZ1",8000,-0.007,0.007);
  hMainZ1->GetXaxis()->SetTitle("Z1");
  hMainZ1->GetXaxis()->CenterTitle();
  hMainZ1->GetYaxis()->SetTitle("");
  hMainZ1->GetYaxis()->CenterTitle();
  hMainZ1->SetFillColor(0);
  hMainZ1->SetBit(TH1::kCanRebin);

  TH1F *hMainT2=new TH1F("hMainT2","MainT2",2000,-1e-9,20e-9);
  hMainT2->GetXaxis()->SetTitle("T2");
  hMainT2->GetXaxis()->CenterTitle();
  hMainT2->GetYaxis()->SetTitle("");
  hMainT2->GetYaxis()->CenterTitle();
  hMainT2->SetFillColor(0);
  hMainT2->SetBit(TH1::kCanRebin);

  TH1F *hMainT2b=new TH1F("hMainT2b","MainT2b",2000,-1e-9,20e-9);
  hMainT2b->GetXaxis()->SetTitle("T2");
  hMainT2b->GetXaxis()->CenterTitle();
  hMainT2b->GetYaxis()->SetTitle("");
  hMainT2b->GetYaxis()->CenterTitle();
  hMainT2b->SetFillColor(0);
  //hMainT2b->SetBit(TH1::kCanRebin);

  TH1F *hMainX2=new TH1F("hMainX2","MainX2",2000,-0.6,0.6);
  hMainX2->GetXaxis()->SetTitle("X2");
  hMainX2->GetXaxis()->CenterTitle();
  hMainX2->GetYaxis()->SetTitle("");
  hMainX2->GetYaxis()->CenterTitle();
  hMainX2->SetFillColor(0);
  hMainX2->SetBit(TH1::kCanRebin);

  TH1F *hMainY2=new TH1F("hMainY2","MainY2",8000,-0.025,0.025);
  hMainY2->GetXaxis()->SetTitle("Y2");
  hMainY2->GetXaxis()->CenterTitle();
  hMainY2->GetYaxis()->SetTitle("");
  hMainY2->GetYaxis()->CenterTitle();
  hMainY2->SetFillColor(0);
  hMainY2->SetBit(TH1::kCanRebin);

  TH1F *hMainZ2=new TH1F("hMainZ2","MainZ2",8000,-0.007,0.007);
  hMainZ2->GetXaxis()->SetTitle("Z2");
  hMainZ2->GetXaxis()->CenterTitle();
  hMainZ2->GetYaxis()->SetTitle("");
  hMainZ2->GetYaxis()->CenterTitle();
  hMainZ2->SetFillColor(0);
  hMainZ2->SetBit(TH1::kCanRebin);

  TH2F *hXvsY=new TH2F("hXvsY","XvsY",200,-0.025,0.025,200,-0.6,0.6);
  hXvsY->GetXaxis()->SetTitle("Y");
  hXvsY->GetXaxis()->CenterTitle();
  hXvsY->GetYaxis()->SetTitle("X");
  hXvsY->GetYaxis()->CenterTitle();
  hXvsY->SetFillColor(0);
  hXvsY->SetBit(TH1::kCanRebin);

  TH2F *hZvsY=new TH2F("hZvsY","ZvsY",200,-0.025,0.025,
                       200,-0.007,0.007);
  hZvsY->GetXaxis()->SetTitle("Y");
  hZvsY->GetXaxis()->CenterTitle();
  hZvsY->GetYaxis()->SetTitle("Z");
  hZvsY->GetYaxis()->CenterTitle();
  hZvsY->SetFillColor(0);
  hZvsY->SetBit(TH1::kCanRebin);

  TH1F *hTrueDistToCentre=new TH1F("hTrueDistToCentre",
                                   "hTrueDistToCentre",400,-1.5,1.0);
  hTrueDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hTrueDistToCentre->GetXaxis()->CenterTitle();
  hTrueDistToCentre->GetYaxis()->SetTitle("");
  hTrueDistToCentre->GetYaxis()->CenterTitle();
  hTrueDistToCentre->SetFillColor(0);
  hTrueDistToCentre->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (!fTruthHitInfo) break;

    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    MSG("CDAnalysis",Msg::kDebug)
      <<"Event="<<event
      <<", truthHits="<<numTruthHits<<endl;

    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
      
      const Int_t plane=hitInfo->GetPlane();
      const Int_t strip=hitInfo->GetStrip();
      const Int_t mainParticle=hitInfo->GetMainParticle();
      const Double_t totalEnDep=hitInfo->GetTotalEnDep();
      const Double_t mainPartEn=hitInfo->GetMainPartEn();
      const Double_t mainPathLength=hitInfo->GetMainPathLength();
      const Double_t numDigiScintHits=hitInfo->GetNumDigiScintHits();
      const Int_t pmtTruth1=hitInfo->GetPmtTruth1();
      const Int_t pmtTruth2=hitInfo->GetPmtTruth2();
      const Int_t vaChip1=hitInfo->GetVaChip1();
      const Int_t vaChip2=hitInfo->GetVaChip2();
      
      const Double_t mainT1=hitInfo->GetMainT1();
      const Double_t mainX1=hitInfo->GetMainX1();
      const Double_t mainY1=hitInfo->GetMainY1();
      const Double_t mainZ1=hitInfo->GetMainZ1();
      const Double_t mainT2=hitInfo->GetMainT2();
      const Double_t mainX2=hitInfo->GetMainX2();
      const Double_t mainY2=hitInfo->GetMainY2();
      const Double_t mainZ2=hitInfo->GetMainZ2();

      const Double_t earliestT1=hitInfo->GetEarliestT1();
      const Double_t latestT2=hitInfo->GetLatestT2();

      //if (plane==0) continue;

      hPlane->Fill(plane);
      hStrip->Fill(strip);
      hMainParticle->Fill(mainParticle);
      hTotalEnDep->Fill(totalEnDep);
      hMainPartEn->Fill(mainPartEn);
      hMainPathLength->Fill(mainPathLength);
      hPmtTruth1->Fill(pmtTruth1);
      hPmtTruth2->Fill(pmtTruth2);
      hVaChip1->Fill(vaChip1);
      hVaChip2->Fill(vaChip2);
      hMainT1->Fill(mainT1);
      hMainT1b->Fill(mainT1);
      hMainX1->Fill(mainX1);
      hMainY1->Fill(mainY1);
      hMainZ1->Fill(mainZ1);
      hMainT2->Fill(mainT2);
      hMainT2b->Fill(mainT2);
      hMainX2->Fill(mainX2);
      hMainY2->Fill(mainY2);
      hMainZ2->Fill(mainZ2);
      hEarliestT1->Fill(earliestT1);
      hLatestT2->Fill(latestT2);
      hNumDigiScintHits->Fill(numDigiScintHits);
      if (mainY1!=0) hXvsY->Fill(mainY1,mainX1);
      if (mainY2!=0) hXvsY->Fill(mainY2,mainX2);
      if (mainY1!=0) hZvsY->Fill(mainY1,mainZ1);
      if (mainY2!=0) hZvsY->Fill(mainY2,mainZ2);

      Float_t dist=this->TrueDistToPlaneCentre(strip,
                                               (mainX1+mainX2)*0.5);
      hTrueDistToCentre->Fill(dist);

      //
      if (earliestT1>0.15e-4){
        MSG("CDAnalysis",Msg::kDebug)
          <<"eT1="<<earliestT1<<", lT2="<<latestT2<<endl;
      }
    }
    
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,3);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hVaChip1->Draw();
  cGeom->cd(4);
  hVaChip2->Draw();
  cGeom->cd(5);
  hTrueDistToCentre->Draw();

  TCanvas *cMainParticle=new TCanvas("cMainParticle",
                                     "MainParticle",0,0,1200,800);
  cMainParticle->SetFillColor(0);
  cMainParticle->Divide(2,2);
  cMainParticle->cd(1);
  hMainParticle->Draw();
  cMainParticle->cd(2);
  hTotalEnDep->Draw();
  cMainParticle->cd(3);
  hMainPartEn->Draw();
  cMainParticle->cd(4);
  hMainPathLength->Draw();

  TCanvas *cTruth=new TCanvas("cTruth","Truth",0,0,1200,800);
  cTruth->SetFillColor(0);
  cTruth->Divide(2,2);
  cTruth->cd(1);
  hPmtTruth1->Draw();
  cTruth->cd(2);
  hPmtTruth2->Draw();
  cTruth->cd(3);
  hNumDigiScintHits->Draw();

  TCanvas *cT=new TCanvas("cT","T",0,0,800,800);
  cT->SetFillColor(0);
  cT->Divide(2,3);
  cT->cd(1);
  hMainT1->Draw();
  cT->cd(2);
  hMainT2->Draw();
  cT->cd(3);
  hMainT1b->Draw();
  cT->cd(4);
  hMainT2b->Draw();
  cT->cd(5);
  hEarliestT1->Draw();
  cT->cd(6);
  hLatestT2->Draw();

  TCanvas *cXYZ=new TCanvas("cXYZ","XYZ",0,0,800,800);
  cXYZ->SetFillColor(0);
  cXYZ->Divide(2,3);
  cXYZ->cd(1);
  hMainX1->Draw();
  cXYZ->cd(2);
  hMainX2->Draw();
  cXYZ->cd(3);
  hMainY1->Draw();
  cXYZ->cd(4);
  hMainY2->Draw();
  cXYZ->cd(5);
  hMainZ1->Draw();
  cXYZ->cd(6);
  hMainZ2->Draw();

  TCanvas *cXvsY=new TCanvas("cXvsY","XvsY",0,0,1200,800);
  cXvsY->SetFillColor(0);
  hXvsY->Draw("colz");

  TCanvas *cZvsY=new TCanvas("cZvsY","ZvsY",0,0,1200,800);
  cZvsY->SetFillColor(0);
  hZvsY->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateTruth method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidateReco()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateReco method... **"<<endl;

  TH1F *hTransPos=new TH1F("hTransPos","hTransPos",400,-1,25);
  hTransPos->GetXaxis()->SetTitle("transPos");
  hTransPos->GetXaxis()->CenterTitle();
  hTransPos->GetYaxis()->SetTitle("");
  hTransPos->GetYaxis()->CenterTitle();
  hTransPos->SetFillColor(0);
  hTransPos->SetBit(TH1::kCanRebin);

  TH1F *hTrueX=new TH1F("hTrueX","hTrueX",1000,-1.5,1.5);
  hTrueX->GetXaxis()->SetTitle("trueX");
  hTrueX->GetXaxis()->CenterTitle();
  hTrueX->GetYaxis()->SetTitle("");
  hTrueX->GetYaxis()->CenterTitle();
  hTrueX->SetFillColor(0);
  hTrueX->SetBit(TH1::kCanRebin);

  TH1F *hLargestRadius=new TH1F("hLargestRadius",
                                "hLargestRadius",1000,-1.5,1.5);
  hLargestRadius->GetXaxis()->SetTitle("radius");
  hLargestRadius->GetXaxis()->CenterTitle();
  hLargestRadius->GetYaxis()->SetTitle("");
  hLargestRadius->GetYaxis()->CenterTitle();
  hLargestRadius->SetFillColor(0);
  hLargestRadius->SetBit(TH1::kCanRebin);

  TH1F *hLargestTrueRadius=new TH1F("hLargestTrueRadius",
                                "hLargestTrueRadius",1000,-1.5,1.5);
  hLargestTrueRadius->GetXaxis()->SetTitle("radius");
  hLargestTrueRadius->GetXaxis()->CenterTitle();
  hLargestTrueRadius->GetYaxis()->SetTitle("");
  hLargestTrueRadius->GetYaxis()->CenterTitle();
  hLargestTrueRadius->SetFillColor(0);
  hLargestTrueRadius->SetBit(TH1::kCanRebin);

  TH1F *hDeltaLargestRadius=new TH1F("hDeltaLargestRadius",
                                "hDeltaLargestRadius",1000,-1.5,1.5);
  hDeltaLargestRadius->GetXaxis()->SetTitle("radius");
  hDeltaLargestRadius->GetXaxis()->CenterTitle();
  hDeltaLargestRadius->GetYaxis()->SetTitle("");
  hDeltaLargestRadius->GetYaxis()->CenterTitle();
  hDeltaLargestRadius->SetFillColor(0);
  hDeltaLargestRadius->SetBit(TH1::kCanRebin);

  TH1F *hRecoDistToCentre=new TH1F("hRecoDistToCentre",
                                   "hRecoDistToCentre",400,-1.5,1.0);
  hRecoDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hRecoDistToCentre->GetXaxis()->CenterTitle();
  hRecoDistToCentre->GetYaxis()->SetTitle("");
  hRecoDistToCentre->GetYaxis()->CenterTitle();
  hRecoDistToCentre->SetFillColor(0);
  hRecoDistToCentre->SetBit(TH1::kCanRebin);

  TH1F *hTrueDistToCentre=new TH1F("hTrueDistToCentre",
                                   "hTrueDistToCentre",400,-1.5,1.0);
  hTrueDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hTrueDistToCentre->GetXaxis()->CenterTitle();
  hTrueDistToCentre->GetYaxis()->SetTitle("");
  hTrueDistToCentre->GetYaxis()->CenterTitle();
  hTrueDistToCentre->SetFillColor(0);
  hTrueDistToCentre->SetBit(TH1::kCanRebin);

  TH1F *hDeltaDistToCentre=new TH1F("hDeltaDistToCentre",
                                   "hDeltaDistToCentre (truth-x)",
                                    800,-1.5,1.0);
  hDeltaDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hDeltaDistToCentre->GetXaxis()->CenterTitle();
  hDeltaDistToCentre->GetYaxis()->SetTitle("");
  hDeltaDistToCentre->GetYaxis()->CenterTitle();
  hDeltaDistToCentre->SetFillColor(0);
  hDeltaDistToCentre->SetBit(TH1::kCanRebin);

  TH2F* hDistVsTrueDist=new TH2F("hDistVsTrueDist","hDistVsTrueDist",
                                 100,0,0.7,100,0,0.7);
  hDistVsTrueDist->GetXaxis()->SetTitle("TrueDist");
  hDistVsTrueDist->GetXaxis()->CenterTitle();
  hDistVsTrueDist->GetYaxis()->SetTitle("RecoDist");
  hDistVsTrueDist->GetYaxis()->CenterTitle();
  hDistVsTrueDist->SetFillColor(0);
  //hDistVsTrueDist->SetMaximum(15000);

  TH2F* hXVsTrueX=new TH2F("hXVsTrueX","hXVsTrueX",
                                 100,-0.5,0.5,100,-0.5,0.5);
  hXVsTrueX->GetXaxis()->SetTitle("TrueX");
  hXVsTrueX->GetXaxis()->CenterTitle();
  hXVsTrueX->GetYaxis()->SetTitle("mod(X)");
  hXVsTrueX->GetYaxis()->CenterTitle();
  hXVsTrueX->SetFillColor(0);
  //hXVsTrueX->SetMaximum(15000);

  Int_t totalCounter=0;
  Int_t notStraightCounter=0;
  Int_t recoFailures=0;
  Int_t recoFailures2Sig=0;
  Int_t straightTrackCounterTrue=0;
  Int_t straightTrackCounter=0;
  Int_t straightTrackCounterBoth=0;
  
  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //cut on straight tracks
    //Double_t mainX1Cut=0.4;
    //if (this->IsStraightTrack(mainX1Cut)){
    //continue;
    //}

    totalCounter++;

    Bool_t trueStraight=false;
    Bool_t recoStraight=false;
    Double_t radiusCut=0.3;

    //section to count tracks
    if (this->IsStraightTrack_Radius(radiusCut)){
      straightTrackCounterTrue++;
      trueStraight=true;
    }
    if (this->StraightTrack_Radius(radiusCut)){
      straightTrackCounter++;
      recoStraight=true;
    }
    if (recoStraight && trueStraight){
      straightTrackCounterBoth++;
    }

    //now decide if to cut or not
    //if (recoStraight) continue;

    notStraightCounter++;
    Float_t largestRadius=-1;
    Float_t largestTrueRadius=-1;

    //get tclones arrays for this snarl
    TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();

    //loop over the tracked hits
    for (Int_t hit=0;hit<numTrkHits;hit++){
      CDTrackedHitInfo *trackedHitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cTrk[hit]);
          
      this->ReadInHitInfo(trackedHitInfo);

      //calculate the first and last planes
      this->CalcFirstLastPlane(fPlane);

      //calc dist to plane centre
      Float_t dist=this->CalcDistToPlaneCentre(fStrip,fTransPos);
      hRecoDistToCentre->Fill(dist);

      if (dist>largestRadius) largestRadius=dist;

      Float_t trueX=this->TrueXInStripFrame(fPlane,fStrip,event);
      MAXMSG("CDAnalysis",Msg::kVerbose,100)
        <<"trueX="<<trueX<<endl;

      hTransPos->Fill(fTransPos);
      hTrueX->Fill(trueX);

      Float_t distTrue=-1;

      if (trueX!=-1){
        distTrue=this->TrueDistToPlaneCentre(fStrip,trueX);
        if (distTrue>largestTrueRadius) largestTrueRadius=distTrue;
        hTrueDistToCentre->Fill(distTrue);
        
        if (fTransPos>0 && fTransPos<23){
          Float_t transPosFromCentre1=-1;
          if (fTransPos<=11) transPosFromCentre1=11-fTransPos;
          else if (fTransPos>11) transPosFromCentre1=fTransPos-11;
          
          //calc real distance
          Float_t stripSize=0.041;
          Float_t x=transPosFromCentre1*stripSize;
          
          //sanity check
          if (x<0){
            MSG("CDAnalysis",Msg::kInfo)
              <<"x="<<x<<", transpos="<<fTransPos
              <<", transPosFromCentre="<<transPosFromCentre1<<endl;
          }

          hXVsTrueX->Fill(trueX,x);
        }
      }

      if (distTrue!=-1 && dist!=-1){    
        Float_t deltaDist=distTrue-dist;
        //if (deltaDist<0) deltaDist=deltaDist-2*deltaDist;
        hDeltaDistToCentre->Fill(deltaDist);
        hDistVsTrueDist->Fill(distTrue,dist);
      }
    }
    //end of loop over the tracked hits

    //count the reco failures where there was a genuine hit
    //outside the radius cut but no reco hit within error
    if (largestRadius<radiusCut-0.025) recoFailures++; 
    if (largestRadius<radiusCut-0.050) recoFailures2Sig++; 
    hLargestTrueRadius->Fill(largestTrueRadius);
    hLargestRadius->Fill(largestRadius);
    if (largestRadius!=-1 && largestTrueRadius!=-1){
      hDeltaLargestRadius->Fill(largestTrueRadius-largestRadius);
    }
    else{
      hDeltaLargestRadius->Fill(-1);
    }

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cPos=new TCanvas("cPos","cPos",0,0,1200,800);
  cPos->SetFillColor(0);
  cPos->Divide(2,2);
  cPos->cd(1);
  hRecoDistToCentre->Draw();
  cPos->cd(2);
  hTrueDistToCentre->Draw();
  cPos->cd(3);
  hDeltaDistToCentre->Draw();

  TCanvas *cGeom=new TCanvas("cGeom","cGeom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(3,2);
  cGeom->cd(1);
  hTransPos->Draw();
  cGeom->cd(2);
  hTrueX->Draw();
  cGeom->cd(3);
  hLargestRadius->Draw();
  cGeom->cd(4);
  hLargestTrueRadius->Draw();
  cGeom->cd(5);
  hDeltaLargestRadius->Draw();
  
  TCanvas *c2D=new TCanvas("c2D","c2D",0,0,1200,800);
  c2D->SetFillColor(0);
  c2D->Divide(2,1);
  c2D->cd(1);
  hDistVsTrueDist->Draw("colz");
  c2D->cd(2);
  hXVsTrueX->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<"Total events="<<totalCounter<<endl
    <<"Reco Failures at 1Sig="<<recoFailures<<"/"<<notStraightCounter
    <<" ("<<100.*recoFailures/notStraightCounter<<"%)"<<endl
    <<"Reco Failures at 2Sig="
    <<recoFailures2Sig<<"/"<<notStraightCounter
    <<" ("<<100.*recoFailures2Sig/notStraightCounter<<"%)"<<endl
    <<"Straight track counter true="<<straightTrackCounterTrue<<endl
    <<"Straight track counter reco="<<straightTrackCounter<<endl
    <<"Straight track counter both="<<straightTrackCounterBoth<<endl;
  
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateReco method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidateTrkHits()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateTrkHits method... **"<<endl;

  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hStripend=new TH1F("hStripend","Stripend hit",120,-2,10);
  hStripend->GetXaxis()->SetTitle("Stripend");
  hStripend->GetXaxis()->CenterTitle();
  hStripend->GetYaxis()->SetTitle("");
  hStripend->GetYaxis()->CenterTitle();
  hStripend->SetFillColor(0);
  hStripend->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigCor=new TH1F("hChargeSigCor","ChargeSigCor",
                               1000,-2,15000);
  hChargeSigCor->GetXaxis()->SetTitle("ChargeSigCor");
  hChargeSigCor->GetXaxis()->CenterTitle();
  hChargeSigCor->GetYaxis()->SetTitle("");
  hChargeSigCor->GetYaxis()->CenterTitle();
  hChargeSigCor->SetFillColor(0);
  hChargeSigCor->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigLin=new TH1F("hChargeSigLin","ChargeSigLin",
                               1000,-2,15000);
  hChargeSigLin->GetXaxis()->SetTitle("ChargeSigLin");
  hChargeSigLin->GetXaxis()->CenterTitle();
  hChargeSigLin->GetYaxis()->SetTitle("");
  hChargeSigLin->GetYaxis()->CenterTitle();
  hChargeSigLin->SetFillColor(0);
  hChargeSigLin->SetBit(TH1::kCanRebin);

  TH1F *hChargePe=new TH1F("hChargePe","ChargePe",400,-2,400);
  hChargePe->GetXaxis()->SetTitle("ChargePe");
  hChargePe->GetXaxis()->CenterTitle();
  hChargePe->GetYaxis()->SetTitle("");
  hChargePe->GetYaxis()->CenterTitle();
  hChargePe->SetFillColor(0);
  hChargePe->SetBit(TH1::kCanRebin);

  TH1F *hGain=new TH1F("hGain","Gain",1000,-2,150);
  hGain->GetXaxis()->SetTitle("Gain");
  hGain->GetXaxis()->CenterTitle();
  hGain->GetYaxis()->SetTitle("");
  hGain->GetYaxis()->CenterTitle();
  hGain->SetFillColor(0);
  hGain->SetBit(TH1::kCanRebin);

  TH1F *hdzds=new TH1F("hdzds","dzds",400,-2,2);
  hdzds->GetXaxis()->SetTitle("dzds");
  hdzds->GetXaxis()->CenterTitle();
  hdzds->GetYaxis()->SetTitle("");
  hdzds->GetYaxis()->CenterTitle();
  hdzds->SetFillColor(0);
  hdzds->SetBit(TH1::kCanRebin);

  TH1F *hdsdz=new TH1F("hdsdz","dsdz",400,-2,10);
  hdsdz->GetXaxis()->SetTitle("dsdz");
  hdsdz->GetXaxis()->CenterTitle();
  hdsdz->GetYaxis()->SetTitle("");
  hdsdz->GetYaxis()->CenterTitle();
  hdsdz->SetFillColor(0);
  hdsdz->SetBit(TH1::kCanRebin);

  TH1F *hdydz=new TH1F("hdydz","dydz",400,-5,5);
  hdydz->GetXaxis()->SetTitle("dydz");
  hdydz->GetXaxis()->CenterTitle();
  hdydz->GetYaxis()->SetTitle("");
  hdydz->GetYaxis()->CenterTitle();
  hdydz->SetFillColor(0);
  hdydz->SetBit(TH1::kCanRebin);

  TH1F *hdxdz=new TH1F("hdxdz","dxdz",400,-10,10);
  hdxdz->GetXaxis()->SetTitle("dxdz");
  hdxdz->GetXaxis()->CenterTitle();
  hdxdz->GetYaxis()->SetTitle("");
  hdxdz->GetYaxis()->CenterTitle();
  hdxdz->SetFillColor(0);
  hdxdz->SetBit(TH1::kCanRebin);

  TH1F *hdyds=new TH1F("hdyds","dyds",400,-3,3);
  hdyds->GetXaxis()->SetTitle("dyds");
  hdyds->GetXaxis()->CenterTitle();
  hdyds->GetYaxis()->SetTitle("");
  hdyds->GetYaxis()->CenterTitle();
  hdyds->SetFillColor(0);
  hdyds->SetBit(TH1::kCanRebin);

  TH1F *hdxds=new TH1F("hdxds","dxds",400,-3,3);
  hdxds->GetXaxis()->SetTitle("dxds");
  hdxds->GetXaxis()->CenterTitle();
  hdxds->GetYaxis()->SetTitle("");
  hdxds->GetYaxis()->CenterTitle();
  hdxds->SetFillColor(0);
  hdxds->SetBit(TH1::kCanRebin);

  TH1F *hTransPos=new TH1F("hTransPos","TransPos",1000,-2,35);
  hTransPos->GetXaxis()->SetTitle("TransPos");
  hTransPos->GetXaxis()->CenterTitle();
  hTransPos->GetYaxis()->SetTitle("");
  hTransPos->GetYaxis()->CenterTitle();
  hTransPos->SetFillColor(0);
  hTransPos->SetBit(TH1::kCanRebin);

  TH1F *hYPos=new TH1F("hYPos","YPos",1000,-8,8);
  hYPos->GetXaxis()->SetTitle("YPos");
  hYPos->GetXaxis()->CenterTitle();
  hYPos->GetYaxis()->SetTitle("");
  hYPos->GetYaxis()->CenterTitle();
  hYPos->SetFillColor(0);
  hYPos->SetBit(TH1::kCanRebin);

  TH1F *hEvenResult=new TH1F("hEvenResult","EvenResult",100,-5,5);
  hEvenResult->GetXaxis()->SetTitle("EvenResult");
  hEvenResult->GetXaxis()->CenterTitle();
  hEvenResult->GetYaxis()->SetTitle("");
  hEvenResult->GetYaxis()->CenterTitle();
  hEvenResult->SetFillColor(0);
  hEvenResult->SetBit(TH1::kCanRebin);

  TH1F *hOddResult=new TH1F("hOddResult","OddResult",100,-5,5);
  hOddResult->GetXaxis()->SetTitle("OddResult");
  hOddResult->GetXaxis()->CenterTitle();
  hOddResult->GetYaxis()->SetTitle("");
  hOddResult->GetYaxis()->CenterTitle();
  hOddResult->SetFillColor(0);
  hOddResult->SetBit(TH1::kCanRebin);

  TH1F *hRecoDistToCentre=new TH1F("hRecoDistToCentre",
                                   "hRecoDistToCentre",400,-1.5,1.0);
  hRecoDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hRecoDistToCentre->GetXaxis()->CenterTitle();
  hRecoDistToCentre->GetYaxis()->SetTitle("");
  hRecoDistToCentre->GetYaxis()->CenterTitle();
  hRecoDistToCentre->SetFillColor(0);
  hRecoDistToCentre->SetBit(TH1::kCanRebin);

  TH1F *hTrueDistToCentre=new TH1F("hTrueDistToCentre",
                                   "hTrueDistToCentre",400,-1.5,1.0);
  hTrueDistToCentre->GetXaxis()->SetTitle("Distance to plane centre");
  hTrueDistToCentre->GetXaxis()->CenterTitle();
  hTrueDistToCentre->GetYaxis()->SetTitle("");
  hTrueDistToCentre->GetYaxis()->CenterTitle();
  hTrueDistToCentre->SetFillColor(0);
  hTrueDistToCentre->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    hEvenResult->Fill(fTrackInfo->GetResult(0));
    hOddResult->Fill(fTrackInfo->GetResult(1));

    //if(fTrackInfo->GetResult(0)==1 && fTrackInfo->GetResult(1)==1 && 
    // fTrkHitInfo){

        TClonesArray &c = *fTrkHitInfo;
        Int_t numTrkHits = fTrkHitInfo->GetEntries();
        Int_t hit = 0;
        
        while(hit<numTrkHits) {
          CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
          
          Int_t plane=trackedHitInfo->GetPlane();
          Int_t strip=trackedHitInfo->GetStrip();
          Int_t stripend=trackedHitInfo->GetEnd();
          
          hPlane->Fill(plane);
          hStrip->Fill(strip);
          hStripend->Fill(stripend);

          Float_t chargeSigLin=trackedHitInfo->GetCharge
              (CDTrackedHitInfo::kSigLin);
          Float_t chargePe=trackedHitInfo->GetCharge
              (CDTrackedHitInfo::kPe);
          Float_t gain = chargeSigLin/chargePe;

          hChargeSigLin->Fill(chargeSigLin);
          hChargePe->Fill(chargePe);
          hGain->Fill(gain);

          Float_t dzds = trackedHitInfo->GetDzDs();
          Float_t dsdz = 1./dzds;
          Float_t dydz = trackedHitInfo->GetDyDz();
          Float_t dxdz = trackedHitInfo->GetDxDz();
          Float_t dyds = trackedHitInfo->GetDyDz()*
              trackedHitInfo->GetDzDs();
          Float_t dxds = trackedHitInfo->GetDxDz()*
              trackedHitInfo->GetDzDs();
          Float_t transPos = trackedHitInfo->GetTransPos();
          Float_t YPos = trackedHitInfo->GetYPos();

          //calc dist to plane centre
          Float_t dist=this->CalcDistToPlaneCentre(strip,transPos);
          hRecoDistToCentre->Fill(dist);

          hdzds->Fill(dzds);
          hdsdz->Fill(dsdz);
          hdydz->Fill(dydz);
          hdxdz->Fill(dxdz);
          hdyds->Fill(dyds);
          hdxds->Fill(dxds);
          hTransPos->Fill(transPos);
          hYPos->Fill(YPos);

          hit++;
        }
        //      }

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cResults=new TCanvas("cResults","Results",0,0,1200,800);
  cResults->SetFillColor(0);
  cResults->Divide(2,2);
  cResults->cd(1);
  hEvenResult->Draw();
  cResults->cd(2);
  hOddResult->Draw();

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hStripend->Draw();

  TCanvas *cHits=new TCanvas("cHits","Hits",0,0,1200,800);
  cHits->SetFillColor(0);
  cHits->Divide(2,2);
  cHits->cd(1);
  hChargeSigLin->Draw();
  cHits->cd(2);
  hChargePe->Draw();
  cHits->cd(3);
  hGain->Draw();

 TCanvas *cAngles=new TCanvas("cAngles","Angles",0,0,1200,800);
  cAngles->SetFillColor(0);
  cAngles->Divide(3,2);
  cAngles->cd(1);
  hdzds->Draw();
  cAngles->cd(2);
  hdsdz->Draw();
  cAngles->cd(3);
  hdydz->Draw();
  cAngles->cd(4);
  hdxdz->Draw();
  cAngles->cd(5);
  hdyds->Draw();
  cAngles->cd(6);
  hdxds->Draw();

  TCanvas *cPos=new TCanvas("cPos","Pos",0,0,1200,800);
  cPos->SetFillColor(0);
  cPos->Divide(2,2);
  cPos->cd(1);
  hTransPos->Draw();
  cPos->cd(2);
  hYPos->Draw();
  cPos->cd(3);
  hRecoDistToCentre->Draw();


  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateTrkHits method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidateUnTrkHits()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateUnTrkHits method... **"<<endl;

  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hStripend=new TH1F("hStripend","Stripend hit",120,-2,10);
  hStripend->GetXaxis()->SetTitle("Stripend");
  hStripend->GetXaxis()->CenterTitle();
  hStripend->GetYaxis()->SetTitle("");
  hStripend->GetYaxis()->CenterTitle();
  hStripend->SetFillColor(0);
  hStripend->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigLin=new TH1F("hChargeSigLin","ChargeSigLin",
                               1000,-2,15000);
  hChargeSigLin->GetXaxis()->SetTitle("ChargeSigLin");
  hChargeSigLin->GetXaxis()->CenterTitle();
  hChargeSigLin->GetYaxis()->SetTitle("");
  hChargeSigLin->GetYaxis()->CenterTitle();
  hChargeSigLin->SetFillColor(0);
  hChargeSigLin->SetBit(TH1::kCanRebin);

  TH1F *hChargePe=new TH1F("hChargePe","ChargePe",400,-2,400);
  hChargePe->GetXaxis()->SetTitle("ChargePe");
  hChargePe->GetXaxis()->CenterTitle();
  hChargePe->GetYaxis()->SetTitle("");
  hChargePe->GetYaxis()->CenterTitle();
  hChargePe->SetFillColor(0);
  hChargePe->SetBit(TH1::kCanRebin);

  TH1F *hGain=new TH1F("hGain","Gain",1000,-2,150);
  hGain->GetXaxis()->SetTitle("Gain");
  hGain->GetXaxis()->CenterTitle();
  hGain->GetYaxis()->SetTitle("");
  hGain->GetYaxis()->CenterTitle();
  hGain->SetFillColor(0);
  hGain->SetBit(TH1::kCanRebin);

  TH1F *hdzds=new TH1F("hdzds","dzds",400,-2,2);
  hdzds->GetXaxis()->SetTitle("dzds");
  hdzds->GetXaxis()->CenterTitle();
  hdzds->GetYaxis()->SetTitle("");
  hdzds->GetYaxis()->CenterTitle();
  hdzds->SetFillColor(0);
  hdzds->SetBit(TH1::kCanRebin);

  TH1F *hdsdz=new TH1F("hdsdz","dsdz",400,-2,10);
  hdsdz->GetXaxis()->SetTitle("dsdz");
  hdsdz->GetXaxis()->CenterTitle();
  hdsdz->GetYaxis()->SetTitle("");
  hdsdz->GetYaxis()->CenterTitle();
  hdsdz->SetFillColor(0);
  hdsdz->SetBit(TH1::kCanRebin);

  TH1F *hdydz=new TH1F("hdydz","dydz",400,-5,5);
  hdydz->GetXaxis()->SetTitle("dydz");
  hdydz->GetXaxis()->CenterTitle();
  hdydz->GetYaxis()->SetTitle("");
  hdydz->GetYaxis()->CenterTitle();
  hdydz->SetFillColor(0);
  hdydz->SetBit(TH1::kCanRebin);

  TH1F *hdxdz=new TH1F("hdxdz","dxdz",400,-10,10);
  hdxdz->GetXaxis()->SetTitle("dxdz");
  hdxdz->GetXaxis()->CenterTitle();
  hdxdz->GetYaxis()->SetTitle("");
  hdxdz->GetYaxis()->CenterTitle();
  hdxdz->SetFillColor(0);
  hdxdz->SetBit(TH1::kCanRebin);

  TH1F *hdyds=new TH1F("hdyds","dyds",400,-3,3);
  hdyds->GetXaxis()->SetTitle("dyds");
  hdyds->GetXaxis()->CenterTitle();
  hdyds->GetYaxis()->SetTitle("");
  hdyds->GetYaxis()->CenterTitle();
  hdyds->SetFillColor(0);
  hdyds->SetBit(TH1::kCanRebin);

  TH1F *hdxds=new TH1F("hdxds","dxds",400,-3,3);
  hdxds->GetXaxis()->SetTitle("dxds");
  hdxds->GetXaxis()->CenterTitle();
  hdxds->GetYaxis()->SetTitle("");
  hdxds->GetYaxis()->CenterTitle();
  hdxds->SetFillColor(0);
  hdxds->SetBit(TH1::kCanRebin);

  TH1F *hTransPos=new TH1F("hTransPos","TransPos",1000,-2,35);
  hTransPos->GetXaxis()->SetTitle("TransPos");
  hTransPos->GetXaxis()->CenterTitle();
  hTransPos->GetYaxis()->SetTitle("");
  hTransPos->GetYaxis()->CenterTitle();
  hTransPos->SetFillColor(0);
  hTransPos->SetBit(TH1::kCanRebin);

  TH1F *hYPos=new TH1F("hYPos","YPos",1000,-8,8);
  hYPos->GetXaxis()->SetTitle("YPos");
  hYPos->GetXaxis()->CenterTitle();
  hYPos->GetYaxis()->SetTitle("");
  hYPos->GetYaxis()->CenterTitle();
  hYPos->SetFillColor(0);
  hYPos->SetBit(TH1::kCanRebin);

  TH1F *hEvenResult=new TH1F("hEvenResult","EvenResult",100,-5,5);
  hEvenResult->GetXaxis()->SetTitle("EvenResult");
  hEvenResult->GetXaxis()->CenterTitle();
  hEvenResult->GetYaxis()->SetTitle("");
  hEvenResult->GetYaxis()->CenterTitle();
  hEvenResult->SetFillColor(0);
  hEvenResult->SetBit(TH1::kCanRebin);

  TH1F *hOddResult=new TH1F("hOddResult","OddResult",100,-5,5);
  hOddResult->GetXaxis()->SetTitle("OddResult");
  hOddResult->GetXaxis()->CenterTitle();
  hOddResult->GetYaxis()->SetTitle("");
  hOddResult->GetYaxis()->CenterTitle();
  hOddResult->SetFillColor(0);
  hOddResult->SetBit(TH1::kCanRebin);

  MSG("CDAnalysis",Msg::kInfo)<<"Starting main loop..."<<endl;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    hEvenResult->Fill(fTrackInfo->GetResult(0));
    hOddResult->Fill(fTrackInfo->GetResult(1));

    //if(fTrackInfo->GetResult(0)==1 && fTrackInfo->GetResult(1)==1 && 
    // fTrkHitInfo){

    //just need to change this bit to do tracked or untracked
    TClonesArray &c = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    Int_t hit = 0;
    
    while(hit<numUnTrkHits) {
      CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];

      Int_t plane=trackedHitInfo->GetPlane();
      Int_t strip=trackedHitInfo->GetStrip();
      Int_t stripend=trackedHitInfo->GetEnd();
      
      hPlane->Fill(plane);
      hStrip->Fill(strip);
      hStripend->Fill(stripend);
      
      Float_t chargeSigLin=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kSigLin);
      Float_t chargePe=trackedHitInfo->GetCharge
        (CDTrackedHitInfo::kPe);
      Float_t gain =chargeSigLin/chargePe;
      
      hChargeSigLin->Fill(chargeSigLin);
      hChargePe->Fill(chargePe);
      hGain->Fill(gain);
      
      Float_t dzds = trackedHitInfo->GetDzDs();
      Float_t dsdz=-2;
      if (dzds!=0){
        dsdz = 1./dzds;
      }
      Float_t dydz = trackedHitInfo->GetDyDz();
      Float_t dxdz = trackedHitInfo->GetDxDz();
      Float_t dyds = trackedHitInfo->GetDyDz()*
        trackedHitInfo->GetDzDs();
      Float_t dxds = trackedHitInfo->GetDxDz()*
        trackedHitInfo->GetDzDs();
      Float_t TransPos = trackedHitInfo->GetTransPos();
      Float_t YPos = trackedHitInfo->GetYPos();
      
      hdzds->Fill(dzds);
      hdsdz->Fill(dsdz);
      hdydz->Fill(dydz);
      hdxdz->Fill(dxdz);
      hdyds->Fill(dyds);
      hdxds->Fill(dxds);
      hTransPos->Fill(TransPos);
      hYPos->Fill(YPos);
      
      hit++;
    }
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cResults=new TCanvas("cResults","Results",0,0,1200,800);
  cResults->SetFillColor(0);
  cResults->Divide(2,2);
  cResults->cd(1);
  hEvenResult->Draw();
  cResults->cd(2);
  hOddResult->Draw();

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hStripend->Draw();

  TCanvas *cHits=new TCanvas("cHits","Hits",0,0,1200,800);
  cHits->SetFillColor(0);
  cHits->Divide(2,2);
  cHits->cd(1);
  hChargeSigLin->Draw();
  cHits->cd(2);
  hChargePe->Draw();
  cHits->cd(3);
  hGain->Draw();

 TCanvas *cAngles=new TCanvas("cAngles","Angles",0,0,1200,800);
  cAngles->SetFillColor(0);
  cAngles->Divide(3,2);
  cAngles->cd(1);
  hdzds->Draw();
  cAngles->cd(2);
  hdsdz->Draw();
  cAngles->cd(3);
  hdydz->Draw();
  cAngles->cd(4);
  hdxdz->Draw();
  cAngles->cd(5);
  hdyds->Draw();
  cAngles->cd(6);
  hdxds->Draw();

  TCanvas *cPos=new TCanvas("cPos","Pos",0,0,1200,800);
  cPos->SetFillColor(0);
  cPos->Divide(2,1);
  cPos->cd(1);
  hTransPos->Draw();
  cPos->cd(2);
  hYPos->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateUnTrkHits method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidateXTalkHits()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateXTalkHits method... **"<<endl;

  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hStripend=new TH1F("hStripend","Stripend hit",120,-2,10);
  hStripend->GetXaxis()->SetTitle("Stripend");
  hStripend->GetXaxis()->CenterTitle();
  hStripend->GetYaxis()->SetTitle("");
  hStripend->GetYaxis()->CenterTitle();
  hStripend->SetFillColor(0);
  hStripend->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hChargeSigLin=new TH1F("hChargeSigLin","ChargeSigLin",
                               1000,-2,15000);
  hChargeSigLin->GetXaxis()->SetTitle("ChargeSigLin");
  hChargeSigLin->GetXaxis()->CenterTitle();
  hChargeSigLin->GetYaxis()->SetTitle("");
  hChargeSigLin->GetYaxis()->CenterTitle();
  hChargeSigLin->SetFillColor(0);
  hChargeSigLin->SetBit(TH1::kCanRebin);

  TH1F *hChargePe=new TH1F("hChargePe","ChargePe",400,-2,400);
  hChargePe->GetXaxis()->SetTitle("ChargePe");
  hChargePe->GetXaxis()->CenterTitle();
  hChargePe->GetYaxis()->SetTitle("");
  hChargePe->GetYaxis()->CenterTitle();
  hChargePe->SetFillColor(0);
  hChargePe->SetBit(TH1::kCanRebin);

  TH1F *hGain=new TH1F("hGain","Gain",1000,-2,150);
  hGain->GetXaxis()->SetTitle("Gain");
  hGain->GetXaxis()->CenterTitle();
  hGain->GetYaxis()->SetTitle("");
  hGain->GetYaxis()->CenterTitle();
  hGain->SetFillColor(0);
  hGain->SetBit(TH1::kCanRebin);

  TH1F *hNumXTalkHits=new TH1F("hNumXTalkHits","NumXTalkHits",400,-2,2);
  hNumXTalkHits->GetXaxis()->SetTitle("NumXTalkHits");
  hNumXTalkHits->GetXaxis()->CenterTitle();
  hNumXTalkHits->GetYaxis()->SetTitle("");
  hNumXTalkHits->GetYaxis()->CenterTitle();
  hNumXTalkHits->SetFillColor(0);
  hNumXTalkHits->SetBit(TH1::kCanRebin);

  TH1F *hPixel=new TH1F("hPixel","Pixel",100,-2,20);
  hPixel->GetXaxis()->SetTitle("Pixel");
  hPixel->GetXaxis()->CenterTitle();
  hPixel->GetYaxis()->SetTitle("");
  hPixel->GetYaxis()->CenterTitle();
  hPixel->SetFillColor(0);
  hPixel->SetBit(TH1::kCanRebin);

  TH1F *hSourceEnd=new TH1F("hSourceEnd","SourceEnd",50,-2,5);
  hSourceEnd->GetXaxis()->SetTitle("SourceEnd");
  hSourceEnd->GetXaxis()->CenterTitle();
  hSourceEnd->GetYaxis()->SetTitle("");
  hSourceEnd->GetYaxis()->CenterTitle();
  hSourceEnd->SetFillColor(0);
  hSourceEnd->SetBit(TH1::kCanRebin);

  TH1F *hSourcePlane=new TH1F("hSourcePlane","SourcePlane",200,-2,75);
  hSourcePlane->GetXaxis()->SetTitle("SourcePlane");
  hSourcePlane->GetXaxis()->CenterTitle();
  hSourcePlane->GetYaxis()->SetTitle("");
  hSourcePlane->GetYaxis()->CenterTitle();
  hSourcePlane->SetFillColor(0);
  hSourcePlane->SetBit(TH1::kCanRebin);

  TH1F *hSourceStrip=new TH1F("hSourceStrip","SourceStrip",100,-2,30);
  hSourceStrip->GetXaxis()->SetTitle("SourceStrip");
  hSourceStrip->GetXaxis()->CenterTitle();
  //hSourceStrip->GetYaxis()->SetTitle("");
  hSourceStrip->GetYaxis()->CenterTitle();
  hSourceStrip->SetFillColor(0);
  hSourceStrip->SetBit(TH1::kCanRebin);

  TH1F *hSourcePixel=new TH1F("hSourcePixel","SourcePixel",100,-2,20);
  hSourcePixel->GetXaxis()->SetTitle("SourcePixel");
  hSourcePixel->GetXaxis()->CenterTitle();
  hSourcePixel->GetYaxis()->SetTitle("");
  hSourcePixel->GetYaxis()->CenterTitle();
  hSourcePixel->SetFillColor(0);
  hSourcePixel->SetBit(TH1::kCanRebin);

  TH1F *hSourceSpot=new TH1F("hSourceSpot","SourceSpot",400,-2,10);
  hSourceSpot->GetXaxis()->SetTitle("SourceSpot");
  hSourceSpot->GetXaxis()->CenterTitle();
  hSourceSpot->GetYaxis()->SetTitle("");
  hSourceSpot->GetYaxis()->CenterTitle();
  hSourceSpot->SetFillColor(0);
  hSourceSpot->SetBit(TH1::kCanRebin);

  TH1F *hSourceCharge=new TH1F("hSourceCharge","SourceCharge",
                               10000,-2,10000);
  hSourceCharge->GetXaxis()->SetTitle("SourceCharge");
  hSourceCharge->GetXaxis()->CenterTitle();
  hSourceCharge->GetYaxis()->SetTitle("");
  hSourceCharge->GetYaxis()->CenterTitle();
  hSourceCharge->SetFillColor(0);
  hSourceCharge->SetBit(TH1::kCanRebin);

  TH1F *hTime=new TH1F("hTime","Time",10000,-2,2);
  hTime->GetXaxis()->SetTitle("Time");
  hTime->GetXaxis()->CenterTitle();
  hTime->GetYaxis()->SetTitle("");
  hTime->GetYaxis()->CenterTitle();
  hTime->SetFillColor(0);
  hTime->SetBit(TH1::kCanRebin);

  TH1F *hEvenResult=new TH1F("hEvenResult","EvenResult",100,-5,5);
  hEvenResult->GetXaxis()->SetTitle("EvenResult");
  hEvenResult->GetXaxis()->CenterTitle();
  hEvenResult->GetYaxis()->SetTitle("");
  hEvenResult->GetYaxis()->CenterTitle();
  hEvenResult->SetFillColor(0);
  hEvenResult->SetBit(TH1::kCanRebin);

  TH1F *hOddResult=new TH1F("hOddResult","OddResult",100,-5,5);
  hOddResult->GetXaxis()->SetTitle("OddResult");
  hOddResult->GetXaxis()->CenterTitle();
  hOddResult->GetYaxis()->SetTitle("");
  hOddResult->GetYaxis()->CenterTitle();
  hOddResult->SetFillColor(0);
  hOddResult->SetBit(TH1::kCanRebin);

  TH2F *hPmtFace=new TH2F("hPmtFace","PmtFace",6,0,6,6,0,6);
  hPmtFace->GetXaxis()->SetTitle("");
  hPmtFace->GetXaxis()->CenterTitle();
  hPmtFace->GetYaxis()->SetTitle("");
  hPmtFace->GetYaxis()->CenterTitle();
  hPmtFace->SetFillColor(0);
  hPmtFace->SetBit(TH1::kCanRebin);

  TH2F *hSpotVsPix=new TH2F("hSpotVsPix","SpotVsPix",17,0,17,10,0,10);
  hSpotVsPix->GetXaxis()->SetTitle("Pixel");
  hSpotVsPix->GetXaxis()->CenterTitle();
  hSpotVsPix->GetYaxis()->SetTitle("Spot");
  hSpotVsPix->GetYaxis()->CenterTitle();
  hSpotVsPix->SetFillColor(0);
  hSpotVsPix->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    hEvenResult->Fill(fTrackInfo->GetResult(0));
    hOddResult->Fill(fTrackInfo->GetResult(1));

    //if(fTrackInfo->GetResult(0)==1 && fTrackInfo->GetResult(1)==1 && 
    // fTrkHitInfo){

        TClonesArray &c = *fXTalkHits;
        Int_t numHits=fXTalkHits->GetEntries();
        Int_t hit = 0;
        
        while(hit<numHits) {
          CDXTalkHitInfo *xTalkHits=(CDXTalkHitInfo*) c[hit];
          
          Int_t plane=xTalkHits->GetPlane();
          Int_t strip=xTalkHits->GetStrip();
          Int_t stripend=xTalkHits->GetEnd();
          Int_t pixel=xTalkHits->GetPixel();
          
          hPlane->Fill(plane);
          hStrip->Fill(strip);
          hStripend->Fill(stripend);
          hPixel->Fill(pixel);

          Float_t chargeSigLin=xTalkHits->GetCharge
            (CalDigitType::kSigLin);
          Float_t chargePe=xTalkHits->GetCharge(CalDigitType::kPE);
          Float_t gain=chargeSigLin/chargePe;
          Float_t sourceCharge=xTalkHits->GetSourceCharge();

          hChargeSigLin->Fill(chargeSigLin);
          hChargePe->Fill(chargePe);
          hGain->Fill(gain);
          hSourceCharge->Fill(sourceCharge);

          Int_t numXTalkHits=xTalkHits->GetNumxhits();
          Int_t sourceEnd=xTalkHits->GetSourceEnd();
          Int_t sourcePlane=xTalkHits->GetSourcePlane();
          Int_t sourceStrip=xTalkHits->GetSourceStrip();
          Int_t sourcePixel=xTalkHits->GetSourcePixel();
          Int_t sourceSpot=xTalkHits->GetSourceSpot();
          Double_t time=xTalkHits->GetTime();

          hNumXTalkHits->Fill(numXTalkHits);
          hSourceEnd->Fill(sourceEnd);
          hSourcePlane->Fill(sourcePlane);
          hSourceStrip->Fill(sourceStrip);
          hSourcePixel->Fill(sourcePixel);
          hSourceSpot->Fill(sourceSpot);
          hTime->Fill(time);

          Int_t x=((sourcePixel-1)%4)+1;
          Int_t y=((sourcePixel-1)/4)+1;
          hPmtFace->Fill(x,y);

          hSpotVsPix->Fill(sourcePixel,sourceSpot);

          hit++;
        }
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cResults=new TCanvas("cResults","Results",0,0,1200,800);
  cResults->SetFillColor(0);
  cResults->Divide(2,2);
  cResults->cd(1);
  hEvenResult->Draw();
  cResults->cd(2);
  hOddResult->Draw();

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hStripend->Draw();
  cGeom->cd(4);
  hPixel->Draw();

  TCanvas *cHits=new TCanvas("cHits","Hits",0,0,1200,800);
  cHits->SetFillColor(0);
  cHits->Divide(2,2);
  cHits->cd(1);
  hChargeSigLin->Draw();
  cHits->cd(2);
  hChargePe->Draw();
  cHits->cd(3);
  hGain->Draw();
  cHits->cd(4);
  hSourceCharge->Draw();

  TCanvas *cSource=new TCanvas("cSource","Source",0,0,1200,800);
  cSource->SetFillColor(0);
  cSource->Divide(3,2);
  cSource->cd(1);
  hNumXTalkHits->Draw();
  cSource->cd(2);
  hSourceEnd->Draw();
  cSource->cd(3);
  hSourcePlane->Draw();
  cSource->cd(4);
  hSourceStrip->Draw();
  cSource->cd(5);
  hSourcePixel->Draw();
  cSource->cd(6);
  hSourceSpot->Draw();

  //turn off stats box
  gStyle->SetOptStat();

  TCanvas *cPmt=new TCanvas("cPmt","Pmt",0,0,1200,800);
  cPmt->SetFillColor(0);
  cPmt->Divide(2,1);
  cPmt->cd(1);
  hPmtFace->Draw("colz");
  cPmt->cd(2);
  hSpotVsPix->Draw("colz");
  
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateXTalkHits method **"<<endl;
}

//......................................................................

void CDAnalysis::ValidatePIDInfo()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidatePIDInfo method... **"<<endl;

  TH1F *hNoOverlap=new TH1F("hNoOverlap","hNoOverlap",100,-2,5);
  hNoOverlap->GetXaxis()->SetTitle("NoOverlap");
  hNoOverlap->GetXaxis()->CenterTitle();
  hNoOverlap->GetYaxis()->SetTitle("");
  hNoOverlap->GetYaxis()->CenterTitle();
  hNoOverlap->SetFillColor(0);
  hNoOverlap->SetBit(TH1::kCanRebin);

  TH1F *hInCERTime=new TH1F("hInCERTime","hInCERTime",100,-2,20);
  hInCERTime->GetXaxis()->SetTitle("InCERTime");
  hInCERTime->GetXaxis()->CenterTitle();
  hInCERTime->GetYaxis()->SetTitle("");
  hInCERTime->GetYaxis()->CenterTitle();
  hInCERTime->SetFillColor(0);
  hInCERTime->SetBit(TH1::kCanRebin);

  //Undetermined kUnknown 0x00
  //e   kElectron 0x01
  //mu  kMuon 0x02
  //pi  kPion 0x04
  //K   kKaon 0x08
  //p   kProton 0x16

  TH1F *hPIDType=new TH1F("hPIDType","hPIDType",400,-2,30);
  hPIDType->GetXaxis()->SetTitle("PIDType");
  hPIDType->GetXaxis()->CenterTitle();
  hPIDType->GetYaxis()->SetTitle("");
  hPIDType->GetYaxis()->CenterTitle();
  hPIDType->SetFillColor(0);
  hPIDType->SetBit(TH1::kCanRebin);

  TH1F *hNoOverlapBits=new TH1F("hNoOverlapBits","hNoOverlapBits",
                                400,-2,40);
  hNoOverlapBits->GetXaxis()->SetTitle("NoOverlapBits");
  hNoOverlapBits->GetXaxis()->CenterTitle();
  hNoOverlapBits->GetYaxis()->SetTitle("");
  hNoOverlapBits->GetYaxis()->CenterTitle();
  hNoOverlapBits->SetFillColor(0);
  hNoOverlapBits->SetBit(TH1::kCanRebin);

  TH1F *hInCERTimeBits=new TH1F("hInCERTimeBits","hInCERTimeBits",
                                10,-2,3);
  hInCERTimeBits->GetXaxis()->SetTitle("InCERTimeBits");
  hInCERTimeBits->GetXaxis()->CenterTitle();
  hInCERTimeBits->GetYaxis()->SetTitle("");
  hInCERTimeBits->GetYaxis()->CenterTitle();
  hInCERTimeBits->SetFillColor(0);
  hInCERTimeBits->SetBit(TH1::kCanRebin);

  TH1F *hOLChi2=new TH1F("hOLChi2","hOLChi2",400,-2,20);
  hOLChi2->GetXaxis()->SetTitle("OLChi2");
  hOLChi2->GetXaxis()->CenterTitle();
  hOLChi2->GetYaxis()->SetTitle("");
  hOLChi2->GetYaxis()->CenterTitle();
  hOLChi2->SetFillColor(0);
  hOLChi2->SetBit(TH1::kCanRebin);

  TH1F *hTriggerPMT=new TH1F("hTriggerPMT","TriggerPMT",400,-2,30);
  hTriggerPMT->GetXaxis()->SetTitle("TriggerPMT");
  hTriggerPMT->GetXaxis()->CenterTitle();
  hTriggerPMT->GetYaxis()->SetTitle("");
  hTriggerPMT->GetYaxis()->CenterTitle();
  hTriggerPMT->SetFillColor(0);
  hTriggerPMT->SetBit(TH1::kCanRebin);

  TH1F *hFafErr=new TH1F("hFafErr","FafErr",400,-2,30);
  hFafErr->GetXaxis()->SetTitle("FafErr");
  hFafErr->GetXaxis()->CenterTitle();
  hFafErr->GetYaxis()->SetTitle("");
  hFafErr->GetYaxis()->CenterTitle();
  hFafErr->SetFillColor(0);
  hFafErr->SetBit(TH1::kCanRebin);

  TH1F *hSparseErr=new TH1F("hSparseErr","SparseErr",400,-2,30);
  hSparseErr->GetXaxis()->SetTitle("SparseErr");
  hSparseErr->GetXaxis()->CenterTitle();
  hSparseErr->GetYaxis()->SetTitle("");
  hSparseErr->GetYaxis()->CenterTitle();
  hSparseErr->SetFillColor(0);
  hSparseErr->SetBit(TH1::kCanRebin);
  
  TH1F *hTrigSource=new TH1F("hTrigSource","TrigSource",400,-2,2000);
  hTrigSource->GetXaxis()->SetTitle("TrigSource");
  hTrigSource->GetXaxis()->CenterTitle();
  hTrigSource->GetYaxis()->SetTitle("");
  hTrigSource->GetYaxis()->CenterTitle();
  hTrigSource->SetFillColor(0);
  hTrigSource->SetBit(TH1::kCanRebin);

  TH1F *hKovADC1=new TH1F("hKovADC1","KovADC1",400,-5,15000);
  hKovADC1->GetXaxis()->SetTitle("KovADC1");
  hKovADC1->GetXaxis()->CenterTitle();
  hKovADC1->GetYaxis()->SetTitle("");
  hKovADC1->GetYaxis()->CenterTitle();
  hKovADC1->SetFillColor(0);
  hKovADC1->SetBit(TH1::kCanRebin);

  TH1F *hKovADC2=new TH1F("hKovADC2","KovADC2",400,-5,15000);
  hKovADC2->GetXaxis()->SetTitle("KovADC2");
  hKovADC2->GetXaxis()->CenterTitle();
  hKovADC2->GetYaxis()->SetTitle("");
  hKovADC2->GetYaxis()->CenterTitle();
  hKovADC2->SetFillColor(0);
  hKovADC2->SetBit(TH1::kCanRebin);

  TH1F *hKovADC3=new TH1F("hKovADC3","KovADC3",400,-5,15000);
  hKovADC3->GetXaxis()->SetTitle("KovADC3");
  hKovADC3->GetXaxis()->CenterTitle();
  hKovADC3->GetYaxis()->SetTitle("");
  hKovADC3->GetYaxis()->CenterTitle();
  hKovADC3->SetFillColor(0);
  hKovADC3->SetBit(TH1::kCanRebin);

  TH1F *hKovTimeStamp1=new TH1F("hKovTimeStamp1","KovTimeStamp1",
                                400,-2,30);
  hKovTimeStamp1->GetXaxis()->SetTitle("KovTimeStamp1");
  hKovTimeStamp1->GetXaxis()->CenterTitle();
  hKovTimeStamp1->GetYaxis()->SetTitle("");
  hKovTimeStamp1->GetYaxis()->CenterTitle();
  hKovTimeStamp1->SetFillColor(0);
  hKovTimeStamp1->SetBit(TH1::kCanRebin);

  TH1F *hKovTimeStamp2=new TH1F("hKovTimeStamp2","KovTimeStamp2",
                                400,-2,30);
  hKovTimeStamp2->GetXaxis()->SetTitle("KovTimeStamp2");
  hKovTimeStamp2->GetXaxis()->CenterTitle();
  hKovTimeStamp2->GetYaxis()->SetTitle("");
  hKovTimeStamp2->GetYaxis()->CenterTitle();
  hKovTimeStamp2->SetFillColor(0);
  hKovTimeStamp2->SetBit(TH1::kCanRebin);

  TH1F *hKovTimeStamp3=new TH1F("hKovTimeStamp3","KovTimeStamp3",
                                400,-2,30);
  hKovTimeStamp3->GetXaxis()->SetTitle("KovTimeStamp3");
  hKovTimeStamp3->GetXaxis()->CenterTitle();
  hKovTimeStamp3->GetYaxis()->SetTitle("");
  hKovTimeStamp3->GetYaxis()->CenterTitle();
  hKovTimeStamp3->SetFillColor(0);
  hKovTimeStamp3->SetBit(TH1::kCanRebin);

  TH1F *hSnarlTimeFrame=new TH1F("hSnarlTimeFrame","SnarlTimeFrame",
                                 400,-2,30);
  hSnarlTimeFrame->GetXaxis()->SetTitle("SnarlTimeFrame");
  hSnarlTimeFrame->GetXaxis()->CenterTitle();
  hSnarlTimeFrame->GetYaxis()->SetTitle("");
  hSnarlTimeFrame->GetYaxis()->CenterTitle();
  hSnarlTimeFrame->SetFillColor(0);
  hSnarlTimeFrame->SetBit(TH1::kCanRebin);

  TH1F *hSnarlMinTimeStamp=new TH1F("hSnarlMinTimeStamp",
                                    "SnarlMinTimeStamp",400,-2,30);
  hSnarlMinTimeStamp->GetXaxis()->SetTitle("SnarlMinTimeStamp");
  hSnarlMinTimeStamp->GetXaxis()->CenterTitle();
  hSnarlMinTimeStamp->GetYaxis()->SetTitle("");
  hSnarlMinTimeStamp->GetYaxis()->CenterTitle();
  hSnarlMinTimeStamp->SetFillColor(0);
  hSnarlMinTimeStamp->SetBit(TH1::kCanRebin);

  TH1F *hSnarlMaxTimeStamp=new TH1F("hSnarlMaxTimeStamp",
                                    "SnarlMaxTimeStamp",400,-2,30);
  hSnarlMaxTimeStamp->GetXaxis()->SetTitle("SnarlMaxTimeStamp");
  hSnarlMaxTimeStamp->GetXaxis()->CenterTitle();
  hSnarlMaxTimeStamp->GetYaxis()->SetTitle("");
  hSnarlMaxTimeStamp->GetYaxis()->CenterTitle();
  hSnarlMaxTimeStamp->SetFillColor(0);
  hSnarlMaxTimeStamp->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC0=new TH1F("hTofTDC0","TofTDC0",400,-2,4000);
  hTofTDC0->GetXaxis()->SetTitle("TofTDC0");
  hTofTDC0->GetXaxis()->CenterTitle();
  hTofTDC0->GetYaxis()->SetTitle("");
  hTofTDC0->GetYaxis()->CenterTitle();
  hTofTDC0->SetFillColor(0);
  hTofTDC0->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC1=new TH1F("hTofTDC1","TofTDC1",400,-2,4000);
  hTofTDC1->GetXaxis()->SetTitle("TofTDC1");
  hTofTDC1->GetXaxis()->CenterTitle();
  hTofTDC1->GetYaxis()->SetTitle("");
  hTofTDC1->GetYaxis()->CenterTitle();
  hTofTDC1->SetFillColor(0);
  hTofTDC1->SetBit(TH1::kCanRebin);

  TH1F *hTofTDC2=new TH1F("hTofTDC2","TofTDC2",400,-2,4000);
  hTofTDC2->GetXaxis()->SetTitle("TofTDC2");
  hTofTDC2->GetXaxis()->CenterTitle();
  hTofTDC2->GetYaxis()->SetTitle("");
  hTofTDC2->GetYaxis()->CenterTitle();
  hTofTDC2->SetFillColor(0);
  hTofTDC2->SetBit(TH1::kCanRebin);

  TH1F *hTofADC0=new TH1F("hTofADC0","TofADC0",400,-2,30);
  hTofADC0->GetXaxis()->SetTitle("TofADC0");
  hTofADC0->GetXaxis()->CenterTitle();
  hTofADC0->GetYaxis()->SetTitle("");
  hTofADC0->GetYaxis()->CenterTitle();
  hTofADC0->SetFillColor(0);
  hTofADC0->SetBit(TH1::kCanRebin);

  TH1F *hTofADC1=new TH1F("hTofADC1","TofADC1",400,-2,30);
  hTofADC1->GetXaxis()->SetTitle("TofADC1");
  hTofADC1->GetXaxis()->CenterTitle();
  hTofADC1->GetYaxis()->SetTitle("");
  hTofADC1->GetYaxis()->CenterTitle();
  hTofADC1->SetFillColor(0);
  hTofADC1->SetBit(TH1::kCanRebin);

  TH1F *hTofADC2=new TH1F("hTofADC2","TofADC2",400,-2,30);
  hTofADC2->GetXaxis()->SetTitle("TofADC2");
  hTofADC2->GetXaxis()->CenterTitle();
  hTofADC2->GetYaxis()->SetTitle("");
  hTofADC2->GetYaxis()->CenterTitle();
  hTofADC2->SetFillColor(0);
  hTofADC2->SetBit(TH1::kCanRebin);

  TH1F *hTofADCTimeStamp0=new TH1F("hTofADCTimeStamp0",
                                   "TofADCTimeStamp",400,-2,30);
  hTofADCTimeStamp0->GetXaxis()->SetTitle("TofADCTimeStamp");
  hTofADCTimeStamp0->GetXaxis()->CenterTitle();
  hTofADCTimeStamp0->GetYaxis()->SetTitle("");
  hTofADCTimeStamp0->GetYaxis()->CenterTitle();
  hTofADCTimeStamp0->SetFillColor(0);
  hTofADCTimeStamp0->SetBit(TH1::kCanRebin);

  TH1F *hTofADCTimeStamp1=new TH1F("hTofADCTimeStamp1",
                                   "TofADCTimeStamp1",400,-2,30);
  hTofADCTimeStamp1->GetXaxis()->SetTitle("TofADCTimeStamp1");
  hTofADCTimeStamp1->GetXaxis()->CenterTitle();
  hTofADCTimeStamp1->GetYaxis()->SetTitle("");
  hTofADCTimeStamp1->GetYaxis()->CenterTitle();
  hTofADCTimeStamp1->SetFillColor(0);
  hTofADCTimeStamp1->SetBit(TH1::kCanRebin);

  TH1F *hTofADCTimeStamp2=new TH1F("hTofADCTimeStamp2",
                                   "TofADCTimeStamp2",400,-2,30);
  hTofADCTimeStamp2->GetXaxis()->SetTitle("TofADCTimeStamp2");
  hTofADCTimeStamp2->GetXaxis()->CenterTitle();
  hTofADCTimeStamp2->GetYaxis()->SetTitle("");
  hTofADCTimeStamp2->GetYaxis()->CenterTitle();
  hTofADCTimeStamp2->SetFillColor(0);
  hTofADCTimeStamp2->SetBit(TH1::kCanRebin);

  TH1F *hTofTimeStamp=new TH1F("hTofTimeStamp",
                               "TofTimeStamp",400,-2,30);
  hTofTimeStamp->GetXaxis()->SetTitle("TofTimeStamp");
  hTofTimeStamp->GetXaxis()->CenterTitle();
  hTofTimeStamp->GetYaxis()->SetTitle("");
  hTofTimeStamp->GetYaxis()->CenterTitle();
  hTofTimeStamp->SetFillColor(0);
  hTofTimeStamp->SetBit(TH1::kCanRebin);

  TH1F *hTickSinceLast=new TH1F("hTickSinceLast",
                                "TickSinceLast",400,-2,30);
  hTickSinceLast->GetXaxis()->SetTitle("TickSinceLast");
  hTickSinceLast->GetXaxis()->CenterTitle();
  hTickSinceLast->GetYaxis()->SetTitle("");
  hTickSinceLast->GetYaxis()->CenterTitle();
  hTickSinceLast->SetFillColor(0);
  hTickSinceLast->SetBit(TH1::kCanRebin);

  Bool_t triggerPMT;            //Did the triggerPMT fire?
  Bool_t fafErr;                //Faf errors?
  Bool_t sparseErr;             //sparse errors?
  Int_t trigSource;             //trigger source
  Int_t kovADC1;                //Cerenkov ADC value
  Int_t kovTimeStamp1;          //Cerenkov TimeStamp
  Int_t kovADC2;
  Int_t kovTimeStamp2;
  Int_t kovADC3;
  Int_t kovTimeStamp3;
  Int_t snarlTimeFrame;         //Event TimeFrame
  ULong_t snarlMinTimeStamp;  //event minimum timetimestamp
  ULong_t snarlMaxTimeStamp;  //event maximum timestamp
  Int_t tofTDC0;                //TOF tdc0 value
  Int_t tofTDC1;                //TOF tdc1 value
  Int_t tofTDC2;                //TOF tdc2 value
  Int_t tofADC0;                //TOF ADC0 value (not always present) 
                               //______Context depends on the run
  Int_t tofADC1;                //TOF ADC1 value (not always present) 
                               //Used for tof system testing
  Int_t tofADC2;                //TOF ADC1 value (not always present) 
                               //Used for tof system testing
  Int_t tofADCTimeStamp0;       //tof adc timestamps
  Int_t tofADCTimeStamp1;
  Int_t tofADCTimeStamp2;  
  Int_t tofTimeStamp;           //time stamp of TOF readout
  Int_t tickSinceLast;          //Ticks since last snarl

  //pid validation counters
  Int_t myPiMuCounter=0;
  Int_t pidPiMuCounter=0;
  Int_t myElecCounter=0;
  Int_t pidElecCounter=0;
  Int_t bothPiMuCounter=0;
  Int_t bothElecCounter=0;

  MSG("CDAnalysis",Msg::kInfo)<<"Starting main loop..."<<endl;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (!fPIDInfo){
      MAXMSG("CDAnalysis",Msg::kWarning,100)
        <<"No PID info: fPIDInfo="<<fPIDInfo<<endl;
      continue;
    }
    
    //bool for storing results of pid
    Bool_t myPiMuFound=false;
    Bool_t pidPiMuFound=false;
    Bool_t myElecFound=false;
    Bool_t pidElecFound=false;

    if (!this->CutByHandOnPid()){
      myPiMuCounter++;
      myPiMuFound=true;
    }
    if (!this->CutOnPid()){
      pidPiMuCounter++;
      pidPiMuFound=true;
    }
    if (!this->CutByHandOnPidForElec()){
      myElecCounter++;
      myElecFound=true;
    }
    if (!this->CutOnPidForElec()){//only electrons!
      pidElecCounter++;
      pidElecFound=true;
    }

    if (myPiMuFound && pidPiMuFound) bothPiMuCounter++;
    if (myElecFound && pidElecFound) bothElecCounter++;

    //if (!fPIDInfo->IsEmpty()){
    
      triggerPMT=fPIDInfo->GetTriggerPMT();
      fafErr=fPIDInfo->GetFafErr() ;
      sparseErr=fPIDInfo->GetSparseErr();
      trigSource=fPIDInfo->GetTrigSource();
      kovADC1=fPIDInfo->GetKovADC1() ;
      kovTimeStamp1=fPIDInfo->GetKovTimeStamp1();
      kovADC2=fPIDInfo->GetKovADC2();
      kovTimeStamp2=fPIDInfo->GetKovTimeStamp2();
      kovADC3=fPIDInfo->GetKovADC3();
      kovTimeStamp3=fPIDInfo->GetKovTimeStamp3(); 
      snarlTimeFrame=fPIDInfo->GetSnarlTimeFrame();
      snarlMinTimeStamp=fPIDInfo->GetSnarlMinTimeStamp();
      snarlMaxTimeStamp=fPIDInfo->GetSnarlMaxTimeStamp();
      tofTDC0=fPIDInfo->GetTofTDC0();
      tofTDC1=fPIDInfo->GetTofTDC1();
      tofTDC2=fPIDInfo->GetTofTDC2();
      tofADC0=fPIDInfo->GetTofADC0();
      tofADC1=fPIDInfo->GetTofADC1();
      tofADC2=fPIDInfo->GetTofADC2();
      tofADCTimeStamp0=fPIDInfo->GetTofADCTimeStamp0();
      tofADCTimeStamp1=fPIDInfo->GetTofADCTimeStamp1();
      tofADCTimeStamp2=fPIDInfo->GetTofADCTimeStamp2();
      tofTimeStamp=fPIDInfo->GetTofTimeStamp();
      tickSinceLast=fPIDInfo->GetTickSinceLast();

      //get and fill the CalDetPID info
      hNoOverlap->Fill(fPIDInfo->GetNoOverlap());
      hInCERTime->Fill(fPIDInfo->GetInCERTime());
      hPIDType->Fill(fPIDInfo->GetPIDType());
      hNoOverlapBits->Fill(fPIDInfo->GetNoOverlapBits());
      hInCERTimeBits->Fill(fPIDInfo->GetInCERTimeBits());
      hOLChi2->Fill(fPIDInfo->GetOLChi2());

      hTriggerPMT->Fill(triggerPMT);
      hFafErr->Fill(fafErr);
      hSparseErr->Fill(sparseErr);
      hTrigSource->Fill(trigSource);
      hKovADC1->Fill(kovADC1);
      hKovTimeStamp1->Fill(kovTimeStamp1);
      hKovADC2->Fill(kovADC2);
      hKovTimeStamp2->Fill(kovTimeStamp2);
      hKovADC3->Fill(kovADC3);
      hKovTimeStamp3->Fill(kovTimeStamp3);
      hSnarlTimeFrame->Fill(snarlTimeFrame);
      hSnarlMinTimeStamp->Fill(snarlMinTimeStamp);
      hSnarlMaxTimeStamp->Fill(snarlMaxTimeStamp);
      hTofTDC0->Fill(tofTDC0);
      hTofTDC1->Fill(tofTDC1);
      hTofTDC2->Fill(tofTDC2);
      hTofADC0->Fill(tofADC0);
      hTofADC1->Fill(tofADC1);
      hTofADC2->Fill(tofADC2);
      hTofADCTimeStamp0->Fill(tofADCTimeStamp0);
      hTofADCTimeStamp1->Fill(tofADCTimeStamp1);
      hTofADCTimeStamp2->Fill(tofADCTimeStamp2);
      hTofTimeStamp->Fill(tofTimeStamp);
      hTickSinceLast->Fill(tickSinceLast);

      //}

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cTof=new TCanvas("cTof","cTof",0,0,1200,800);
  cTof->SetFillColor(0);
  cTof->Divide(3,3);
  cTof->cd(1);
  hTofTDC0->Draw();
  cTof->cd(2);
  hTofTDC1->Draw();
  cTof->cd(3);
  hTofTDC2->Draw();
  cTof->cd(1+3);
  hTofADC0->Draw();
  cTof->cd(2+3);
  hTofADC1->Draw();
  cTof->cd(3+3);
  hTofADC2->Draw();
  cTof->cd(1+6);
  hTofADCTimeStamp0->Draw();
  cTof->cd(2+6);
  hTofADCTimeStamp1->Draw();
  cTof->cd(3+6);
  hTofADCTimeStamp2->Draw();

  TCanvas *cKov=new TCanvas("cKov","cKov",0,0,1200,800);
  cKov->SetFillColor(0);
  cKov->Divide(3,2);
  cKov->cd(1);
  hKovADC1->Draw();
  cKov->cd(2);
  hKovADC2->Draw();
  cKov->cd(3);
  hKovADC3->Draw();
  cKov->cd(1+3);
  hKovTimeStamp1->Draw();
  cKov->cd(2+3);
  hKovTimeStamp2->Draw();
  cKov->cd(3+3);
  hKovTimeStamp3->Draw();

  TCanvas *cTime=new TCanvas("cTime","cTime",0,0,1200,800);
  cTime->SetFillColor(0);
  cTime->Divide(2,1);
  cTime->cd(1);
  hTofTimeStamp->Draw();
  cTime->cd(2);
  hTickSinceLast->Draw();

  TCanvas *cTrig=new TCanvas("cTrig","cTrig",0,0,1200,800);
  cTrig->SetFillColor(0);
  cTrig->Divide(2,1);
  cTrig->cd(1);
  hTriggerPMT->Draw();
  cTrig->cd(2);
  hTrigSource->Draw();

  TCanvas *cErr=new TCanvas("cErr","cErr",0,0,1200,800);
  cErr->SetFillColor(0);
  cErr->Divide(2,1);
  cErr->cd(1);
  hFafErr->Draw();
  cErr->cd(2);
  hSparseErr->Draw();

  TCanvas *cPID=new TCanvas("cPID","cPID",0,0,1200,800);
  cPID->SetFillColor(0);
  cPID->Divide(3,2);
  cPID->cd(1);
  hNoOverlap->Draw();
  cPID->cd(2);
  hInCERTime->Draw();
  cPID->cd(3);
  hPIDType->Draw();
  cPID->cd(4);
  hNoOverlapBits->Draw();
  cPID->cd(5);
  hInCERTimeBits->Draw();
  cPID->cd(6);
  hOLChi2->Draw();

  //pid validation counters results
  MSG("CDAnalysis",Msg::kInfo)
    <<"My PiMu counter="<<myPiMuCounter<<endl
    <<"PID PiMu counter="<<pidPiMuCounter<<endl
    <<"Both PiMu counter="<<bothPiMuCounter<<endl
    <<"My Elec counter="<<myElecCounter<<endl
    <<"PID Elec counter="<<pidElecCounter<<endl
    <<"Both Elec counter="<<bothElecCounter<<endl;

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidatePIDInfo method **"<<endl;
}

//......................................................................

void CDAnalysis::PrintPIDStats()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running PrintPIDStats method... **"<<endl;

  //pid counters
  fMyPiMuCounter=0;
  fPidPiMuCounter=0;
  fMyElecCounter=0;
  fPidElecCounter=0;
  fBothPiMuCounter=0;
  fBothElecCounter=0;

  MSG("CDAnalysis",Msg::kInfo)<<"Starting main loop..."<<endl;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (this->CutOnDeadChips()) continue;

    if (!fPIDInfo){
      MAXMSG("CDAnalysis",Msg::kWarning,100)
        <<"No PID info: fPIDInfo="<<fPIDInfo<<endl;
      continue;
    }
    
    //bool for storing results of pid
    Bool_t myPiMuFound=false;
    Bool_t pidPiMuFound=false;
    Bool_t myElecFound=false;
    Bool_t pidElecFound=false;

    if (!this->CutByHandOnPid()){
      fMyPiMuCounter++;
      myPiMuFound=true;
    }
    if (!this->CutOnPid()){
      fPidPiMuCounter++;
      pidPiMuFound=true;
    }
    if (!this->CutByHandOnPidForElec()){
      fMyElecCounter++;
      myElecFound=true;
    }
    if (!this->CutOnPidForElec()){//only electrons!
      fPidElecCounter++;
      pidElecFound=true;
    }

    if (myPiMuFound && pidPiMuFound) fBothPiMuCounter++;
    if (myElecFound && pidElecFound) fBothElecCounter++;

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //pid validation counters results
  MSG("CDAnalysis",Msg::kInfo)
    <<"My PiMu counter="<<fMyPiMuCounter<<endl
    <<"PID PiMu counter="<<fPidPiMuCounter<<endl
    <<"Both PiMu counter="<<fBothPiMuCounter<<endl
    <<"My Elec counter="<<fMyElecCounter<<endl
    <<"PID Elec counter="<<fPidElecCounter<<endl
    <<"Both Elec counter="<<fBothElecCounter<<endl;

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished PrintPIDStats method **"<<endl;
}

//......................................................................

void CDAnalysis::Template()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<endl<<" ** Running the TEMPLATE!!!! method... ** "<<endl;

  //put any variable and histogram declarations etc here

  TH1F *hEvent=new TH1F("hEvent","Event",40,-5,35);
  hEvent->GetXaxis()->SetTitle("Event");
  hEvent->GetXaxis()->CenterTitle();
  hEvent->GetYaxis()->SetTitle("Num");
  hEvent->GetYaxis()->CenterTitle();
  hEvent->SetFillColor(0);
  hEvent->SetBit(TH1::kCanRebin);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //put all your cuts and histogram filling here
    
    MSG("CDAnalysis",Msg::kVerbose)
        <<"Event="<<event<<endl;
    
    hEvent->Fill(event);

  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  //do any plots or analysis here

  TCanvas *cMean=new TCanvas("cMean","Mean adc",0,0,1200,800);
  cMean->SetFillColor(0);
  cMean->cd();
  hEvent->Draw();

  MSG("CDAnalysis",Msg::kInfo) 
    <<endl<<" ** Finished the TEMPLATE!!!!! method ** "<<endl;
}

//......................................................................

void CDAnalysis::ValidateMC()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running ValidateMC method... **"<<endl;

  fS="Strip Vs Plane SigCor (SE1)";
  TProfile2D* pStVsPl1=new TProfile2D("pStVsPl1",fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPl1->GetXaxis()->SetTitle("Plane");
  pStVsPl1->GetXaxis()->CenterTitle();
  pStVsPl1->GetYaxis()->SetTitle("Strip");
  pStVsPl1->GetYaxis()->CenterTitle();
  pStVsPl1->SetFillColor(0);
  //pStVsPl1->SetMaximum(15000);

  fS="Strip Vs Plane SigCor (SE2)";
  TProfile2D* pStVsPl2=new TProfile2D("pStVsPl2",fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPl2->GetXaxis()->SetTitle("Plane");
  pStVsPl2->GetXaxis()->CenterTitle();
  pStVsPl2->GetYaxis()->SetTitle("Strip");
  pStVsPl2->GetYaxis()->CenterTitle();
  pStVsPl2->SetFillColor(0);
  //pStVsPl2->SetMaximum(15000);

  fS="Strip Vs Plane PE (SE1)";
  TProfile2D* pStVsPlPe1=new TProfile2D("pStVsPlPe1",fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlPe1->GetXaxis()->SetTitle("Plane");
  pStVsPlPe1->GetXaxis()->CenterTitle();
  pStVsPlPe1->GetYaxis()->SetTitle("Strip");
  pStVsPlPe1->GetYaxis()->CenterTitle();
  pStVsPlPe1->SetFillColor(0);
  //pStVsPlPe1->SetMaximum(15000);

  fS="Strip Vs Plane SigCor (SE2)";
  TProfile2D* pStVsPlPe2=new TProfile2D("pStVsPlPe2",fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlPe2->GetXaxis()->SetTitle("Plane");
  pStVsPlPe2->GetXaxis()->CenterTitle();
  pStVsPlPe2->GetYaxis()->SetTitle("Strip");
  pStVsPlPe2->GetYaxis()->CenterTitle();
  pStVsPlPe2->SetFillColor(0);
  //pStVsPlPe2->SetMaximum(15000);


  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    //get tclones arrays for this snarl
    //TClonesArray &cTrk=*fTrkHitInfo;
    Int_t numTrkHits=fTrkHitInfo->GetEntries();
    TClonesArray &cUnTrk = *fUnTrkHitInfo;
    Int_t numUnTrkHits = fUnTrkHitInfo->GetEntries();
    //CDTrackedHitInfo *trackedHitInfo=(CDTrackedHitInfo*) c[hit];
    //TClonesArray &cXTalk = *fXTalkHits;
    Int_t numXTalkHits=fXTalkHits->GetEntries();
    //TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=0;
    if (fTruthHitInfo) numTruthHits=fTruthHitInfo->GetEntries();

    MSG("CDAnalysis",Msg::kInfo)
      <<"Event="<<event
      <<", Num hits: trk="<<numTrkHits<<", unTrk="<<numUnTrkHits
      <<", xtalk="<<numXTalkHits<<", truth="<<numTruthHits
      <<endl;

    //loop over the untracked hits in the snarl
    for (Int_t hit=0;hit<numUnTrkHits;hit++){
      //cast the tclonesarray up to a trackedhitinfo object
      CDTrackedHitInfo *hitInfo=
        dynamic_cast<CDTrackedHitInfo*>(cUnTrk[hit]);

      this->ReadInHitInfo(hitInfo);

      //fill the histo
      if (fStripend==1) pStVsPl1->Fill(fPlane,fStrip,fChargeSigCor);
      if (fStripend==2) pStVsPl2->Fill(fPlane,fStrip,fChargeSigCor);

      if (fStripend==1) pStVsPlPe1->Fill(fPlane,fStrip,fChargePe);
      if (fStripend==2) pStVsPlPe2->Fill(fPlane,fStrip,fChargePe);
      
    }
  }//end of for                                       
  

  //turn off the stats box printing
  gStyle->SetOptStat(0);

  TCanvas *cStVsPl=new TCanvas("cStVsPl","StVsPl",
                                         0,0,1200,800);
  cStVsPl->SetFillColor(0);
  cStVsPl->Divide(1,2);
  cStVsPl->cd(1);
  pStVsPl1->Draw("colz");
  cStVsPl->cd(2);
  pStVsPl2->Draw("colz");

  TCanvas *cStVsPlPe=new TCanvas("cStVsPlPe","StVsPlPe",
                                         0,0,1200,800);
  cStVsPlPe->SetFillColor(0);
  cStVsPlPe->Divide(1,2);
  cStVsPlPe->cd(1);
  pStVsPlPe1->Draw("colz");
  cStVsPlPe->cd(2);
  pStVsPlPe2->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished ValidateMC method **"<<endl;
}

//......................................................................

void CDAnalysis::TruthAnalysis()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running TruthAnalysis method... **"<<endl;
  
  TH1F *hStrip=new TH1F("hStrip","Strips hit",100,-2,30);
  hStrip->GetXaxis()->SetTitle("Strip");
  hStrip->GetXaxis()->CenterTitle();
  hStrip->GetYaxis()->SetTitle("");
  hStrip->GetYaxis()->CenterTitle();
  hStrip->SetFillColor(0);
  hStrip->SetBit(TH1::kCanRebin);

  TH1F *hPlane=new TH1F("hPlane","Planes hit",200,-2,75);
  hPlane->GetXaxis()->SetTitle("Plane");
  hPlane->GetXaxis()->CenterTitle();
  hPlane->GetYaxis()->SetTitle("");
  hPlane->GetYaxis()->CenterTitle();
  hPlane->SetFillColor(0);
  hPlane->SetBit(TH1::kCanRebin);

  TH1F *hPmtTruth1=new TH1F("hPmtTruth1","PmtTruth1",400,-2,125);
  hPmtTruth1->GetXaxis()->SetTitle("PmtTruth1");
  hPmtTruth1->GetXaxis()->CenterTitle();
  hPmtTruth1->GetYaxis()->SetTitle("");
  hPmtTruth1->GetYaxis()->CenterTitle();
  hPmtTruth1->SetFillColor(0);
  hPmtTruth1->SetBit(TH1::kCanRebin);

  TH1F *hPmtTruth2=new TH1F("hPmtTruth2","PmtTruth2",400,-2,125);
  hPmtTruth2->GetXaxis()->SetTitle("PmtTruth2");
  hPmtTruth2->GetXaxis()->CenterTitle();
  hPmtTruth2->GetYaxis()->SetTitle("");
  hPmtTruth2->GetYaxis()->CenterTitle();
  hPmtTruth2->SetFillColor(0);
  hPmtTruth2->SetBit(TH1::kCanRebin);
  //kUnknown       = 0x00,   // Can happen: known cause is 0 charge
  // but random noise passes sparsification thresh.
  //kGenuine       = 0x01,   // A real hit from real gosh-darn physics.
  //kDarkNoise        = 0x02,   // Dark noise from the tube.
  //kFibreLight       = 0x04,   // Random [singles] from a fibre. 
  //kCrosstalk        = 0x08,   // A generic crosstalk hit.
  //kCrosstalkOptical = 0x10,   // A crosstalk hit, specifically from
  //kLeakFromNextBucket = 0x20,  
  // The next bucket leaked charge back to this one
  //kLeakFromPrevBucket = 0x40  

  TH1F *hVaChip1=new TH1F("hVaChip1","VaChip1",50,-2,5);
  hVaChip1->GetXaxis()->SetTitle("VaChip1");
  hVaChip1->GetXaxis()->CenterTitle();
  hVaChip1->GetYaxis()->SetTitle("");
  hVaChip1->GetYaxis()->CenterTitle();
  hVaChip1->SetFillColor(0);
  hVaChip1->SetBit(TH1::kCanRebin);

  TH1F *hVaChip2=new TH1F("hVaChip2","VaChip2",50,-2,5);
  hVaChip2->GetXaxis()->SetTitle("VaChip2");
  hVaChip2->GetXaxis()->CenterTitle();
  hVaChip2->GetYaxis()->SetTitle("");
  hVaChip2->GetYaxis()->CenterTitle();
  hVaChip2->SetFillColor(0);
  hVaChip2->SetBit(TH1::kCanRebin);

  TH1F *hMainParticle=new TH1F("hMainParticle","MainParticle",200,-20,20);
  hMainParticle->GetXaxis()->SetTitle("MainParticle");
  hMainParticle->GetXaxis()->CenterTitle();
  hMainParticle->GetYaxis()->SetTitle("");
  hMainParticle->GetYaxis()->CenterTitle();
  hMainParticle->SetFillColor(0);
  hMainParticle->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDep=new TH1F("hTotalEnDep","TotalEnDep",
                             2000,-5./1000,15./1000);
  hTotalEnDep->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDep->GetXaxis()->CenterTitle();
  hTotalEnDep->GetYaxis()->SetTitle("");
  hTotalEnDep->GetYaxis()->CenterTitle();
  hTotalEnDep->SetFillColor(0);
  hTotalEnDep->SetBit(TH1::kCanRebin);

  TH1F *hMainPartEn=new TH1F("hMainPartEn","MainPartEn",500,-0.5,2);
  hMainPartEn->GetXaxis()->SetTitle("MainPartEn");
  hMainPartEn->GetXaxis()->CenterTitle();
  hMainPartEn->GetYaxis()->SetTitle("");
  hMainPartEn->GetYaxis()->CenterTitle();
  hMainPartEn->SetFillColor(0);
  hMainPartEn->SetBit(TH1::kCanRebin);

  TH1F *hMainPathLength=new TH1F("hMainPathLength","MainPathLength",
                                 500,-0.01,0.1);
  hMainPathLength->GetXaxis()->SetTitle("MainPathLength");
  hMainPathLength->GetXaxis()->CenterTitle();
  hMainPathLength->GetYaxis()->SetTitle("");
  hMainPathLength->GetYaxis()->CenterTitle();
  hMainPathLength->SetFillColor(0);
  hMainPathLength->SetBit(TH1::kCanRebin);

  fS="Strip Vs Plane EnergyDep Map";
  TProfile2D* pStVsPlEnDep=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDep->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDep->GetXaxis()->CenterTitle();
  pStVsPlEnDep->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDep->GetYaxis()->CenterTitle();
  pStVsPlEnDep->SetFillColor(0);
  //pStVsPlEnDep->SetMaximum(15000);

  fS="Strip Vs Plane Num Hits Map";
  TProfile2D* hStVsPlNum=new TProfile2D(fS.c_str(),fS.c_str(),64,-2,62,30,-3,27);
  hStVsPlNum->GetXaxis()->SetTitle("Plane");
  hStVsPlNum->GetXaxis()->CenterTitle();
  hStVsPlNum->GetYaxis()->SetTitle("Strip");
  hStVsPlNum->GetYaxis()->CenterTitle();
  hStVsPlNum->SetFillColor(0);
  //hStVsPlNum->SetMaximum(15000);

  fS="Strip Vs Plane FibreLight Map SE1";
  TProfile2D* hStVsPlFibreLight1=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlFibreLight1->GetXaxis()->SetTitle("Plane");
  hStVsPlFibreLight1->GetXaxis()->CenterTitle();
  hStVsPlFibreLight1->GetYaxis()->SetTitle("Strip");
  hStVsPlFibreLight1->GetYaxis()->CenterTitle();
  hStVsPlFibreLight1->SetFillColor(0);
  //hStVsPlFibreLight1->SetMaximum(15000);

  fS="Strip Vs Plane OpticalXTalk Map SE1";
  TH2F* hStVsPlOptXTalk1=new TH2F("hStVsPlOptXTalk1",fS.c_str(),
                                  64,-2,62,30,-3,27);
  hStVsPlOptXTalk1->GetXaxis()->SetTitle("Plane");
  hStVsPlOptXTalk1->GetXaxis()->CenterTitle();
  hStVsPlOptXTalk1->GetYaxis()->SetTitle("Strip");
  hStVsPlOptXTalk1->GetYaxis()->CenterTitle();
  hStVsPlOptXTalk1->SetFillColor(0);
  //hStVsPlOptXTalk1->SetMaximum(15000);

  fS="Strip Vs Plane DarkNoise Map SE1";
  TH2F* hStVsPlDarkNoise1=new TH2F(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlDarkNoise1->GetXaxis()->SetTitle("Plane");
  hStVsPlDarkNoise1->GetXaxis()->CenterTitle();
  hStVsPlDarkNoise1->GetYaxis()->SetTitle("Strip");
  hStVsPlDarkNoise1->GetYaxis()->CenterTitle();
  hStVsPlDarkNoise1->SetFillColor(0);
  //hStVsPlDarkNoise1->SetMaximum(15000);

  fS="Strip Vs Plane FibreLight Map SE2";
  TH2F* hStVsPlFibreLight2=new TH2F(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlFibreLight2->GetXaxis()->SetTitle("Plane");
  hStVsPlFibreLight2->GetXaxis()->CenterTitle();
  hStVsPlFibreLight2->GetYaxis()->SetTitle("Strip");
  hStVsPlFibreLight2->GetYaxis()->CenterTitle();
  hStVsPlFibreLight2->SetFillColor(0);
  //hStVsPlFibreLight2->SetMaximum(15000);

  fS="Strip Vs Plane OpticalXTalk Map SE2";
  TH2F* hStVsPlOptXTalk2=new TH2F("hStVsPlOptXTalk2",fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlOptXTalk2->GetXaxis()->SetTitle("Plane");
  hStVsPlOptXTalk2->GetXaxis()->CenterTitle();
  hStVsPlOptXTalk2->GetYaxis()->SetTitle("Strip");
  hStVsPlOptXTalk2->GetYaxis()->CenterTitle();
  hStVsPlOptXTalk2->SetFillColor(0);
  //hStVsPlOptXTalk2->SetMaximum(15000);

  fS="Strip Vs Plane OpticalXTalk on Shared Pmt Map";
  TH2F* hStVsPlOptXTalkShared=new TH2F(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlOptXTalkShared->GetXaxis()->SetTitle("Plane");
  hStVsPlOptXTalkShared->GetXaxis()->CenterTitle();
  hStVsPlOptXTalkShared->GetYaxis()->SetTitle("Strip");
  hStVsPlOptXTalkShared->GetYaxis()->CenterTitle();
  hStVsPlOptXTalkShared->SetFillColor(0);
  //hStVsPlOptXTalkShared->SetMaximum(15000);

  fS="Strip Vs Plane OpticalXTalk on Non-Shared Pmt Map";
  TH2F* hStVsPlOptXTalkNonShared=new TH2F(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlOptXTalkNonShared->GetXaxis()->SetTitle("Plane");
  hStVsPlOptXTalkNonShared->GetXaxis()->CenterTitle();
  hStVsPlOptXTalkNonShared->GetYaxis()->SetTitle("Strip");
  hStVsPlOptXTalkNonShared->GetYaxis()->CenterTitle();
  hStVsPlOptXTalkNonShared->SetFillColor(0);
  //hStVsPlOptXTalkNonShared->SetMaximum(15000);

  fS="Strip Vs Plane DarkNoise Map SE2";
  TH2F* hStVsPlDarkNoise2=new TH2F(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  hStVsPlDarkNoise2->GetXaxis()->SetTitle("Plane");
  hStVsPlDarkNoise2->GetXaxis()->CenterTitle();
  hStVsPlDarkNoise2->GetYaxis()->SetTitle("Strip");
  hStVsPlDarkNoise2->GetYaxis()->CenterTitle();
  hStVsPlDarkNoise2->SetFillColor(0);
  //hStVsPlDarkNoise2->SetMaximum(15000);

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (!fTruthHitInfo) break;
    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    MSG("CDAnalysis",Msg::kDebug)
      <<"Event="<<event
      <<", truthHits="<<numTruthHits<<endl;

    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
      
      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();
      Int_t mainParticle=hitInfo->GetMainParticle();
      Double_t totalEnDep=hitInfo->GetTotalEnDep();
      Double_t mainPartEn=hitInfo->GetMainPartEn();
      Double_t mainPathLength=hitInfo->GetMainPathLength();
      Int_t pmtTruth1=hitInfo->GetPmtTruth1();
      Int_t pmtTruth2=hitInfo->GetPmtTruth2();
      Int_t vaChip1=hitInfo->GetVaChip1();
      Int_t vaChip2=hitInfo->GetVaChip2();

      //if (plane==0) continue;

      hPlane->Fill(plane);
      hStrip->Fill(strip);
      hMainParticle->Fill(mainParticle);
      hTotalEnDep->Fill(totalEnDep);
      hMainPartEn->Fill(mainPartEn);
      hMainPathLength->Fill(mainPathLength);
      hPmtTruth1->Fill(pmtTruth1);
      hPmtTruth2->Fill(pmtTruth2);
      hVaChip1->Fill(vaChip1);
      hVaChip2->Fill(vaChip2);

      //do stripend 1
      if (pmtTruth1 & DigiSignal::kFibreLight){
        hStVsPlFibreLight1->Fill(plane,strip,1);
      }

      if (pmtTruth1 & DigiSignal::kCrosstalkOptical){
        hStVsPlOptXTalk1->Fill(plane,strip,1);

        //fill the shared and nonshared
        if (vaChip1==1) hStVsPlOptXTalkShared->Fill(plane,strip,1);
        else hStVsPlOptXTalkNonShared->Fill(plane,strip,1);
      }

      if (pmtTruth1 & DigiSignal::kDarkNoise){
        hStVsPlDarkNoise1->Fill(plane,strip,1);
      }

      //now do stripend 2
      if (pmtTruth2 & DigiSignal::kFibreLight){
        hStVsPlFibreLight2->Fill(plane,strip,1);
      }

      if (pmtTruth2 & DigiSignal::kCrosstalkOptical){
        hStVsPlOptXTalk2->Fill(plane,strip,1);
      }

      if (pmtTruth2 & DigiSignal::kDarkNoise){
        hStVsPlDarkNoise2->Fill(plane,strip,1);
      }

      pStVsPlEnDep->Fill(plane,strip,totalEnDep);
      hStVsPlNum->Fill(plane,strip,1);
    }
    
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  TCanvas *cGeom=new TCanvas("cGeom","Geom",0,0,1200,800);
  cGeom->SetFillColor(0);
  cGeom->Divide(2,2);
  cGeom->cd(1);
  hPlane->Draw();
  cGeom->cd(2);
  hStrip->Draw();
  cGeom->cd(3);
  hVaChip1->Draw();
  cGeom->cd(4);
  hVaChip2->Draw();

  TCanvas *cMainParticle=new TCanvas("cMainParticle","MainParticle",0,0,1200,800);
  cMainParticle->SetFillColor(0);
  cMainParticle->Divide(2,2);
  cMainParticle->cd(1);
  hMainParticle->Draw();
  cMainParticle->cd(2);
  hTotalEnDep->Draw();
  cMainParticle->cd(3);
  hMainPartEn->Draw();
  cMainParticle->cd(4);
  hPmtTruth1->Draw();
  hPmtTruth2->SetLineColor(2);
  hPmtTruth2->Draw("same");

  TCanvas *cStVsPlEnDep=new TCanvas("cStVsPlEnDep","StVsPlEnDep",
                                    0,0,1200,800);
  cStVsPlEnDep->SetFillColor(0);
  pStVsPlEnDep->Draw("colz");

  TCanvas *cStVsPlNum=new TCanvas("cStVsPlNum","StVsPlNum",
                                  0,0,1200,800);
  cStVsPlNum->SetFillColor(0);
  hStVsPlNum->Draw("colz");

  TCanvas *cStVsPlFibreLight=new TCanvas("cStVsPlFibreLight",
                                         "StVsPlFibreLight",
                                         0,0,1200,800);
  cStVsPlFibreLight->SetFillColor(0);
  cStVsPlFibreLight->Divide(1,2);
  cStVsPlFibreLight->cd(1);
  hStVsPlFibreLight1->Draw("colz");
  cStVsPlFibreLight->cd(2);
  hStVsPlFibreLight2->Draw("colz");
  
  TCanvas *cStVsPlOptXTalk=new TCanvas("cStVsPlOptXTalk",
                                         "StVsPlOptXTalk",
                                         0,0,1200,800);
  cStVsPlOptXTalk->SetFillColor(0);

  cStVsPlOptXTalk->Divide(1,2);
  cStVsPlOptXTalk->cd(1);
  hStVsPlOptXTalk1->Draw("colz");
  cStVsPlOptXTalk->cd(2);
  hStVsPlOptXTalk2->Draw("colz");

  TCanvas *cStVsPlOptXTalk2=new TCanvas("cStVsPlOptXTalk2",
                                         "StVsPlOptXTalk2",
                                         0,0,1200,800);
  cStVsPlOptXTalk2->SetFillColor(0);

  cStVsPlOptXTalk2->Divide(1,2);
  cStVsPlOptXTalk2->cd(1);
  hStVsPlOptXTalkShared->Draw("colz");
  cStVsPlOptXTalk2->cd(2);
  hStVsPlOptXTalkNonShared->Draw("colz");

  TCanvas *cStVsPlDarkNoise=new TCanvas("cStVsPlDarkNoise",
                                         "StVsPlDarkNoise",
                                         0,0,1200,800);
  cStVsPlDarkNoise->SetFillColor(0);
  cStVsPlDarkNoise->Divide(1,2);
  cStVsPlDarkNoise->cd(1);
  hStVsPlDarkNoise1->Draw("colz");
  cStVsPlDarkNoise->cd(2);
  hStVsPlDarkNoise2->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished TruthAnalysis method **"<<endl;
}

//......................................................................

void CDAnalysis::TruthEnDep()
{
  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Running TruthEnDep method... **"<<endl;
  
  //open the output file for the histograms
  fOutFile=this->OpenFile(fRunNumber,"TruthEnDep");

  TH1F *hPl20=new TH1F("hPl20","hPl20",200,-1,10);
  hPl20->SetTitle("Energy Deposition in plane 20");
  hPl20->GetXaxis()->SetTitle("MeV");
  hPl20->GetXaxis()->CenterTitle();
  hPl20->GetYaxis()->SetTitle("");
  hPl20->GetYaxis()->CenterTitle();
  hPl20->SetFillColor(0);
  hPl20->SetBit(TH1::kCanRebin);

  TH1F *hPl20Mu=new TH1F("hPl20Mu","hPl20Mu",200,-1,10);
  hPl20Mu->SetTitle("Energy Deposition in plane 20");
  hPl20Mu->GetXaxis()->SetTitle("MeV");
  hPl20Mu->GetXaxis()->CenterTitle();
  hPl20Mu->GetYaxis()->SetTitle("");
  hPl20Mu->GetYaxis()->CenterTitle();
  hPl20Mu->SetFillColor(0);
  hPl20Mu->SetLineColor(2);
  hPl20Mu->SetBit(TH1::kCanRebin);

  TH1F *hPl20NotMu=new TH1F("hPl20NotMu","hPl20NotMu",200,-1,10);
  hPl20NotMu->SetTitle("Energy Deposition in plane 20");
  hPl20NotMu->GetXaxis()->SetTitle("MeV");
  hPl20NotMu->GetXaxis()->CenterTitle();
  hPl20NotMu->GetYaxis()->SetTitle("");
  hPl20NotMu->GetYaxis()->CenterTitle();
  hPl20NotMu->SetFillColor(0);
  hPl20NotMu->SetLineColor(3);
  hPl20NotMu->SetBit(TH1::kCanRebin);

  TH1F *hSum15_18All=new TH1F("hSum15_18All","hSum15_18All",1000,-2,75);
  hSum15_18All->SetTitle("Energy Deposition in 15_18 Track Window");
  hSum15_18All->GetXaxis()->SetTitle("MeV");
  hSum15_18All->GetXaxis()->CenterTitle();
  hSum15_18All->GetYaxis()->SetTitle("");
  hSum15_18All->GetYaxis()->CenterTitle();
  hSum15_18All->SetFillColor(0);
  hSum15_18All->SetBit(TH1::kCanRebin);

  TH1F *hSum15_18Cut=new TH1F("hSum15_18Cut","hSum15_18Cut",500,-1,10);
  hSum15_18Cut->SetTitle
    ("Energy Deposition per MEU (Cuts on Track Quality)");
  hSum15_18Cut->GetXaxis()->SetTitle("MeV");
  hSum15_18Cut->GetXaxis()->CenterTitle();
  hSum15_18Cut->GetYaxis()->SetTitle("");
  hSum15_18Cut->GetYaxis()->CenterTitle();
  hSum15_18Cut->SetFillColor(0);
  hSum15_18Cut->SetBit(TH1::kCanRebin);

  TH1F *hSum15_18=new TH1F("hSum15_18","hSum15_18",500,-1,10);
  hSum15_18->SetTitle("Energy Deposition per MEU");
  hSum15_18->GetXaxis()->SetTitle("MeV");
  hSum15_18->GetXaxis()->CenterTitle();
  hSum15_18->GetYaxis()->SetTitle("");
  hSum15_18->GetYaxis()->CenterTitle();
  hSum15_18->SetFillColor(0);
  hSum15_18->SetBit(TH1::kCanRebin);

  TH1F *hSum15_18Truth=new TH1F("hSum15_18Truth","hSum15_18Truth",
                                500,-1,10);
  hSum15_18Truth->SetTitle("Energy Deposition per MEU (True Track)");
  hSum15_18Truth->GetXaxis()->SetTitle("MeV");
  hSum15_18Truth->GetXaxis()->CenterTitle();
  hSum15_18Truth->GetYaxis()->SetTitle("");
  hSum15_18Truth->GetYaxis()->CenterTitle();
  hSum15_18Truth->SetFillColor(0);
  hSum15_18Truth->SetBit(TH1::kCanRebin);

  TH1F *hSumEnDep=new TH1F("hSumEnDep","hSumEnDep",
                             2000,-5./1000,50./1000);
  hSumEnDep->GetXaxis()->SetTitle("Sum of Energy Dep. in Whole Event");
  hSumEnDep->GetXaxis()->SetTitle("SumEnDep");
  hSumEnDep->GetXaxis()->CenterTitle();
  hSumEnDep->GetYaxis()->SetTitle("");
  hSumEnDep->GetYaxis()->CenterTitle();
  hSumEnDep->SetFillColor(0);
  hSumEnDep->SetBit(TH1::kCanRebin);

  TH1F *hSumEnDepLateT1=new TH1F("hSumEnDepLateT1","hSumEnDepLateT1",
                             2000,-5./1000,50./1000);
  hSumEnDepLateT1->GetXaxis()->SetTitle("SumEnDep");
  hSumEnDepLateT1->GetXaxis()->CenterTitle();
  hSumEnDepLateT1->GetYaxis()->SetTitle("");
  hSumEnDepLateT1->GetYaxis()->CenterTitle();
  hSumEnDepLateT1->SetFillColor(0);
  hSumEnDepLateT1->SetBit(TH1::kCanRebin);

  TH1F *hSumEnDepLateT1Cut=new TH1F("hSumEnDepLateT1Cut",
                                    "hSumEnDepLateT1Cut",
                                    2000,-5./1000,50./1000);
  hSumEnDepLateT1Cut->GetXaxis()->SetTitle("SumEnDep");
  hSumEnDepLateT1Cut->GetXaxis()->CenterTitle();
  hSumEnDepLateT1Cut->GetYaxis()->SetTitle("");
  hSumEnDepLateT1Cut->GetYaxis()->CenterTitle();
  hSumEnDepLateT1Cut->SetFillColor(0);
  hSumEnDepLateT1Cut->SetBit(TH1::kCanRebin);

  TH1F *hSumEnDepLateT2=new TH1F("hSumEnDepLateT2","hSumEnDepLateT2",
                             2000,-5./1000,50./1000);
  hSumEnDepLateT2->GetXaxis()->SetTitle("SumEnDep");
  hSumEnDepLateT2->GetXaxis()->CenterTitle();
  hSumEnDepLateT2->GetYaxis()->SetTitle("");
  hSumEnDepLateT2->GetYaxis()->CenterTitle();
  hSumEnDepLateT2->SetFillColor(0);
  hSumEnDepLateT2->SetBit(TH1::kCanRebin);

  TH1F *hRatioScToBeam=new TH1F("hRatioScToBeam","hRatioScToBeam",
                                500,-5./1000,100./1000);
  hRatioScToBeam->GetXaxis()->SetTitle("Esc/Ebeam");
  hRatioScToBeam->GetXaxis()->CenterTitle();
  hRatioScToBeam->GetYaxis()->SetTitle("");
  hRatioScToBeam->GetYaxis()->CenterTitle();
  hRatioScToBeam->SetFillColor(0);
  hRatioScToBeam->SetBit(TH1::kCanRebin);

  TH1F *hRatioScToBeamCut=new TH1F("hRatioScToBeamCut",
                                   "hRatioScToBeamCut",
                                   500,-5./1000,100./1000);
  hRatioScToBeamCut->GetXaxis()->SetTitle("Esc/Ebeam");
  hRatioScToBeamCut->GetXaxis()->CenterTitle();
  hRatioScToBeamCut->GetYaxis()->SetTitle("");
  hRatioScToBeamCut->GetYaxis()->CenterTitle();
  hRatioScToBeamCut->SetFillColor(0);
  hRatioScToBeamCut->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDep=new TH1F("hTotalEnDep","hTotalEnDep",
                             2000,-5./1000,50./1000);
  hTotalEnDep->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDep->GetXaxis()->CenterTitle();
  hTotalEnDep->GetYaxis()->SetTitle("");
  hTotalEnDep->GetYaxis()->CenterTitle();
  hTotalEnDep->SetFillColor(0);
  hTotalEnDep->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDepMu=new TH1F("hTotalEnDepMu","hTotalEnDepMu",
                             2000,-5./1000,50./1000);
  hTotalEnDepMu->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDepMu->GetXaxis()->CenterTitle();
  hTotalEnDepMu->GetYaxis()->SetTitle("");
  hTotalEnDepMu->GetYaxis()->CenterTitle();
  hTotalEnDepMu->SetFillColor(0);
  hTotalEnDepMu->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDep2=new TH1F("hTotalEnDep2","hTotalEnDep2",
                             2000,-5./1000,50./1000);
  hTotalEnDep2->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDep2->GetXaxis()->CenterTitle();
  hTotalEnDep2->GetYaxis()->SetTitle("");
  hTotalEnDep2->GetYaxis()->CenterTitle();
  hTotalEnDep2->SetFillColor(0);
  hTotalEnDep2->SetBit(TH1::kCanRebin);

  TH1F *hTotalEnDep3=new TH1F("hTotalEnDep3","hTotalEnDep3",
                             2000,-5./1000,50./1000);
  hTotalEnDep3->GetXaxis()->SetTitle("TotalEnDep");
  hTotalEnDep3->GetXaxis()->CenterTitle();
  hTotalEnDep3->GetYaxis()->SetTitle("");
  hTotalEnDep3->GetYaxis()->CenterTitle();
  hTotalEnDep3->SetFillColor(0);
  hTotalEnDep3->SetBit(TH1::kCanRebin);

  TH1F *hMainPartEn=new TH1F("hMainPartEn","hMainPartEn",1000,-0.5,2);
  hMainPartEn->GetXaxis()->SetTitle("MainPartEn");
  hMainPartEn->GetXaxis()->CenterTitle();
  hMainPartEn->GetYaxis()->SetTitle("");
  hMainPartEn->GetYaxis()->CenterTitle();
  hMainPartEn->SetFillColor(0);
  hMainPartEn->SetBit(TH1::kCanRebin);

  TH1F *hMainPartEn0=new TH1F("hMainPartEn0","hMainPartEn0",500,-0.5,2);
  hMainPartEn0->GetXaxis()->SetTitle("MainPartEn0");
  hMainPartEn0->GetXaxis()->CenterTitle();
  hMainPartEn0->GetYaxis()->SetTitle("");
  hMainPartEn0->GetYaxis()->CenterTitle();
  hMainPartEn0->SetFillColor(0);
  hMainPartEn0->SetBit(TH1::kCanRebin);

  TH1F *hMainPathLength=new TH1F("hMainPathLength","hMainPathLength",
                                 500,-0.01,0.1);
  hMainPathLength->GetXaxis()->SetTitle("MainPathLength");
  hMainPathLength->GetXaxis()->CenterTitle();
  hMainPathLength->GetYaxis()->SetTitle("");
  hMainPathLength->GetYaxis()->CenterTitle();
  hMainPathLength->SetFillColor(0);
  hMainPathLength->SetBit(TH1::kCanRebin);

  TH1F *hMainPLInPlane=new TH1F("hMainPLInPlane","hMainPLInPlane",
                                500,-0.01,0.1);
  hMainPLInPlane->GetXaxis()->SetTitle("MainPathLength");
  hMainPLInPlane->GetXaxis()->CenterTitle();
  hMainPLInPlane->GetYaxis()->SetTitle("");
  hMainPLInPlane->GetYaxis()->CenterTitle();
  hMainPLInPlane->SetFillColor(0);
  hMainPLInPlane->SetBit(TH1::kCanRebin);

  fS="Strip Vs Plane EnergyDep Map";
  TProfile2D* pStVsPlEnDep=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDep->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDep->GetXaxis()->CenterTitle();
  pStVsPlEnDep->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDep->GetYaxis()->CenterTitle();
  pStVsPlEnDep->SetFillColor(0);
  //pStVsPlEnDep->SetMaximum(15000);

  fS="Strip Vs Plane EnergyDepMu Map";
  TProfile2D* pStVsPlEnDepMu=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDepMu->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDepMu->GetXaxis()->CenterTitle();
  pStVsPlEnDepMu->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDepMu->GetYaxis()->CenterTitle();
  pStVsPlEnDepMu->SetFillColor(0);
  //pStVsPlEnDepMu->SetMaximum(15000);

  fS="Strip Vs Plane EnergyDepNotMu Map";
  TProfile2D* pStVsPlEnDepNotMu=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDepNotMu->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDepNotMu->GetXaxis()->CenterTitle();
  pStVsPlEnDepNotMu->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDepNotMu->GetYaxis()->CenterTitle();
  pStVsPlEnDepNotMu->SetFillColor(0);
  //pStVsPlEnDepNotMu->SetMaximum(15000);

  fS="Strip Vs Plane EnergyDepNotMuLate Map";
  TProfile2D* pStVsPlEnDepNotMuLate=new TProfile2D(fS.c_str(),fS.c_str(),
                                           64,-2,62,30,-3,27);
  pStVsPlEnDepNotMuLate->GetXaxis()->SetTitle("Plane");
  pStVsPlEnDepNotMuLate->GetXaxis()->CenterTitle();
  pStVsPlEnDepNotMuLate->GetYaxis()->SetTitle("Strip");
  pStVsPlEnDepNotMuLate->GetYaxis()->CenterTitle();
  pStVsPlEnDepNotMuLate->SetFillColor(0);
  //pStVsPlEnDepNotMuLate->SetMaximum(15000);

  fS="Strip Vs Plane Num Hits Map";
  TH2F* hStVsPlNum=new TH2F(fS.c_str(),fS.c_str(),64,-2,62,30,-3,27);
  hStVsPlNum->GetXaxis()->SetTitle("Plane");
  hStVsPlNum->GetXaxis()->CenterTitle();
  hStVsPlNum->GetYaxis()->SetTitle("Strip");
  hStVsPlNum->GetYaxis()->CenterTitle();
  hStVsPlNum->SetFillColor(0);
  //hStVsPlNum->SetMaximum(15000);

  fS="Strip Vs Plane NumMu Hits Map";
  TH2F* hStVsPlNumMu=new TH2F(fS.c_str(),fS.c_str(),64,-2,62,30,-3,27);
  hStVsPlNumMu->GetXaxis()->SetTitle("Plane");
  hStVsPlNumMu->GetXaxis()->CenterTitle();
  hStVsPlNumMu->GetYaxis()->SetTitle("Strip");
  hStVsPlNumMu->GetYaxis()->CenterTitle();
  hStVsPlNumMu->SetFillColor(0);
  //hStVsPlNumMu->SetMaximum(15000);

  fS="Strip Vs Plane NumNotMu Hits Map";
  TH2F* hStVsPlNumNotMu=new TH2F(fS.c_str(),fS.c_str(),
                                 64,-2,62,30,-3,27);
  hStVsPlNumNotMu->GetXaxis()->SetTitle("Plane");
  hStVsPlNumNotMu->GetXaxis()->CenterTitle();
  hStVsPlNumNotMu->GetYaxis()->SetTitle("Strip");
  hStVsPlNumNotMu->GetYaxis()->CenterTitle();
  hStVsPlNumNotMu->SetFillColor(0);
  //hStVsPlNumNotMu->SetMaximum(15000);

  fS="Strip Vs Plane NumNotMuLate Hits Map";
  TH2F* hStVsPlNumNotMuLate=new TH2F(fS.c_str(),fS.c_str(),
                                 64,-2,62,30,-3,27);
  hStVsPlNumNotMuLate->GetXaxis()->SetTitle("Plane");
  hStVsPlNumNotMuLate->GetXaxis()->CenterTitle();
  hStVsPlNumNotMuLate->GetYaxis()->SetTitle("Strip");
  hStVsPlNumNotMuLate->GetYaxis()->CenterTitle();
  hStVsPlNumNotMuLate->SetFillColor(0);
  //hStVsPlNumNotMuLate->SetMaximum(15000);

  fS="Path Length Vs EnDep";
  TH2F* hPathLenVsEnDep=new TH2F(fS.c_str(),fS.c_str(),
                                 500,-1./1000,10./1000,
                                 500,-0.005,0.04);
  hPathLenVsEnDep->GetXaxis()->SetTitle("EnDep");
  hPathLenVsEnDep->GetXaxis()->CenterTitle();
  hPathLenVsEnDep->GetYaxis()->SetTitle("Path Length");
  hPathLenVsEnDep->GetYaxis()->CenterTitle();
  hPathLenVsEnDep->SetFillColor(0);
  //hPathLenVsEnDep->SetMaximum(15000);

  fS="EnDep Vs Plane";
  TProfile* pEnDepVsPl=new TProfile(fS.c_str(),fS.c_str(),66,-4,62);
  pEnDepVsPl->GetXaxis()->SetTitle("Plane");
  pEnDepVsPl->GetXaxis()->CenterTitle();
  pEnDepVsPl->GetYaxis()->SetTitle("EnDep");
  pEnDepVsPl->GetYaxis()->CenterTitle();
  pEnDepVsPl->SetFillColor(0);
  //pEnDepVsPl->SetMaximum(15000);

  fS="MainParticle Energy Vs Plane";
  TProfile* pEnVsPl=new TProfile(fS.c_str(),fS.c_str(),66,-4,62);
  pEnVsPl->GetXaxis()->SetTitle("Plane");
  pEnVsPl->GetXaxis()->CenterTitle();
  pEnVsPl->GetYaxis()->SetTitle("MainParticle Energy");
  pEnVsPl->GetYaxis()->CenterTitle();
  pEnVsPl->SetFillColor(0);
  //pEnVsPl->SetMaximum(15000);

  fS="Esc/Ebeam Vs Last Plane";
  TProfile* pEscEbeamVsLastPl=new TProfile("pEscEbeamVsLastPl",
                                           fS.c_str(),66,-4,62);
  pEscEbeamVsLastPl->GetXaxis()->SetTitle("Last Plane");
  pEscEbeamVsLastPl->GetXaxis()->CenterTitle();
  pEscEbeamVsLastPl->GetYaxis()->SetTitle("Esc/Ebeam");
  pEscEbeamVsLastPl->GetYaxis()->CenterTitle();
  pEscEbeamVsLastPl->SetFillColor(0);
  //pEscEbeamVsLastPl->SetMaximum(15000);

  fS="Esc/Ebeam Vs First Plane Included";
  TProfile* pEscEbeamVsFirstPl=new TProfile("pEscEbeamVsFirstPl",
                                            fS.c_str(),66,-4,62);
  pEscEbeamVsFirstPl->GetXaxis()->SetTitle("First Plane Included");
  pEscEbeamVsFirstPl->GetXaxis()->CenterTitle();
  pEscEbeamVsFirstPl->GetYaxis()->SetTitle("Esc/Ebeam");
  pEscEbeamVsFirstPl->GetYaxis()->CenterTitle();
  pEscEbeamVsFirstPl->SetFillColor(0);
  //pEscEbeamVsFirstPl->SetMaximum(15000);

  Int_t straightCutCounter=0;
  Double_t simple15_18=0;
  Int_t simple15_18Counter=0;

  
  this->InitialiseLoopVariables();  
  
  for(Int_t event=0;event<fEvents;event++){
    
    this->SetLoopVariables(event);

    if (!fTruthHitInfo) break;
    TClonesArray &cTruth = *fTruthHitInfo;
    Int_t numTruthHits=fTruthHitInfo->GetEntries();
    
    MSG("CDAnalysis",Msg::kDebug)
      <<"Event="<<event
      <<", truthHits="<<numTruthHits<<endl;

    //cut on not straight tracks
    Double_t mainX1Cut=0.5;
    if (!this->IsStraightTrack(mainX1Cut)){
      straightCutCounter++;
      continue;
    }

    //calc and set fLastPlane
    this->CalcLastPlaneOnTrk();
    Int_t lastPlaneTruth=this->CalcLastPlaneTruth();

    //make event length cuts
    Bool_t goodEvLen=!(this->CutOnEventLength());
    //make track quality cuts
    //Bool_t goodTrackQuality=!(this->CutOnTrackQuality());
    //make sure that the first plane makes sense and was actually set
    Bool_t goodFirstPlane=true;
    if (fFirstPlane<0 || fFirstPlane>59) goodFirstPlane=false;

    Double_t partEn=-1;
    Double_t sumScEnDep=0;
    Double_t sumScEnDepCut=0;
    Double_t sumScEnDepLateT1=0;
    Double_t sumScEnDepLateT1Cut=0;
    Double_t sumScEnDepLateT2=0;
    Double_t sum15_18=0;
    Double_t sum15_18Truth=0;
    Double_t sum15_18Cut=0;
    Double_t simple15_18Local=0;

    for (Int_t pl=0;pl<=fLastPlane;pl++){
      Double_t mainPL=this->TrueMainPL(pl,event);
      hMainPLInPlane->Fill(mainPL);
    }

    //loop over the truth hits
    for (Int_t hit=0;hit<numTruthHits;hit++){
      //cast the tclonesarray up to a truthhitinfo object
      CDTruthHitInfo *hitInfo=
        dynamic_cast<CDTruthHitInfo*>(cTruth[hit]);
      
      Int_t plane=hitInfo->GetPlane();
      Int_t strip=hitInfo->GetStrip();
      Double_t totalEnDep=hitInfo->GetTotalEnDep();
      Double_t mainPartEn=hitInfo->GetMainPartEn();
      Double_t mainPathLength=hitInfo->GetMainPathLength();
      Double_t earliestT1=hitInfo->GetEarliestT1();
      Double_t latestT2=hitInfo->GetLatestT2();
      Int_t pmtTruth1=hitInfo->GetPmtTruth1();
      Int_t pmtTruth2=hitInfo->GetPmtTruth2();
      Int_t mainParticle=hitInfo->GetMainParticle();

      Int_t muon=13;

      if (totalEnDep==0) continue;

      //do simple window calc of 15 planes 29-15+1=15
      if (plane>=15 && plane<=29) simple15_18Local+=1000*totalEnDep;

      //get the largest particle energy
      if (mainPartEn>partEn) partEn=mainPartEn;
      if (fRunNumber==60002) partEn=1.8;

      //sum the energy deposition for every strip
      sumScEnDep+=totalEnDep;
      //sum the energy deposition for tracks passing "data" cuts
      if (goodEvLen && goodFirstPlane){
        sumScEnDepCut+=totalEnDep;
      }

      //sum the energy in the 15_18 window on the track
      //if lp=48 then >15  and <=30 then have 15 planes in total
      //make sure that there are actually 15 planes to add up
      if (fLastPlane>18+15 &&
          plane>fLastPlane-18-15 && plane<=fLastPlane-18){
        sum15_18+=1000*totalEnDep;
      }
      //sum the energy for the true end of track
      if (lastPlaneTruth>18+15 && 
          plane>lastPlaneTruth-18-15 && plane<=lastPlaneTruth-18){
        sum15_18Truth+=1000*totalEnDep;
      }     
      //sum the energy for the tracks that pass data selection cuts
      if (goodEvLen && goodFirstPlane &&
          plane>lastPlaneTruth-18-15 && plane<=lastPlaneTruth-18){
        sum15_18Cut+=1000*totalEnDep;
      }
      

      if (plane==0) {
        if (abs(mainParticle)==muon) hMainPartEn0->Fill(mainPartEn);
        if (mainPartEn==0){
          MSG("CDAnalysis",Msg::kInfo)
            <<"mainPart="<<mainParticle
            <<", mainPL="<<mainPathLength
            <<", truth1="<<pmtTruth1
            <<", truth2="<<pmtTruth2<<endl;
        }
      }

      hTotalEnDep->Fill(totalEnDep);
      hMainPartEn->Fill(mainPartEn);
      hMainPathLength->Fill(mainPathLength);

      pStVsPlEnDep->Fill(plane,strip,totalEnDep);
      hStVsPlNum->Fill(plane,strip,1);
      if (mainParticle==muon){
        hPathLenVsEnDep->Fill(totalEnDep,mainPathLength,1);

        hTotalEnDepMu->Fill(totalEnDep);
        pStVsPlEnDepMu->Fill(plane,strip,totalEnDep);
        hStVsPlNumMu->Fill(plane,strip,1);
      }
      if (mainParticle!=muon){
        hTotalEnDep2->Fill(totalEnDep);
        pStVsPlEnDepNotMu->Fill(plane,strip,totalEnDep);
        hStVsPlNumNotMu->Fill(plane,strip,1);

        //fill the late histos
        if (earliestT1>15e-9){
          hTotalEnDep3->Fill(totalEnDep);
          pStVsPlEnDepNotMuLate->Fill(plane,strip,totalEnDep);
          hStVsPlNumNotMuLate->Fill(plane,strip,1);

          //sum the energy deposition for every strip
          sumScEnDepLateT1+=totalEnDep;
        }
        if (latestT2>15e-9){
          sumScEnDepLateT2+=totalEnDep;
        }
        if (earliestT1>15e-9 && earliestT1<500e-9){
          //sum the energy deposition for every strip
          sumScEnDepLateT1Cut+=totalEnDep;
        }
      }
      
      //look at a particular plane
      if (plane==20){
        hPl20->Fill(1000*totalEnDep);
        if (mainParticle==muon){
          hPl20Mu->Fill(1000*totalEnDep);
        }
        else{
          hPl20NotMu->Fill(1000*totalEnDep);
        }
      }

      pEnDepVsPl->Fill(plane,totalEnDep);
      if (mainParticle==muon) pEnVsPl->Fill(plane,mainPartEn);
    }
    //end of loop over the truth hits

    //look at dependence of ratio on which planes are included
    for (Int_t firstPl=0;firstPl<60;firstPl++){
      if (firstPl<fLastPlane){
        pEscEbeamVsFirstPl->Fill(firstPl,sumScEnDep/partEn);
      }
    }

    //do simple window calc
    if (simple15_18Local>0){
      simple15_18+=simple15_18Local;
      simple15_18Counter++;
      MAXMSG("CDAnalysis",Msg::kInfo,1)
        <<"simple 15_18 local="<<simple15_18Local/15
        <<", av="<<(simple15_18/15)/simple15_18Counter
        <<" (N="<<simple15_18Counter<<")"<<endl;
    }

    //fill the histos
    hSumEnDep->Fill(sumScEnDep);
    hSumEnDepLateT1->Fill(sumScEnDepLateT1);
    hSumEnDepLateT1Cut->Fill(sumScEnDepLateT1Cut);
    hSumEnDepLateT2->Fill(sumScEnDepLateT2);
    if (partEn) {
      hRatioScToBeam->Fill(sumScEnDep/partEn);
      //fill the prof
      pEscEbeamVsLastPl->Fill(fLastPlane,sumScEnDep/partEn);

      if (sumScEnDepCut>0) hRatioScToBeamCut->
                             Fill(sumScEnDepCut/partEn);
    }
    else MSG("CDAnalysis",Msg::kWarning)<<"partEn="<<partEn<<endl;

    if (sum15_18<10 && sum15_18>0){
      MSG("CDAnalysis",Msg::kInfo)
        <<"Very low 15_18="<<sum15_18/15<<", event="<<event<<endl;
    }
    if (sum15_18>0) hSum15_18->Fill(sum15_18/15);
    if (sum15_18Cut>0) hSum15_18Cut->Fill(sum15_18Cut/15);
    if (sum15_18Truth>0) hSum15_18Truth->Fill(sum15_18Truth/15);
    if (sum15_18>0) hSum15_18All->Fill(sum15_18);
  }//end of for                                       
  

  MSG("CDAnalysis",Msg::kInfo)<<"Finished main loop"<<endl;

  MSG("CDAnalysis",Msg::kInfo)
    <<"Straight Cut Counter="<<straightCutCounter<<endl;

  TCanvas *cSumEnDep=new TCanvas("cSumEnDep","SumEnDep",
                                 0,0,1200,800);
  cSumEnDep->SetFillColor(0);
  cSumEnDep->Divide(3,3);
  cSumEnDep->cd(1);
  hRatioScToBeam->Draw();
  cSumEnDep->cd(2);
  //hSum15_18Cut->Draw();
  hRatioScToBeamCut->Draw();
  cSumEnDep->cd(3);
  hSumEnDep->Draw();
  cSumEnDep->cd(4);
  hSumEnDepLateT1->Draw();
  cSumEnDep->cd(5);
  hSumEnDepLateT1Cut->Draw();
  cSumEnDep->cd(6);
  hSumEnDepLateT2->Draw();
  cSumEnDep->cd(7);
  hSum15_18All->Draw();
  cSumEnDep->cd(8);
  hSum15_18->Draw();
  cSumEnDep->cd(9);
  hSum15_18Truth->Draw();

  TCanvas *cEscEbeam=new TCanvas("cEscEbeam","cEscEbeam",
                                 0,0,1200,800);
  cEscEbeam->SetFillColor(0);
  cEscEbeam->Divide(1,2);
  cEscEbeam->cd(1);
  pEscEbeamVsLastPl->Draw();
  cEscEbeam->cd(2);
  pEscEbeamVsFirstPl->Draw();



  Double_t enWith500nsCut=hSumEnDep->GetMean()-
    hSumEnDepLateT1->GetMean()+
    hSumEnDepLateT1Cut->GetMean();

  Double_t partEn=1;
  if (fMainParticleEnergy>1.7 && fMainParticleEnergy<1.9) partEn=1.8;
  if (fMainParticleEnergy>1.5 && fMainParticleEnergy<1.7) partEn=1.6;
  if (fMainParticleEnergy>1.3 && fMainParticleEnergy<1.5) partEn=1.4;
  if (fMainParticleEnergy>1.1 && fMainParticleEnergy<1.3) partEn=1.2;
  if (fMainParticleEnergy>0.9 && fMainParticleEnergy<1.1) partEn=1.0;

  MSG("CDAnalysis",Msg::kInfo)
    <<endl
    <<"*** Ratio of Energy in Sc to Steel Section ***"<<endl
    <<"totalEn="<<hSumEnDep->GetMean()
    <<" +/- "<<hSumEnDep->GetRMS()/sqrt(hSumEnDep->GetEntries())
    <<" ("<<100*(hSumEnDep->GetRMS()/sqrt(hSumEnDep->GetEntries()))/
    hSumEnDep->GetMean()<<"%)"
    <<endl
    <<"ratio="<<hSumEnDep->GetMean()/partEn
    <<" +/- "<<100*(hSumEnDep->GetRMS()/sqrt(hSumEnDep->GetEntries()))/
    hSumEnDep->GetMean()<<"%"
    <<endl
    <<"lateEn(>15ns)="<<hSumEnDepLateT1->GetMean()<<endl
    <<endl
    <<"lateT1/total="<<100*hSumEnDepLateT1->GetMean()/
    hSumEnDep->GetMean()<<"%"
    <<" (ratio="<<hSumEnDepLateT1->GetMean()/partEn<<")"
    <<endl
    <<"lateT1Cut/total="<<100*hSumEnDepLateT1Cut->GetMean()/
    hSumEnDep->GetMean()<<"%"
    <<" (ratio="<<hSumEnDepLateT1Cut->GetMean()/partEn<<")"
    <<endl
    <<"lateT2/total="<<100*hSumEnDepLateT2->GetMean()/
    hSumEnDep->GetMean()<<"%"
    <<" (ratio="<<hSumEnDepLateT2->GetMean()/partEn<<")"
    <<endl
    <<endl
    <<"enWith500nsCut="<<enWith500nsCut<<endl
    <<"fMainParticleEnergy="<<fMainParticleEnergy<<" (using "
    <<partEn<<")"<<endl
    <<"ratio="<<enWith500nsCut/partEn<<endl
    <<"ratio (with track cuts)="<<hRatioScToBeamCut->GetMean()
    <<" +/- "<<100*((hRatioScToBeamCut->GetRMS()/
                     sqrt(hRatioScToBeamCut->GetEntries()))/
                    hRatioScToBeamCut->GetMean())<<"%"
    <<endl
    <<"*** End of Section ***"<<endl
    <<endl;

  MSG("CDAnalysis",Msg::kInfo)
    <<endl
    <<"*** Energy Loss in Window Section ***"<<endl
    <<"15_18="<<hSum15_18->GetMean()
    <<" MeV +/- "<<hSum15_18->GetRMS()/sqrt(hSum15_18->GetEntries())
    <<" ("<<100*((hSum15_18->GetRMS()/sqrt(hSum15_18->GetEntries()))/
                 hSum15_18->GetMean())<<"%)"
    <<", N="<<hSum15_18->GetEntries()
    <<endl
    <<"15_18Truth="<<hSum15_18Truth->GetMean()
    <<" MeV +/- "<<(hSum15_18Truth->GetRMS()/
                    sqrt(hSum15_18Truth->GetEntries()))
    <<" ("<<100*((hSum15_18Truth->GetRMS()/
                 sqrt(hSum15_18Truth->GetEntries()))/
                 hSum15_18Truth->GetMean())<<"%)"
    <<", N="<<hSum15_18Truth->GetEntries()
    <<endl
    <<"15_18Cut="<<hSum15_18Cut->GetMean()
    <<" MeV +/- "<<(hSum15_18Cut->GetRMS()/
                    sqrt(hSum15_18Cut->GetEntries()))
    <<" ("<<100*((hSum15_18Cut->GetRMS()/
                 sqrt(hSum15_18Cut->GetEntries()))/
                 hSum15_18Cut->GetMean())<<"%)"
    <<", N="<<hSum15_18Cut->GetEntries()
    <<endl
    <<"*** End of Section ***"<<endl
    <<endl;

  TCanvas *cMainParticle=new TCanvas("cMainParticle","MainParticle",
                                     0,0,1200,800);
  cMainParticle->SetFillColor(0);
  cMainParticle->Divide(2,2);
  cMainParticle->cd(1);
  hMainPartEn0->Draw();
  cMainParticle->cd(2);
  hTotalEnDep->Draw();
  cMainParticle->cd(3);
  hMainPartEn->Draw();
  cMainParticle->cd(4);
  hMainPathLength->Draw();

  TCanvas *cEnDep=new TCanvas("cEnDep","EnDep",
                                     0,0,1200,800);
  cEnDep->SetFillColor(0);
  cEnDep->Divide(2,3);
  cEnDep->cd(1);
  hTotalEnDep->Draw();
  cEnDep->cd(2);
  hTotalEnDepMu->Draw();
  cEnDep->cd(3);
  hTotalEnDep2->Draw();
  cEnDep->cd(4);
  hTotalEnDep3->Draw();
  cEnDep->cd(5);

  cEnDep->cd(6);


  TCanvas *cStVsPlEnDep=new TCanvas("cStVsPlEnDep","StVsPlEnDep",
                                    0,0,1200,800);
  cStVsPlEnDep->SetFillColor(0);
  pStVsPlEnDep->Draw("colz");

  TCanvas *cStVsPlEnDepMu=new TCanvas("cStVsPlEnDepMu","StVsPlEnDepMu",
                                    0,0,1200,800);
  cStVsPlEnDepMu->SetFillColor(0);
  cStVsPlEnDepMu->Divide(2,2);
  cStVsPlEnDepMu->cd(1);
  pStVsPlEnDep->Draw("colz");
  cStVsPlEnDepMu->cd(2);
  pStVsPlEnDepMu->Draw("colz");
  cStVsPlEnDepMu->cd(3);
  pStVsPlEnDepNotMu->Draw("colz");
  cStVsPlEnDepMu->cd(4);
  pStVsPlEnDepNotMuLate->Draw("colz");

  TCanvas *cStVsPlNum=new TCanvas("cStVsPlNum","StVsPlNum",
                                  0,0,1200,800);
  cStVsPlNum->SetFillColor(0);
  cStVsPlNum->Divide(2,2);
  cStVsPlNum->cd(1);
  hStVsPlNum->Draw("colz");
  cStVsPlNum->cd(2);
  hStVsPlNumMu->Draw("colz");
  cStVsPlNum->cd(3);
  hStVsPlNumNotMu->Draw("colz");
  cStVsPlNum->cd(4);
  hStVsPlNumNotMuLate->Draw("colz");

  TCanvas *cEnVsPl=new TCanvas("cEnVsPl","cEnVsPl",0,0,1200,800);
  cEnVsPl->SetFillColor(0);
  cEnVsPl->Divide(2,2);
  cEnVsPl->cd(1);
  pEnDepVsPl->Draw();
  cEnVsPl->cd(2);
  pEnVsPl->Draw();
  cEnVsPl->cd(3);
  hPl20->Draw();
  cEnVsPl->cd(4);
  hPl20Mu->Draw();
  hPl20NotMu->Draw("sames");

  TCanvas *cPathLenVsEnDep=new TCanvas("cPathLenVsEnDep",
                                       "cPathLenVsEnDep",0,0,1200,800);
  cPathLenVsEnDep->SetFillColor(0);
  //cPathLenVsEnDep->Divide(1,2);
  //cPathLenVsEnDep->cd(1);
  hPathLenVsEnDep->Draw("colz");

  MSG("CDAnalysis",Msg::kInfo) 
    <<" ** Finished TruthEnDep method **"<<endl;
}

//......................................................................

---