ShieldGeom.cxx

Go to the documentation of this file.

#include <cmath>
#include <iostream>
#include <fstream>
#include "TSystem.h"
#include "TVector3.h"
#include "MessageService/MsgService.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexPlaneId.h"
#include "Validity/VldContext.h"
#include "ShieldGeom.h"
using std::endl;
using std::cout;

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

CVSID("$Id: ShieldGeom.cxx,v 1.20 2008/01/04 22:27:10 bspeak Exp $");


// ************ CONSTRUCTOR **************
ShieldGeom::ShieldGeom(const VldContext& vldc){

  // 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;
    }
  }

  //Resetting the existence of planks
  for(int pl=0;pl<=167;pl++){
    for(int st=0;st<20;st++){
      VetoGeomPlank_exist[pl][st]=0;
      VetoGeomAlreadyFilled[pl][st]=0;
    }
  }
  
  if(vldc.GetDetector()==2){
    SetupShieldGeom(vldc);    
  } else{
    MSG("CandShield",Msg::kWarning) << "ShieldGeom only applies to the far detector; will not load shield geometry" << endl; 
  }

}

// ************ DESTRUCTOR ***************
ShieldGeom::~ShieldGeom(){}

// ************ PRIVATE METHODS ************
//------------------------------------------------------------------------
//method that fills the ShieldGeom object

void ShieldGeom::SetupShieldGeom(const VldContext& vldc){

  // Definitions
  Int_t vetoplane=0;
  TVector3 stripPos(0,0,0);
  Int_t ini_plank=0;
  Int_t ini_plane=0;  
  Int_t ini_plane_pnf=0;
  valid_planes=0;

  //Reading from database; Getting VldRanges
  UgliGeomHandle ugh(vldc);  
  fughVldRange=ugh.GetVldRange();
  PlexHandle ph(vldc);
  fphVldRange=ph.GetVldRange();

  //PlaneArray restructuration
  for(int pl=0;pl<=167;pl++){
    PlexPlaneId *planeid = new PlexPlaneId(Detector::kFar,PlaneArray[pl]);
    UgliPlnHandle ugp = ugh.GetScintPlnHandle(*planeid);
    delete planeid;
    if(ugp.IsValid()==true){
      PlaneValidity[pl]=true;
      valid_planes+=1;
    } 
    else {
      PlaneValidity[pl]=false;
    }
  }
    
  // 1) Planes

  MSG("CandShield",Msg::kDebug) << "Doing strips and planes in SetupShieldGeom" << endl; 
  for(int pl=0;pl<valid_planes;pl++){
    if(PlaneValidity[pl]==true){
    
      vetoplane=PlaneArray[pl];  
      PlexPlaneId *pid = new PlexPlaneId(Detector::kFar,vetoplane);    
      UgliPlnHandle ugp = ugh.GetScintPlnHandle(*pid);
      VetoGeom_x[pl]=ugp.GetX0();    
      VetoGeom_y[pl]=ugp.GetY0();
      VetoGeom_z[pl]=ugp.GetZ0();   
      VetoGeomSection[pl]=pid->GetVetoSection();
      delete pid;
      
      //get the position of the 19th strip of each plane
      PlexPlaneId plnid(Detector::kFar,vetoplane,false);
      PlexStripEndId *seid = new PlexStripEndId(plnid,19,StripEnd::kUnknown);
      UgliStripHandle ugs = ugh.GetStripHandle(*seid);
      delete seid;
      stripPos=ugs.GlobalPos(0);
      VetoGeom_x_s19[pl]=stripPos[0];
      VetoGeom_y_s19[pl]=stripPos[1];
      VetoGeom_z_s19[pl]=stripPos[2];        
    }
  }
  
  //Individual strip positions
  for(int pl=0;pl<valid_planes;pl++){
    if(PlaneValidity[pl]==true){
      vetoplane=PlaneArray[pl];
      PlexPlaneId pid(Detector::kFar,vetoplane);
      for(int st=0;st<20;st++){      
        PlexStripEndId *seid = new PlexStripEndId(pid,st,StripEnd::kUnknown);
        UgliStripHandle ugs = ugh.GetStripHandle(*seid);      
        delete seid;
        if(st==0){
          VetoPlaneClearFiber[pl][0]=ugs.ClearFiber(StripEnd::kSouth);
          VetoPlaneClearFiber[pl][1]=ugs.ClearFiber(StripEnd::kNorth);
        }
        stripPos=ugs.GlobalPos(0);
        VetoStrip_x[pl][st]=stripPos[0];
        VetoStrip_y[pl][st]=stripPos[1];
        VetoStrip_z[pl][st]=stripPos[2];
        VetoStripWls[pl][st][0]=ugs.WlsPigtail(StripEnd::kSouth);      
        VetoStripWls[pl][st][1]=ugs.WlsPigtail(StripEnd::kNorth);
      }    
    }
  }
  
  //2) Planks
  MSG("CandShield",Msg::kDebug) << "Doing planks in SetupShieldGeom" << endl;  
  for(int pl=0;pl<valid_planes;pl++){
    if(PlaneValidity[pl]==true){
      PlexPlaneId plnid(Detector::kFar,PlaneArray[pl],false);
      for(int st=0;st<=19;st++){
        PlexStripEndId pseid(plnid,st,StripEnd::kNorth);
        RawChannelId rcid = ph.GetRawChannelId(pseid);
        
        PlexStripEndId pseid_op = pseid.GetOppositeSEId();
        RawChannelId rcid_op = ph.GetRawChannelId(pseid_op);
        
        PlexSEIdAltL altlist = ph.GetSEIdAltL(rcid);
        
        //Iterate through the alt list to find the SEId with the smallest
        //plane/strip combo, and the average X, Y, and Z positions
        double MeanPlankXYZ[3] = {0.0};
        altlist.SetFirst();
        PlexStripEndId IndexSEId = altlist.GetCurrentSEId();
        while (altlist.IsValid()) {
          PlexStripEndId ThisSEId = altlist.GetCurrentSEId();
          if(ThisSEId.GetPlane() < IndexSEId.GetPlane() ||
             (ThisSEId.GetStrip() < IndexSEId.GetStrip() &&
              ThisSEId.GetPlane() == IndexSEId.GetPlane())) IndexSEId=ThisSEId;

          UgliStripHandle ugs = ugh.GetStripHandle(ThisSEId);
          stripPos = ugs.GlobalPos(0);

          MeanPlankXYZ[0] += stripPos[0];
          MeanPlankXYZ[1] += stripPos[1];
          MeanPlankXYZ[2] += stripPos[2];

          altlist.Next();
        }

        ini_plane = IndexSEId.GetPlane();
        ini_plank = IndexSEId.GetStrip();

        ini_plane_pnf = planeNumberFinder(ini_plane);
        if(ini_plane_pnf==-1){
          MSG("CandShield",Msg::kWarning) << "WARNING: Plane number returned by PlexSEIdAltL is not valid veto shield plane !! ---- Will not calculate variables for it" << endl;
          break;              
        }
            
        MeanPlankXYZ[0] = MeanPlankXYZ[0] / altlist.GetSize();
        MeanPlankXYZ[1] = MeanPlankXYZ[1] / altlist.GetSize();
        MeanPlankXYZ[2] = MeanPlankXYZ[2] / altlist.GetSize();

        VetoGeomPlank_x[ini_plane_pnf][ini_plank] = MeanPlankXYZ[0]; 
        VetoGeomPlank_y[ini_plane_pnf][ini_plank] = MeanPlankXYZ[1];
        VetoGeomPlank_z[ini_plane_pnf][ini_plank] = MeanPlankXYZ[2];

        VetoChipIndex[ini_plane_pnf][ini_plank][1]=rcid.GetCrate()*108 + rcid.GetVarcId()*36+rcid.GetVmm()*6 + rcid.GetVaAdcSel()*3+rcid.GetVaChip();
        VetoChipIndex[ini_plane_pnf][ini_plank][0]=rcid_op.GetCrate()*108 + rcid_op.GetVarcId()*36+rcid_op.GetVmm()*6 + rcid_op.GetVaAdcSel()*3+rcid_op.GetVaChip();
        VetoGeomPlank_exist[ini_plane_pnf][ini_plank]=1;
        VetoGeomPlank_strips[ini_plane_pnf][ini_plank]=altlist.GetSize();
            
        if(VetoGeomAlreadyFilled[ini_plane_pnf][ini_plank]!=1){
          PlexPlaneId plnid2(Detector::kFar,ini_plane,false);
          PlexStripEndId *pseid2 = new PlexStripEndId(plnid2,ini_plank,StripEnd::kUnknown);
          UgliStripHandle ugs = ugh.GetStripHandle(*pseid2);
          delete pseid2;
          stripPos=ugs.GlobalPos(0);
          VetoGeomPlank_x_s0[ini_plane_pnf][ini_plank]=stripPos[0];
          VetoGeomPlank_y_s0[ini_plane_pnf][ini_plank]=stripPos[1];
          VetoGeomPlank_z_s0[ini_plane_pnf][ini_plank]=stripPos[2];
        }

        altlist.SetFirst();
        Int_t contlist=0;
        while (altlist.IsValid()) {
          PlexStripEndId sebest = altlist.GetCurrentSEId();
          ListStripsInPlank[ini_plane_pnf][ini_plank][contlist][0] = sebest.GetPlane();
          ListStripsInPlank[ini_plane_pnf][ini_plank][contlist][1] = sebest.GetStrip(); 
          AssociatedPlank[planeNumberFinder(sebest.GetPlane())][sebest.GetStrip()][0]=ini_plane;
          AssociatedPlank[planeNumberFinder(sebest.GetPlane())][sebest.GetStrip()][1]=ini_plank;
          
          altlist.Next();
          contlist=contlist+1;
        }  
        VetoGeomAlreadyFilled[ini_plane_pnf][ini_plank]=1;
      }//end of strip loop
      
    }//plane validity check
    
  }//end of planes loop  
  
  //Other stuff
  AlreadyDidChipNumbers=false;

  //Planks that cease to exist and are replaced by others
  for(int sect=1;sect<5;sect++){
    VetoGeomPlank_x[8+42*(sect-1)][12]+=-0.492;
    VetoGeomPlank_x[8+42*(sect-1)][4]+=0.164;
    VetoGeomPlank_x[9+42*(sect-1)][0]+=0.492;
    VetoGeomPlank_x[9+42*(sect-1)][8]+=-0.164;  
  }
}//end of SetupShieldGeom method

//------------------------------------------------------------------------
//method that assigns a number between 0 and 167 for each veto plane. 

Int_t ShieldGeom::planeNumberFinder(Int_t pln)
{
  Int_t planeNum=-1;
  
  for(int ii=0;ii<168;ii++){
    if(PlaneArray[ii]==pln){
      planeNum = ii; 
      continue;
    }    
  }
  return planeNum;
  
}

// -----------------------------------------------------------------------
// 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 ShieldGeom::specialPlank(Int_t pl,Int_t pk){
  
  Bool_t verdict;
  
  static Int_t specialList[8] = {
    565, 574,  /*Section 1*/
    629, 638,  /*Section 2*/
    693, 702,  /*Section 3*/
    757, 766}; /*Section 4*/

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

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

//--------------------------------------------------------
Bool_t ShieldGeom::Reinitialize(const VldContext& vldc){

  if(fughVldRange.IsCompatible(vldc) && fphVldRange.IsCompatible(vldc)){
    return false;
  }
  else{
    //Resetting the existence of planks
    for(int pl=0;pl<=167;pl++){
      for(int st=0;st<20;st++){
        VetoGeomPlank_exist[pl][st]=0;
        VetoGeomAlreadyFilled[pl][st]=0;
      }
    }
    SetupShieldGeom(vldc);
    return true;
  }

}

//--------------------------------------------------------
Double_t ShieldGeom::GetPlank_X(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomPlank_x[planeNumberFinder(pl)][pk];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlank_X:Plank " << pl << "," << pk << " does not exist!" << endl; 
      return -100;
    }
  } else {
    MSG("CandShield",Msg::kWarning) << "GetPlank_X:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlank_Y(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
   if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
     return VetoGeomPlank_y[planeNumberFinder(pl)][pk];
   } else{
     MSG("CandShield",Msg::kWarning) << "GetPlank_Y:Plank " << pl << "," << pk << " does not exist!" << endl;
     return -100;
   } 
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlank_Y:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlank_Z(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomPlank_z[planeNumberFinder(pl)][pk];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlank_Z:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -100;
    }
  } else {
    MSG("CandShield",Msg::kWarning) << "GetPlank_Z:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100;
  }
  
}
// -------------------------------------------------------
Bool_t ShieldGeom::PlankExists(Int_t pl, Int_t pk) {
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return true;
    }
    else {return false;
    }
  }else{    
    return false;
  }

}
 
//--------------------------------------------------------
Double_t ShieldGeom::GetPlankStrip0_X(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomPlank_x_s0[planeNumberFinder(pl)][pk];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_X:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -100;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_X:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlankStrip0_Y(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
   if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
     return VetoGeomPlank_y_s0[planeNumberFinder(pl)][pk];
   } else{
     MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_Y:Plank " << pl << "," << pk << " does not exist!" << endl;
     return -100;
   }   
  }else{
    MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_Y:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlankStrip0_Z(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomPlank_z_s0[planeNumberFinder(pl)][pk];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_Z:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -100;
    }  
  } else{
    MSG("CandShield",Msg::kWarning) << "GetPlankStrip0_Z:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -100; 
  }
}

// -------------------------------------------------------
Int_t ShieldGeom::GetStripsInPlank(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomPlank_strips[planeNumberFinder(pl)][pk];
    }
    else{
      MSG("CandShield",Msg::kWarning) << "GetStripsInPlank:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -1;
    }
  }else{
    MSG("CandShield",Msg::kWarning) << "GetStripsInPlank:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -1;
  }
}

// ------------------------------------------------------
Int_t ShieldGeom::GetListStripsInPlank(Int_t pl, Int_t pk, Int_t entry, Int_t plorst){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && plorst<2 && plorst>-1 && entry<VetoGeomPlank_strips[planeNumberFinder(pl)][pk] && PlaneValidity[planeNumberFinder(pl)]==true){        
      return ListStripsInPlank[planeNumberFinder(pl)][pk][entry][plorst];
    }
    else {
      MSG("CandShield",Msg::kWarning) << "GetListStripsInPlank:Either supplied plank does not exist, or third and/or fourth fields are out of range, or supplied plane is not valid"<< endl;
      return -1;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetListStripsInPlank:Plane " << pl << " does not exist!" << endl;
    return -1;
  }

}

// -----------------------------------------------------
Int_t ShieldGeom::GetAssociatedPlank(Int_t pl, Int_t st, Int_t plorst){
  if(planeNumberFinder(pl)!=-1){
    if(plorst<2 && plorst>-1 && PlaneValidity[planeNumberFinder(pl)]==true && st<20 && st>-1){
      return AssociatedPlank[planeNumberFinder(pl)][st][plorst];
    }else {
      MSG("CandShield",Msg::kWarning) << "GetAssociatedPlank:Either second and/or third fields out of range, or supplied plane is not valid." << endl;
      return -1;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetAssociatedPlank:Plane " << pl << " does not exist in veto!" << endl;
    return -1;
  }

}

// ------------------------------------------------------
Int_t ShieldGeom::GetChipIndex(Int_t pl, Int_t pk, Int_t noorso){
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoChipIndex[planeNumberFinder(pl)][pk][noorso];
    }
    else {
      MSG("CandShield",Msg::kWarning) << "GetChipIndex:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -1;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetChipIndex:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -1;
  }
  
}

// ------------------------------------------------------
Int_t ShieldGeom::GetChipNumber(Int_t pl, Int_t pk, Int_t noorso){
   
  if(AlreadyDidChipNumbers==false){    
    
    Int_t AlreadyChip[100]={0};
    Int_t found_ll;
    Int_t main_cont=-1;
    
    for(int pln=0;pln<168;pln++){   
      for(int st=0;st<20;st++){
        if(VetoGeomPlank_exist[pln][st]==1){
          
          found_ll=-1;
          for(int ll=0;ll<64;ll++){
            if(AlreadyChip[ll]==VetoChipIndex[pln][st][1]){
              found_ll=ll;
            }
          }
          if(found_ll==-1){
            main_cont+=1;
            AlreadyChip[main_cont]=VetoChipIndex[pln][st][1];
            VetoChipNumber[pln][st][1]=main_cont;
          }
          else {
            VetoChipNumber[pln][st][1]=found_ll;
          }
          
          found_ll=-1;
          for(int ll=0;ll<64;ll++){
            if(AlreadyChip[ll]==VetoChipIndex[pln][st][0]){
              found_ll=ll;
            }
          }
          if(found_ll==-1){
            main_cont+=1;
            AlreadyChip[main_cont]=VetoChipIndex[pln][st][0];
            VetoChipNumber[pln][st][0]=main_cont;
          }
          else VetoChipNumber[pln][st][0]=found_ll;
        }
        else{
          VetoChipNumber[pln][st][0]=-1;
          VetoChipNumber[pln][st][1]=-1;
        }
      }
    } 
    if(valid_planes==168){
      AlreadyDidChipNumbers=true;
    }
  }
  if(planeNumberFinder(pl)!=-1){
    if(VetoGeomPlank_exist[planeNumberFinder(pl)][pk]==1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoChipNumber[planeNumberFinder(pl)][pk][noorso];
    }else {
      MSG("CandShield",Msg::kWarning) << "GetChipNumber:Plank " << pl << "," << pk << " does not exist!" << endl;
      return -1; 
    }  
  }else {
    MSG("CandShield",Msg::kWarning) << "GetChipNumber:Plank " << pl << "," << pk << " does not exist!" << endl;
    return -1;  
  }
}

// ------------------------------------------------------
Bool_t ShieldGeom::IsVertical(Int_t pl){
  
  Bool_t verticality=false;

  Int_t VerticalList[10]={0};
  VerticalList[0]=558;
  VerticalList[1]=559;
  VerticalList[2]=563;
  VerticalList[3]=564;
  VerticalList[4]=565;
  VerticalList[5]=567;
  VerticalList[6]=568;
  VerticalList[7]=572;
  VerticalList[8]=573;
  VerticalList[9]=574;
  
  for(int sect=0;sect<4;sect++){
    for(int ii=0;ii<10;ii++){
      if(VerticalList[ii]+sect*64==pl){
        verticality = true;
      }
    }
  }

  return verticality;

}

// ------------------------------------------------------
Bool_t ShieldGeom::IsLowerSide(Int_t pl){

  Bool_t lsidity=false;

  Int_t LowerSideList[10]={0};
  LowerSideList[0]=558;
  LowerSideList[1]=559;
  LowerSideList[2]=567;
  LowerSideList[3]=568;
  
  for(int sect=0;sect<4;sect++){
    for(int ii=0;ii<10;ii++){
      if(LowerSideList[ii]+sect*64==pl){
        lsidity = true;
      }
    }
  }

  return lsidity;

}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlane_X(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_x[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlane_X:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlane_X:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlane_Y(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_y[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlane_Y:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlane_Y:Plane " << pl << " does not exist in the shield!" << endl;
      return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlane_Z(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_z[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlane_Z:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlane_Z:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlaneClearFiber(Int_t pl, Int_t noorso){
  if(planeNumberFinder(pl)!=-1){
    if(noorso<2 && noorso > -1 && PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoPlaneClearFiber[planeNumberFinder(pl)][noorso];
    } else {
      MSG("CandShield",Msg::kWarning) << "GetPlaneClearFiber:Plane " << pl << " is not valid and/or value in 2nd field is out of bounds" << endl;
      return -100;
    }    
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlaneClearFiber:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// ------------------------------------------------------
Bool_t ShieldGeom::PlaneExistsInVeto(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return true;
    }
    else {
      return false;
    }
  }else {
    return false;
  }
}

// -------------------------------------------------------
Int_t ShieldGeom::WhatSection(Int_t pl){
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeomSection[planeNumberFinder(pl)];
    } else{    
      MSG("CandShield",Msg::kWarning) << "WhatSection:Plane " << pl << " is not valid!" << endl;
      return -1;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "WhatSection:Plane " << pl << " does not exist in the shield!" << endl;
    return -1;
  }
}

// ------------------------------------------------------
Bool_t ShieldGeom::IsPlaneActive(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    return PlaneValidity[planeNumberFinder(pl)];
  }
  else {
    return false;
  }    
}

// ------------------------------------------------------
Int_t ShieldGeom::ValidVetoPlanes() {
  
  return valid_planes;
  
}


// -------------------------------------------------------
Double_t ShieldGeom::GetPlaneStrip19_X(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_x_s19[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_X:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  }else {
    MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_X:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlaneStrip19_Y(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_y_s19[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_Y:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  } else {
    MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_Y:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetPlaneStrip19_Z(Int_t pl) {
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true){
      return VetoGeom_z_s19[planeNumberFinder(pl)];
    } else{
      MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_Z:Plane " << pl << " is not valid!" << endl;
      return -100;
    }
  } else {
    MSG("CandShield",Msg::kWarning) << "GetPlaneStrip19_Z:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetStrip_X(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true && pk<20 && pk>=0){
      return VetoStrip_x[planeNumberFinder(pl)][pk];
    } else {
      MSG("CandShield",Msg::kWarning) << "GetStrip_X:Plane " << pl << " is not valid and/or value in 2nd field is out of bounds" << endl;
      return -100;
    }  
  } else {
    MSG("CandShield",Msg::kWarning) << "GetStrip_X:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetStrip_Y(Int_t pl, Int_t pk){  
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true && pk<20 && pk>=0){
      return VetoStrip_y[planeNumberFinder(pl)][pk];
    } else {
      MSG("CandShield",Msg::kWarning) << "GetStrip_Y:Plane " << pl << " is not valid and/or value in 2nd field is out of bounds" << endl;
      return -100;
    }    
  }else {
    MSG("CandShield",Msg::kWarning) << "GetStrip_Y:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetStrip_Z(Int_t pl, Int_t pk){
  if(planeNumberFinder(pl)!=-1){
    if(PlaneValidity[planeNumberFinder(pl)]==true && pk<20 && pk>=20){
      return VetoStrip_z[planeNumberFinder(pl)][pk];
    } else {
      MSG("CandShield",Msg::kWarning) << "GetStrip_Z:Plane " << pl << " is not valid and/or value in 2nd field is out of bounds" << endl;
      return -100;
    }    
  } else {
    MSG("CandShield",Msg::kWarning) << "GetStrip_Z:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// -------------------------------------------------------
Double_t ShieldGeom::GetStripWls(Int_t pl, Int_t pk, Int_t noorso){
  if(planeNumberFinder(pl)!=-1){
    if(noorso<2 && noorso > -1 && PlaneValidity[planeNumberFinder(pl)]==true && pk<20 && pk>=0){
      return VetoStripWls[planeNumberFinder(pl)][pk][noorso];
    } else {
      MSG("CandShield",Msg::kWarning) << "GetStripWls:Plane " << pl << " is not valid and/or value in 2nd/3rd fields is/are out of bounds" << endl;
      return -100;
    }    
  } else {
    MSG("CandShield",Msg::kWarning) << "GetStripWls:Plane " << pl << " does not exist in the shield!" << endl;
    return -100;
  }
}

// ----------------------------------------------------------
Int_t ShieldGeom::WhatSectionAbove(Double_t zpos, Int_t cont){ 
  Int_t sectAbove[2]={0};
  sectAbove[0]=-1;
  sectAbove[1]=-1;
  Int_t contsect=0;
  for(int sect=0;sect<4;sect++){
    if(fabs(zpos-VetoGeom_z[planeNumberFinder(535+sect*64)])<4.){
      sectAbove[contsect]=sect+1;
      ++contsect;
    }
  }
  if(cont==0 || cont==1){
    return sectAbove[cont];
  }else {        
    MSG("CandShield",Msg::kWarning) << "WhatSectionAbove:Value in second field must be 0 or 1; Only 2 sections can overlap." << endl;
    return -1;
  }
  
}

// ----------------------------------------------------------
Int_t ShieldGeom::ClosestTwoSections(Double_t zpos, Int_t cont){ 
  Int_t sectClosest[2]={0};
  sectClosest[0]=-1;
  sectClosest[1]=-1;
  Int_t contsect=0;
  for(int sect=0;sect<4;sect++){
    if(fabs(zpos-VetoGeom_z[planeNumberFinder(535+sect*64)])<8.&& contsect<2){
      sectClosest[contsect]=sect+1;
      ++contsect;
    }
  }
  if(cont==0 || cont==1){
    return sectClosest[cont];
  }else {        
    MSG("CandShield",Msg::kWarning) << "ClosestTwoSections:Value in second field must be 0 or 1." << endl;
    return -1;
  }
  
}

---