CandShieldSR.cxx

Go to the documentation of this file.

#include <iostream>
#include "TCanvas.h"
#include "TMath.h"
#include "TMatrixD.h"
#include "TVector3.h"
#include "TH1.h"
#include "TH2.h"
#include "TSystem.h"
#include "TChain.h"
#include "MessageService/MsgService.h"
#include "CandNtupleSR/NtpSRRecord.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "CandNtupleSR/NtpSRStrip.h"
#include "CandNtupleSR/NtpSRShieldStrip.h"
#include "CandNtupleSR/NtpSRVertex.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexPlaneId.h"
#include <fstream>
#include "Validity/VldTimeStamp.h"
#include "CandShield/ShieldGeom.h"
#include "CandShield/ShieldProj.h"
#include "CandShieldSR.h" 

using std::endl;
using std::cout;
using std::ifstream;
using std::ofstream;

// ******** STATIC DATA MEMBERS **********

CVSID("$Id: CandShieldSR.cxx,v 1.11 2009/05/09 22:55:24 jpochoa Exp $");

// **************** CONSTRUCTOR & DESTRUCTOR *********************

CandShieldSR::CandShieldSR(Double_t vtx0_in, Double_t vtx1_in, Double_t vtx2_in, Double_t vtxCos0_in, Double_t vtxCos1_in, Double_t vtxCos2_in, ShieldGeom* sg){
  vtx0 = vtx0_in;
  vtx1 = vtx1_in;
  vtx2 = vtx2_in;
  vtxCos0 = vtxCos0_in;
  vtxCos1 = vtxCos1_in;
  vtxCos2 = vtxCos2_in;

  //Plane Array
  for(int sec=0;sec<=3;sec++){  
    for(int ii=0;ii<=31;ii++){
      PlaneArray[ii+sec*42]=528+ii+sec*64;
    }
    for(int ii=0;ii<=5;ii++){
      PlaneArray[ii+32+sec*42]=563+ii+sec*64;
    }
    for(int ii=0;ii<=3;ii++){
      PlaneArray[ii+38+sec*42]=572+ii+sec*64;
    }
  }
    
  //What Plank?

  //Initialising variables
  Int_t pln=0;
  Double_t dpv=0;
  Double_t dis_min=20000;
  hit_closest=0;
  Int_t list_plane=0;
  Int_t list_strip=0;
  Double_t list_dist=0;
  Double_t list_dist_max=1000;
  for(int ii=0;ii<12;ii++){
    min_dpv[ii]=10000; //has to be smaller than default value for dis_min
    proj_plane[ii]=-1;  
    proj_plank[ii]=-1;
    inter0_chosen[ii]=-100;
    inter1_chosen[ii]=-100;
    inter2_chosen[ii]=-100;
    st_strip_chosen[ii]=-1;
    st_plane_chosen[ii]=-1;
  }
  hit_cont=0;
  MSG("CandShield",Msg::kDebug) << "About to find shield intersections." << endl; 
  for(int pl=0;pl<168;pl++){
    for(int st=0;st<20;st++){
      if(sg->PlankExists(PlaneArray[pl],st)==true && sg->IsPlaneActive(PlaneArray[pl])){
        pln=PlaneArray[pl];
        
        ShieldProj sp(vtx0,vtx1,vtx2,vtxCos0,vtxCos1,vtxCos2,pln,st,sg);
        dpv=sp.GetProjDis();
        inter0=sp.GetProjInter_X();
        inter1=sp.GetProjInter_Y();
        inter2=sp.GetProjInter_Z();
        
        if(sp.ProjHitPlank()==true){
          hit_cont+=1;
          if(hit_cont<13){
            min_dpv[hit_cont-1] = dpv;
            proj_plane[hit_cont-1]=pl;
            proj_plank[hit_cont-1]=st;          
            inter0_chosen[hit_cont-1]=inter0;
            inter1_chosen[hit_cont-1]=inter1;
            inter2_chosen[hit_cont-1]=inter2;
          }
          else {
            MSG("CandShield",Msg::kDebug) << "Finding more than 12 hits in the shield for this track!" << endl; 
          }
        }
      }
    }
  }
  
  MSG("CandShield",Msg::kDebug) << "Finding hit strip in plank." << endl; 
  //What strip
  for(int incr=0;incr<hit_cont;incr++){
    if(incr<12){
      list_dist_max=1000; 
      for(int ls=0;ls<sg->GetStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr]);ls++){
        list_plane=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,0);
        list_strip=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,1);
        list_dist=sqrt(pow((sg->GetStrip_X(list_plane,list_strip)-inter0_chosen[incr]),2)+pow((sg->GetStrip_Y(list_plane,list_strip)-inter1_chosen[incr]),2));    
        if(list_dist<list_dist_max){
          list_dist_max=list_dist;
          st_strip_chosen[incr]=list_strip;
          st_plane_chosen[incr]=list_plane;
        }
      }
    }
  }
  
  
  //Determining the closest to center hit
  for(int ii=0;ii<12;ii++){
    if(min_dpv[ii]<dis_min){
      dis_min=min_dpv[ii];
      hit_closest=ii;
    }
  }
  
}//end of first constructor

CandShieldSR::CandShieldSR(NtpSRTrack* ntpTrack,ShieldGeom* sg){

  //Definitions
  Double_t vtx[3];
  Double_t dcosVtx[3];
  Double_t end[3];
  Double_t dcosEnd[3];
  Double_t min_dpv_vtx[12];
  Double_t inter0_chosen_vtx[12];
  Double_t inter1_chosen_vtx[12];
  Double_t inter2_chosen_vtx[12];
  Int_t proj_plane_vtx[12];
  Int_t proj_plank_vtx[12];
  Double_t min_dpv_end[12];
  Double_t inter0_chosen_end[12];
  Double_t inter1_chosen_end[12];
  Double_t inter2_chosen_end[12];
  Int_t proj_plane_end[12];
  Int_t proj_plank_end[12];
  Int_t hit_cont_vtx;
  Int_t hit_cont_end;
  Double_t dist_vtx;
  Double_t dist_end;

  //Getting vertex & end information
  vtx[0] = ntpTrack->vtx.x; 
  vtx[1] = ntpTrack->vtx.y; 
  vtx[2] = ntpTrack->vtx.z; 
  dcosVtx[0] = ntpTrack->vtx.dcosx;
  dcosVtx[1] = ntpTrack->vtx.dcosy;
  dcosVtx[2] = ntpTrack->vtx.dcosz;
  end[0] = ntpTrack->end.x; 
  end[1] = ntpTrack->end.y; 
  end[2] = ntpTrack->end.z; 
  dcosEnd[0] = ntpTrack->end.dcosx;
  dcosEnd[1] = ntpTrack->end.dcosy;
  dcosEnd[2] = ntpTrack->end.dcosz;
    
  //Plane Array
  for(int sec=0;sec<=3;sec++){  
    for(int ii=0;ii<=31;ii++){
      PlaneArray[ii+sec*42]=528+ii+sec*64;
    }
    for(int ii=0;ii<=5;ii++){
      PlaneArray[ii+32+sec*42]=563+ii+sec*64;
    }
    for(int ii=0;ii<=3;ii++){
      PlaneArray[ii+38+sec*42]=572+ii+sec*64;
    }
  }
    
  //Finding intersected planks
  //--------------------------

  //Initialising variables
  Double_t dis_min=20000;
  hit_closest=0;
  Int_t list_plane=0;
  Int_t list_strip=0;
  Double_t list_dist=0;
  Double_t list_dist_max=1000;
  for(int ii=0;ii<12;ii++){
    min_dpv[ii]=10000; //has to be smaller than default value for dis_min
    proj_plane[ii]=-1;  
    proj_plank[ii]=-1;
    inter0_chosen[ii]=-100;
    inter1_chosen[ii]=-100;
    inter2_chosen[ii]=-100;
    st_strip_chosen[ii]=-1;
    st_plane_chosen[ii]=-1;
  }

  //Intersections using vtx and end separately
  Int_t pln=0;
  Double_t dpv=0;
  hit_cont_vtx=0;
  hit_cont_end=0;
  MSG("CandShield",Msg::kDebug) << "About to find shield intersections." << endl; 
  for(int pl=0;pl<168;pl++){
    for(int st=0;st<20;st++){
      if(sg->PlankExists(PlaneArray[pl],st)==true){
        pln=PlaneArray[pl];
        
        ShieldProj sp_vtx(vtx[0],vtx[1],vtx[2],dcosVtx[0],dcosVtx[1],dcosVtx[2],pln,st,sg);
        dpv=sp_vtx.GetProjDis();
        inter0=sp_vtx.GetProjInter_X();
        inter1=sp_vtx.GetProjInter_Y();
        inter2=sp_vtx.GetProjInter_Z();
        
        if(sp_vtx.ProjHitPlank()==true){
          hit_cont_vtx+=1;
          if(hit_cont_vtx<13){
            min_dpv_vtx[hit_cont_vtx-1] = dpv;
            proj_plane_vtx[hit_cont_vtx-1]=pl;
            proj_plank_vtx[hit_cont_vtx-1]=st;          
            inter0_chosen_vtx[hit_cont_vtx-1]=inter0;
            inter1_chosen_vtx[hit_cont_vtx-1]=inter1;
            inter2_chosen_vtx[hit_cont_vtx-1]=inter2;       
          }      
        }

        
        ShieldProj sp_end(end[0],end[1],end[2],dcosEnd[0],dcosEnd[1],dcosEnd[2],pln,st,sg);
        dpv=sp_end.GetProjDis();
        inter0=sp_end.GetProjInter_X();
        inter1=sp_end.GetProjInter_Y();
        inter2=sp_end.GetProjInter_Z();
        
        if(sp_end.ProjHitPlank()==true){
          hit_cont_end+=1;
          if(hit_cont_end<13){
            min_dpv_end[hit_cont_end-1] = dpv;
            proj_plane_end[hit_cont_end-1]=pl;
            proj_plank_end[hit_cont_end-1]=st;          
            inter0_chosen_end[hit_cont_end-1]=inter0;
            inter1_chosen_end[hit_cont_end-1]=inter1;
            inter2_chosen_end[hit_cont_end-1]=inter2;       
          }      
          else {
            MSG("CandShield",Msg::kDebug) << "Found more than 12 hits in the shield for this track!" << endl; 
          }
        }
      }
    }
  }
  
  //looping over separate vtx and end hits and keeping the good ones
  hit_cont=0;
  for(int ht=0;ht<hit_cont_vtx;ht++){
    dist_vtx=sqrt(pow(vtx[0]-inter0_chosen_vtx[ht],2)+pow(vtx[1]-inter1_chosen_vtx[ht],2)+pow(vtx[2]-inter2_chosen_vtx[ht],2));
    dist_end=sqrt(pow(end[0]-inter0_chosen_vtx[ht],2)+pow(end[1]-inter1_chosen_vtx[ht],2)+pow(end[2]-inter2_chosen_vtx[ht],2));
    if(dist_vtx<dist_end && hit_cont<13 && ht<12){ 
      hit_cont+=1;
      min_dpv[hit_cont-1]=min_dpv_vtx[ht];
      proj_plane[hit_cont-1]=proj_plane_vtx[ht];
      proj_plank[hit_cont-1]=proj_plank_vtx[ht];
      inter0_chosen[hit_cont-1]=inter0_chosen_vtx[ht];
      inter1_chosen[hit_cont-1]=inter1_chosen_vtx[ht];
      inter2_chosen[hit_cont-1]=inter2_chosen_vtx[ht];
    }
  }
  for(int ht=0;ht<hit_cont_end;ht++){
    dist_vtx=sqrt(pow(vtx[0]-inter0_chosen_end[ht],2)+pow(vtx[1]-inter1_chosen_end[ht],2)+pow(vtx[2]-inter2_chosen_end[ht],2));
    dist_end=sqrt(pow(end[0]-inter0_chosen_end[ht],2)+pow(end[1]-inter1_chosen_end[ht],2)+pow(end[2]-inter2_chosen_end[ht],2));
    if(dist_end<dist_vtx && hit_cont<13 && ht<12){
      hit_cont+=1;
      min_dpv[hit_cont-1]=min_dpv_end[ht];
      proj_plane[hit_cont-1]=proj_plane_end[ht];
      proj_plank[hit_cont-1]=proj_plank_end[ht];
      inter0_chosen[hit_cont-1]=inter0_chosen_end[ht];
      inter1_chosen[hit_cont-1]=inter1_chosen_end[ht];
      inter2_chosen[hit_cont-1]=inter2_chosen_end[ht];  
    }
  }

  //What strip
  MSG("CandShield",Msg::kDebug) << "Finding hit strip in plank." << endl; 
  for(int incr=0;incr<hit_cont;incr++){
    if(incr<12){
      list_dist_max=1000; 
      for(int ls=0;ls<sg->GetStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr]);ls++){
        list_plane=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,0);
        list_strip=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,1);
        list_dist=sqrt(pow((sg->GetStrip_X(list_plane,list_strip)-inter0_chosen[incr]),2)+pow((sg->GetStrip_Y(list_plane,list_strip)-inter1_chosen[incr]),2));    
        if(list_dist<list_dist_max){
          list_dist_max=list_dist;
          st_strip_chosen[incr]=list_strip;
          st_plane_chosen[incr]=list_plane;
        }
      }
    }
  }
  
  //Determining the closest to center hit
  for(int ii=0;ii<12;ii++){
    if(min_dpv[ii]<dis_min){
      dis_min=min_dpv[ii];
      hit_closest=ii;
    }
  }

}//end of constructor

CandShieldSR::CandShieldSR(const NtpSRVertex& ntpVtx, const NtpSRVertex& ntpEnd, ShieldGeom* sg){

  //Definitions
  Double_t vtx[3];
  Double_t dcosVtx[3];
  Double_t end[3];
  Double_t dcosEnd[3];
  Double_t min_dpv_vtx[12];
  Double_t inter0_chosen_vtx[12];
  Double_t inter1_chosen_vtx[12];
  Double_t inter2_chosen_vtx[12];
  Int_t proj_plane_vtx[12];
  Int_t proj_plank_vtx[12];
  Double_t min_dpv_end[12];
  Double_t inter0_chosen_end[12];
  Double_t inter1_chosen_end[12];
  Double_t inter2_chosen_end[12];
  Int_t proj_plane_end[12];
  Int_t proj_plank_end[12];
  Int_t hit_cont_vtx;
  Int_t hit_cont_end;
  Double_t dist_vtx;
  Double_t dist_end;

  //Getting vertex & end information    
  vtx[0] = ntpVtx.x;
  vtx[1] = ntpVtx.y;
  vtx[2] = ntpVtx.z;
  dcosVtx[0] = ntpVtx.dcosx;
  dcosVtx[1] = ntpVtx.dcosy;
  dcosVtx[2] = ntpVtx.dcosz;
  end[0] = ntpEnd.x;
  end[1] = ntpEnd.y;
  end[2] = ntpEnd.z;
  dcosEnd[0] = ntpEnd.dcosx;
  dcosEnd[1] = ntpEnd.dcosy;
  dcosEnd[2] = ntpEnd.dcosz;

  //Plane Array
  for(int sec=0;sec<=3;sec++){  
    for(int ii=0;ii<=31;ii++){
      PlaneArray[ii+sec*42]=528+ii+sec*64;
    }
    for(int ii=0;ii<=5;ii++){
      PlaneArray[ii+32+sec*42]=563+ii+sec*64;
    }
    for(int ii=0;ii<=3;ii++){
      PlaneArray[ii+38+sec*42]=572+ii+sec*64;
    }
  }
    
  //Finding intersected planks
  //--------------------------

  //Initialising variables
  Double_t dis_min=20000;
  hit_closest=0;
  Int_t list_plane=0;
  Int_t list_strip=0;
  Double_t list_dist=0;
  Double_t list_dist_max=1000;
  for(int ii=0;ii<12;ii++){
    min_dpv[ii]=10000; //has to be smaller than default value for dis_min
    proj_plane[ii]=-1;  
    proj_plank[ii]=-1;
    inter0_chosen[ii]=-100;
    inter1_chosen[ii]=-100;
    inter2_chosen[ii]=-100;
    st_strip_chosen[ii]=-1;
    st_plane_chosen[ii]=-1;
  }

  //Intersections using vtx and end separately
  Int_t pln=0;
  Double_t dpv=0;
  hit_cont_vtx=0;
  hit_cont_end=0;
  MSG("CandShield",Msg::kDebug) << "About to find shield intersections." << endl; 
  for(int pl=0;pl<168;pl++){
    for(int st=0;st<20;st++){
      if(sg->PlankExists(PlaneArray[pl],st)==true){
        pln=PlaneArray[pl];
        
        ShieldProj sp_vtx(vtx[0],vtx[1],vtx[2],dcosVtx[0],dcosVtx[1],dcosVtx[2],pln,st,sg);
        dpv=sp_vtx.GetProjDis();
        inter0=sp_vtx.GetProjInter_X();
        inter1=sp_vtx.GetProjInter_Y();
        inter2=sp_vtx.GetProjInter_Z();
        
        if(sp_vtx.ProjHitPlank()==true){
          hit_cont_vtx+=1;
          if(hit_cont_vtx<13){
            min_dpv_vtx[hit_cont_vtx-1] = dpv;
            proj_plane_vtx[hit_cont_vtx-1]=pl;
            proj_plank_vtx[hit_cont_vtx-1]=st;          
            inter0_chosen_vtx[hit_cont_vtx-1]=inter0;
            inter1_chosen_vtx[hit_cont_vtx-1]=inter1;
            inter2_chosen_vtx[hit_cont_vtx-1]=inter2;       
          }     
          else {
            MSG("CandShield",Msg::kDebug) << "Found more than 12 hits in the shield for this track!" << endl; 
          }
        }

        
        ShieldProj sp_end(end[0],end[1],end[2],dcosEnd[0],dcosEnd[1],dcosEnd[2],pln,st,sg);
        dpv=sp_end.GetProjDis();
        inter0=sp_end.GetProjInter_X();
        inter1=sp_end.GetProjInter_Y();
        inter2=sp_end.GetProjInter_Z();
        
        if(sp_end.ProjHitPlank()==true){
          hit_cont_end+=1;
          if(hit_cont_end<13){
            min_dpv_end[hit_cont_end-1] = dpv;
            proj_plane_end[hit_cont_end-1]=pl;
            proj_plank_end[hit_cont_end-1]=st;          
            inter0_chosen_end[hit_cont_end-1]=inter0;
            inter1_chosen_end[hit_cont_end-1]=inter1;
            inter2_chosen_end[hit_cont_end-1]=inter2;       
          }      
        }
      }
    }
  }
  
  //looping over separate vtx and end hits and keeping the good ones
  hit_cont=0;
  for(int ht=0;ht<hit_cont_vtx;ht++){
    dist_vtx=sqrt(pow(vtx[0]-inter0_chosen_vtx[ht],2)+pow(vtx[1]-inter1_chosen_vtx[ht],2)+pow(vtx[2]-inter2_chosen_vtx[ht],2));
    dist_end=sqrt(pow(end[0]-inter0_chosen_vtx[ht],2)+pow(end[1]-inter1_chosen_vtx[ht],2)+pow(end[2]-inter2_chosen_vtx[ht],2));
    if(dist_vtx<dist_end && hit_cont<13 && ht<12){ 
      hit_cont+=1;
      min_dpv[hit_cont-1]=min_dpv_vtx[ht];
      proj_plane[hit_cont-1]=proj_plane_vtx[ht];
      proj_plank[hit_cont-1]=proj_plank_vtx[ht];
      inter0_chosen[hit_cont-1]=inter0_chosen_vtx[ht];
      inter1_chosen[hit_cont-1]=inter1_chosen_vtx[ht];
      inter2_chosen[hit_cont-1]=inter2_chosen_vtx[ht];
    }
  }
  for(int ht=0;ht<hit_cont_end;ht++){
    dist_vtx=sqrt(pow(vtx[0]-inter0_chosen_end[ht],2)+pow(vtx[1]-inter1_chosen_end[ht],2)+pow(vtx[2]-inter2_chosen_end[ht],2));
    dist_end=sqrt(pow(end[0]-inter0_chosen_end[ht],2)+pow(end[1]-inter1_chosen_end[ht],2)+pow(end[2]-inter2_chosen_end[ht],2));
    if(dist_end<dist_vtx && hit_cont<13 && ht<12){
      hit_cont+=1;
      min_dpv[hit_cont-1]=min_dpv_end[ht];
      proj_plane[hit_cont-1]=proj_plane_end[ht];
      proj_plank[hit_cont-1]=proj_plank_end[ht];
      inter0_chosen[hit_cont-1]=inter0_chosen_end[ht];
      inter1_chosen[hit_cont-1]=inter1_chosen_end[ht];
      inter2_chosen[hit_cont-1]=inter2_chosen_end[ht];  
    }
  }

  //What strip
  MSG("CandShield",Msg::kDebug) << "Finding hit strip in plank." << endl; 
  for(int incr=0;incr<hit_cont;incr++){
    if(incr<12){
      list_dist_max=1000; 
      for(int ls=0;ls<sg->GetStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr]);ls++){
        list_plane=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,0);
        list_strip=sg->GetListStripsInPlank(PlaneArray[proj_plane[incr]],proj_plank[incr],ls,1);
        list_dist=sqrt(pow((sg->GetStrip_X(list_plane,list_strip)-inter0_chosen[incr]),2)+pow((sg->GetStrip_Y(list_plane,list_strip)-inter1_chosen[incr]),2));    
        if(list_dist<list_dist_max){
          list_dist_max=list_dist;
          st_strip_chosen[incr]=list_strip;
          st_plane_chosen[incr]=list_plane;
        }
      }
    }
  }
  
  //Determining the closest to center hit
  for(int ii=0;ii<12;ii++){
    if(min_dpv[ii]<dis_min){
      dis_min=min_dpv[ii];
      hit_closest=ii;
    }
  }

}//end of constructor

CandShieldSR::~CandShieldSR() {
 
}

// ************** PRIVATE METHODS **********************************
// -----------------------------------------------------------------------
// method that tells you wether a plank is "special" or not (special planks
// are the ones that are "twisted", or "curved" (half of them is inclined
// and the other half isn't)

Bool_t CandShieldSR::specialPlank(Int_t pl,Int_t pk){
  
  Bool_t verdict;
  
  Int_t specialList[8];
  specialList[0]=566;
  specialList[1]=575;
  specialList[2]=630;
  specialList[3]=639;
  specialList[4]=694;
  specialList[5]=703;
  specialList[6]=758;
  specialList[7]=767;

  verdict=false;
  for(int pi=0;pi<8;pi++){
    if(pl==specialList[pi] && pk == 3){
      verdict = true;
    }
  }
  return verdict;
  
}

//***************** PUBLIC METHODS ********************************

// -----------------------------------------------------------------
Int_t CandShieldSR::GetCandShieldPlane(Int_t id) const {
  if(id>0 && id<=hit_cont){
    if(proj_plane[id-1]!=-1){
      return PlaneArray[proj_plane[id-1]];
    } else{
      return -1;
    }
  } else {
    MSG("CandShield",Msg::kWarning) << "GetCandShieldPlane:Input is out of bounds;Check HitsInShield" << endl; 
    return -1;
  }

}

// -----------------------------------------------------------------
Int_t CandShieldSR::GetCandShieldStrip0(Int_t id) const {
  if(id>0 && id<=hit_cont){
    return proj_plank[id-1];
  } else {
    MSG("CandShield",Msg::kWarning) << "GetCandShieldStrip0:Input is out of bounds;Check HitsInShield" << endl; 
    return -1;
  }  

}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_X(Int_t id) const{
  if(id>0 && id<=hit_cont){
    return inter0_chosen[id-1];
  } else {
    MSG("CandShield",Msg::kWarning) << "GetCandShieldInter_X:Input is out of bounds;Check HitsInShield" << endl; 
    return -100;
  }   

}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_Y(Int_t id) const{  
  if(id>0 && id<=hit_cont){
    return inter1_chosen[id-1];
  } else {
    MSG("CandShield",Msg::kWarning) << "GetCandShieldInter_Y:Input is out of bounds;Check HitsInShield" << endl; 
    return -100;
  } 
  
}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_Z(Int_t id) const{
  if(id>0 && id<=hit_cont){
    return inter2_chosen[id-1];
  } else {
    MSG("CandShield",Msg::kWarning) << "GetCandShieldInter_Z:Input is out of bounds;Check HitsInShield" << endl; 
    return -100;
  }  
  
}

// ---------------------------------------------------------------
Double_t CandShieldSR::GetInterCenterDis(Int_t id) const{
  if(id>0 && id<=hit_cont){
    return min_dpv[id-1];
  } else {
    MSG("CandShield",Msg::kWarning) << "GetInterCenterDis:Input is out of bounds;Check HitsInShield" << endl; 
    return 10000;
  }  
  
}

// ----------------------------------------------------------------
Int_t CandShieldSR::GetStripInPlank(Int_t id, Int_t plorst) const{
 if(id>0 && id<=hit_cont){ 
   if(plorst==0){
     return st_plane_chosen[id-1];
   }
   else if(plorst==1){
     return st_strip_chosen[id-1];
   }
   else{
     MSG("CandShield",Msg::kWarning) << "GetStripInPlank:Value in second field must be 0 or 1" << endl;
     return -1;
   }
 } else {
   MSG("CandShield",Msg::kWarning) << "GetStripInPlank:Value in first field is out of bounds;Check HitsInShield" << endl; 
   return -1;
 } 
}

// -----------------------------------------------------------------
Int_t CandShieldSR::GetCandShieldPlane() const {
  
  if(proj_plane[0]!=-1){
    return PlaneArray[proj_plane[hit_closest]];
  } else{
    return -1;
  }

}

// -----------------------------------------------------------------
Int_t CandShieldSR::GetCandShieldStrip0() const {

  return proj_plank[hit_closest];

}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_X() const{

  return inter0_chosen[hit_closest];

}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_Y() const{

  return inter1_chosen[hit_closest];

}

// ----------------------------------------------------------------
Double_t CandShieldSR::GetCandShieldInter_Z() const{

  return inter2_chosen[hit_closest];

}

// ---------------------------------------------------------------
Double_t CandShieldSR::GetInterCenterDis() const{

  return min_dpv[hit_closest];

}

// ---------------------------------------------------------------
Int_t CandShieldSR::GetStripInPlank(Int_t plorst) const{

 if(plorst==0){
    return st_plane_chosen[hit_closest];
  }
  else if(plorst==1){
    return st_strip_chosen[hit_closest];
  }
  else{
    MSG("CandShield",Msg::kWarning) << "GetStripInPlank:Value in first field must be 0 or 1" << endl;
    return -1;
  }    
}

// ---------------------------------------------------------------
Bool_t CandShieldSR::IsVetoHit() const{

  if(hit_cont!=0){
    return true;
  }
  else {
    return false;
  }

}

// ---------------------------------------------------------------
Int_t CandShieldSR::HitsInShield() const{

  if(hit_cont<=12){
    return hit_cont;
  }
  else {
    MSG("CandShield",Msg::kWarning) << "HitsInShield:Found more than 12 intersections for this track. Only retained 12" << endl;
    return 12;
  }

}

---