LILookup.cxx

Go to the documentation of this file.

// Program name: LILookup.cxx
//                                                                     
// Package: LISummary  
//                                                                    
// Coded by Jeff Hartnell Nov/2002-Jan/2004                             
//                                                                    
// Purpose: Provides LI constants and lookup funtions 
//                                                                    
// Contact: jeffrey.hartnell@physics.ox.ac.uk                         

#include "Conventions/StripEnd.h"
#include "MessageService/MsgService.h"

#include "LISummary/LILookup.h"

#include <cmath>

//make default values those of FD
Int_t LILookup::FIRSTSTRIP=0;
Int_t LILookup::LASTSTRIP=191;
Int_t LILookup::NUMSTRIPS=192;

Int_t LILookup::NUMCHADD=8000;

Int_t LILookup::FIRSTLED=1;
Int_t LILookup::LASTLED=20;
Int_t LILookup::NUMLEDS=20;

Int_t LILookup::FIRSTASHTRAY=1;
Int_t LILookup::LASTASHTRAY=20;
Int_t LILookup::NUMASHTRAYS=20;

Int_t LILookup::FIRSTPULSERBOX=0;
Int_t LILookup::LASTPULSERBOX=15;
Int_t LILookup::NUMPULSERBOXES=16;
Int_t LILookup::NUMPULSERBOXESCURRENT=14;

Int_t LILookup::NUMCHANNELS=8000;

Int_t LILookup::FIRSTCRATE=0;
Int_t LILookup::LASTCRATE=15;
Int_t LILookup::NUMCRATES=16;

Int_t LILookup::FIRSTVARC=0;
Int_t LILookup::LASTVARC=3; 
Int_t LILookup::NUMVARCS=4;

Int_t LILookup::FIRSTVMM=0;
Int_t LILookup::LASTVMM=5;
Int_t LILookup::NUMVMMS=6;

Int_t LILookup::FIRSTVFB=0;
Int_t LILookup::LASTVFB=1;
Int_t LILookup::NUMVFBS=2;

Int_t LILookup::FIRSTCHIP=0;
Int_t LILookup::LASTCHIP=2;
Int_t LILookup::NUMCHIPS=3;

Int_t LILookup::FIRSTPMT=0;
Int_t LILookup::LASTPMT=2;
Int_t LILookup::NUMPMTS=3;

Int_t LILookup::FIRSTPIXEL=0;
Int_t LILookup::LASTPIXEL=15;
Int_t LILookup::NUMPIXELS=16;

Int_t LILookup::FIRSTPIXELSPOT=0;
Int_t LILookup::LASTPIXELSPOT=7;
Int_t LILookup::NUMPIXELSPOTS=8;

Int_t LILookup::FIRSTVACHANNEL=0;
Int_t LILookup::LASTVACHANNEL=21;
Int_t LILookup::NUMVACHANNELS=22;

Int_t LILookup::NUMSIDES=2;
Int_t LILookup::FIRSTSIDE=1;
Int_t LILookup::LASTSIDE=2;

Int_t LILookup::FIRSTEND=1;
Int_t LILookup::LASTEND=2;
Int_t LILookup::SECONDEND=2;
Int_t LILookup::NUMENDS=2;

Int_t LILookup::NUMRACKLEVELS=2;
Int_t LILookup::NUMLEVELS=3;
    
Int_t LILookup::FIRSTRACK=1;
Int_t LILookup::LASTRACK=16;
Int_t LILookup::NUMRACKS=16;

Int_t LILookup::FIRSTMUX=0;
Int_t LILookup::LASTMUX=7;
Int_t LILookup::NUMMUX=8;

Int_t LILookup::NUMPINGAINS=2;

Int_t LILookup::PB0STARTPLANE=0;   //  0- 64 inclusive
Int_t LILookup::PB2STARTPLANE=65;  // 65-128
Int_t LILookup::PB4STARTPLANE=129; //129-192
Int_t LILookup::PB6STARTPLANE=193; //193-248
Int_t LILookup::PB8STARTPLANE=249; //249-313
Int_t LILookup::PB10STARTPLANE=314;//314-377
Int_t LILookup::PB12STARTPLANE=378;//378-441
Int_t LILookup::PB14STARTPLANE=442;//442-485

Int_t LILookup::FIRSTPLANE=0;
Int_t LILookup::FIRSTSCINTPLANE=1;
Int_t LILookup::LASTSM1SCINTPLANE=248;

Int_t LILookup::FIRSTSM2PLANE=249;
Int_t LILookup::FIRSTSM2SCINTPLANE=250;
Int_t LILookup::LASTSCINTPLANE=485;
Int_t LILookup::LASTPLANE=485;
Int_t LILookup::NUMPLANES=486;

Int_t LILookup::NUMBOOKENDS=2;
Int_t LILookup::SM1BOOKEND=0;//steel only plane
Int_t LILookup::SM2BOOKEND=249;//steel only plane

Int_t LILookup::FIRSTSPECTROMETERPLANE=10000;//nonsense for FD

CVSID("$Id: LILookup.cxx,v 1.39 2007/11/11 08:00:53 rhatcher Exp $");

ClassImp(LILookup)

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

LILookup::LILookup()
{
  MSG("LILookup", Msg::kDebug) 
    <<"Running LILookup constructor..."<<endl;

  MSG("LILookup", Msg::kDebug) 
    <<"Finished LILookup constructor"<<endl;
}

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

LILookup::~LILookup()
{
  MSG("LILookup", Msg::kDebug) 
    <<"Running LILookup destructor..."<<endl;


  MSG("LILookup", Msg::kDebug) 
    <<"Finished LILookup destructor"<<endl;
}

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

void LILookup::SetDetector(Int_t det)
{

  MSG("LILookup", Msg::kInfo)
    <<"Setting Detector specific variables using detector type: "
    <<Detector::AsString(static_cast<Detector::
                             Detector_t>(det))<<endl; 

  if (det==Detector::kCalDet){
    FIRSTSTRIP=0;
    LASTSTRIP=23;
    NUMSTRIPS=24;
    
    FIRSTLED=1;
    LASTLED=6;
    NUMLEDS=6;

    FIRSTASHTRAY=1;
    LASTASHTRAY=3;
    NUMASHTRAYS=3;

    FIRSTPULSERBOX=0;
    LASTPULSERBOX=0;
    NUMPULSERBOXES=1;
    NUMPULSERBOXESCURRENT=1;

    FIRSTPMT=0;
    LASTPMT=2;
    NUMPMTS=3;

    FIRSTPIXEL=0;
    LASTPIXEL=15;
    NUMPIXELS=16;

    FIRSTPIXELSPOT=0;
    LASTPIXELSPOT=7;
    NUMPIXELSPOTS=8;

    NUMCHADD=8000;
    NUMCHANNELS=8000;

    FIRSTCRATE=0;
    LASTCRATE=2;
    NUMCRATES=3;

    FIRSTVARC=0;
    LASTVARC=3; 
    NUMVARCS=4;

    FIRSTVMM=0;
    LASTVMM=5;
    NUMVMMS=6;

    FIRSTVFB=0;
    LASTVFB=1;
    NUMVFBS=2;

    FIRSTCHIP=0;
    LASTCHIP=2;
    NUMCHIPS=3;

    FIRSTVACHANNEL=0;
    LASTVACHANNEL=21;
    NUMVACHANNELS=22;

    FIRSTSIDE=1;
    LASTSIDE=2;
    NUMSIDES=2;

    FIRSTEND=1;
    LASTEND=2;
    SECONDEND=2;
    NUMENDS=2;

    NUMRACKLEVELS=2;
    NUMLEVELS=3;

    FIRSTRACK=1;
    LASTRACK=16;
    NUMRACKS=16;

    FIRSTMUX=0;
    LASTMUX=7;
    NUMMUX=8;

    NUMPINGAINS=2;

    PB0STARTPLANE=0;  //  0- 59 inclusive

    //<Rubbish for CalDet but keep>
    PB2STARTPLANE=0; 
    PB4STARTPLANE=0; 
    PB6STARTPLANE=0; 
    PB8STARTPLANE=0; 
    PB10STARTPLANE=0;
    PB12STARTPLANE=0;
    PB14STARTPLANE=0;
    //</Rubbish for CalDet but keep>

    FIRSTPLANE=0;
    FIRSTSCINTPLANE=0;
    LASTSM1SCINTPLANE=59;

    FIRSTSM2PLANE=0;

    //<Rubbish for CalDet but keep>
    FIRSTSM2SCINTPLANE=0;
    //</Rubbish for CalDet but keep>

    LASTSCINTPLANE=59;
    LASTPLANE=59;
    NUMPLANES=60;
    //the total number of instrumented planes will be 60 since
    //there are no bookends at CalDet

    NUMBOOKENDS=0;
    SM1BOOKEND=-1;//steel only plane
    SM2BOOKEND=-1;//steel only plane

    FIRSTSPECTROMETERPLANE=10000;//nonsense for FD and CD
  }
  else if (det==Detector::kFar){
    FIRSTSTRIP=0;
    LASTSTRIP=191;
    NUMSTRIPS=192;

    FIRSTLED=1;
    LASTLED=20;
    NUMLEDS=20;

    FIRSTASHTRAY=1;
    LASTASHTRAY=20;
    NUMASHTRAYS=20;

    FIRSTPULSERBOX=0;
    LASTPULSERBOX=15;
    NUMPULSERBOXES=16;
    NUMPULSERBOXESCURRENT=14;

    FIRSTPMT=0;
    LASTPMT=2;
    NUMPMTS=3;

    FIRSTPIXEL=0;
    LASTPIXEL=15;
    NUMPIXELS=16;

    FIRSTPIXELSPOT=0;
    LASTPIXELSPOT=7;
    NUMPIXELSPOTS=8;

    NUMCHADD=8000;
    NUMCHANNELS=8000;

    FIRSTCRATE=0;
    LASTCRATE=15;
    NUMCRATES=16;

    FIRSTVARC=0;
    LASTVARC=3; 
    NUMVARCS=4;

    FIRSTVMM=0;
    LASTVMM=5;
    NUMVMMS=6;

    FIRSTVFB=0;
    LASTVFB=1;
    NUMVFBS=2;

    FIRSTCHIP=0;
    LASTCHIP=2;
    NUMCHIPS=3;

    FIRSTVACHANNEL=0;
    LASTVACHANNEL=21;
    NUMVACHANNELS=22;

    NUMSIDES=2;
    FIRSTSIDE=1;
    LASTSIDE=2;

    FIRSTEND=1;
    LASTEND=2;
    SECONDEND=2;
    NUMENDS=2;

    NUMRACKLEVELS=2;
    NUMLEVELS=3;
    
    FIRSTRACK=1;
    LASTRACK=16;
    NUMRACKS=16;

    FIRSTMUX=0;
    LASTMUX=7;
    NUMMUX=8;

    NUMPINGAINS=2;

    PB0STARTPLANE=0;  //  0- 64 inclusive
    PB2STARTPLANE=65;  // 65-128
    PB4STARTPLANE=129; //129-192
    PB6STARTPLANE=193; //193-248
    PB8STARTPLANE=249; //249-313
    PB10STARTPLANE=314;//314-377
    PB12STARTPLANE=378;//378-441
    PB14STARTPLANE=442;//442-485

    FIRSTPLANE=0;
    FIRSTSCINTPLANE=1;
    LASTSM1SCINTPLANE=248;

    FIRSTSM2PLANE=249;
    FIRSTSM2SCINTPLANE=250;
    LASTSCINTPLANE=485;
    LASTPLANE=485;
    NUMPLANES=486;

    NUMBOOKENDS=2;
    SM1BOOKEND=0;//steel only plane
    SM2BOOKEND=249;//steel only plane

    FIRSTSPECTROMETERPLANE=10000;//nonsense for FD and CD

    //the total number of instrumented planes will be 484 since
    //0 and 249 are bookends
  }
  else if (det==Detector::kNear){
    FIRSTSTRIP=0;
    LASTSTRIP=95;
    NUMSTRIPS=96;

    FIRSTLED=1;
    LASTLED=40;
    NUMLEDS=40;

    FIRSTASHTRAY=1;//?
    LASTASHTRAY=20;
    NUMASHTRAYS=20;

    FIRSTPULSERBOX=0;
    LASTPULSERBOX=2;
    NUMPULSERBOXES=3;
    NUMPULSERBOXESCURRENT=3;

    FIRSTPMT=0;//?
    LASTPMT=0;
    NUMPMTS=0;

    FIRSTPIXEL=0;
    LASTPIXEL=63;
    NUMPIXELS=64;

    FIRSTPIXELSPOT=0;
    LASTPIXELSPOT=0;
    NUMPIXELSPOTS=1;

    NUMCHADD=50000;//?
    NUMCHANNELS=50000;

    FIRSTCRATE=0;//?
    LASTCRATE=7;
    NUMCRATES=8;

    //<Rubbish for NearDet but keep>
    FIRSTVARC=0;
    LASTVARC=0; 
    NUMVARCS=0;

    FIRSTVMM=0;
    LASTVMM=0;
    NUMVMMS=0;

    FIRSTVFB=0;
    LASTVFB=0;
    NUMVFBS=0;

    FIRSTCHIP=0;
    LASTCHIP=0;
    NUMCHIPS=0;

    FIRSTVACHANNEL=0;
    LASTVACHANNEL=0;
    NUMVACHANNELS=0;
    //</Rubbish for NearDet but keep>

    NUMSIDES=1;
    FIRSTSIDE=1;//?
    LASTSIDE=1;//?

    FIRSTEND=2;//?
    LASTEND=2;
    SECONDEND=2;
    NUMENDS=1;

    NUMRACKLEVELS=2;
    NUMLEVELS=2;
    
    FIRSTRACK=1;//?
    LASTRACK=16;
    NUMRACKS=16;

    //<Rubbish for NearDet but keep>
    FIRSTMUX=0;
    LASTMUX=0;
    NUMMUX=0;
    //</Rubbish for NearDet but keep>

    NUMPINGAINS=2;

    PB0STARTPLANE=0;   //  0-120 inclusive
    PB2STARTPLANE=121; //121-281

    //<Rubbish for NearDet but keep>
    PB4STARTPLANE=0;
    PB6STARTPLANE=0;
    PB8STARTPLANE=0;
    PB10STARTPLANE=0;
    PB12STARTPLANE=0;
    PB14STARTPLANE=0;
    //<Rubbish for NearDet but keep>

    FIRSTPLANE=0;
    FIRSTSCINTPLANE=1;

    LASTSM1SCINTPLANE=120;//end of forward section not SM obviously
    FIRSTSM2PLANE=121;
    FIRSTSM2SCINTPLANE=121;
    LASTSCINTPLANE=281;
    LASTPLANE=281;
    NUMPLANES=282;

    NUMBOOKENDS=2;
    SM1BOOKEND=0;//steel only plane
    //consider SM2BE to be first steel-only plane in ND spectrometer
    SM2BOOKEND=122;//steel only plane

    //this is ND only
    FIRSTSPECTROMETERPLANE=121;

    //the total number of instrumented planes will be 153 since
    //0 is a bookend and 32*4=128 are uninstrumented in the spectrometer

    //Different regions in the ND:
    //Breakdown of number of planes:
    // Veto=21 planes numbered 0-20 (1st is steel bookend)
    // Target=40 planes numbered 21-60
    // Shower=60 planes numbered 61-120
    // Spectrometer=161 planes 121-281
    //   First and last are instrumented
    //   33 have scintillator, 128 are steel
    //   4 steel planes for each one with scintillator,
    //   Altogether: 5*32=160, 160+1 at end=161

    //Number of strips:
    //Forward section:
    //96 planes with 64 strips
    //24 planes with 96 strips
    //Spectrometer section:
    //33 planes with 96 strips
    //96+24+33=153 instrumented in total
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type="<<det<<" not supported yet"<<endl;
  }
}

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

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

  TGraph* g=0;

  if (vX.size()!=vY.size()){
    MSG("LIPlexMaps",Msg::kError)
      <<"Cannot create TGraph from the two vectors as they are"<<endl
      <<"different sizes. vX="<<vX.size()<<", vY="<<vY.size()<<endl; 
    return g;
  }

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

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

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

TGraphAsymmErrors* LILookup::
TGraphAsymmErrorsVectEY(vector<Double_t>& vX,vector<Double_t>& vY,
                        vector<Double_t>& vEYL,vector<Double_t>& vEYH)
{
  MSG("LIPlexMaps",Msg::kDebug) 
    <<" ** Running TGraphVectAsymmErrors method... **"<<endl;

  TGraphAsymmErrors* g=0;

  //check two vectors are same size
  if (vX.size()!=vY.size()){
    MSG("LIPlexMaps",Msg::kError)
      <<"Cannot create TGraphAsymmErrors from the two vectors"
      <<" of points as they are"<<endl
      <<"different sizes. vX="<<vX.size()<<", vY="<<vY.size()<<endl; 
    return g;
  }
  //check two error vectors are same size
  if (vEYL.size()!=vEYH.size()){
    MSG("LIPlexMaps",Msg::kError)
      <<"Cannot create TGraphAsymmErrors from the two vectors"
      <<" of errors as they are"<<endl
      <<"different sizes. vEX="<<vEYL.size()
      <<", vEY="<<vEYH.size()<<endl; 
    return g;
  }
  //check error vectors are same size as the point vectors
  //if you get here then two errors are the same size and
  //the two points are the same size
  //so, if either of each are different, it is enough to check just that
  if (vEYL.size()!=vY.size()){
    MSG("LIPlexMaps",Msg::kError)
      <<"Cannot create TGraphAsymmErrors from the two vectors"
      <<" of errors as they are"<<endl
      <<"different sizes. vEY="<<vEYL.size()<<", vY="<<vY.size()<<endl; 
    return g;
  }

  g=new TGraphAsymmErrors(vX.size());

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

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

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

void LILookup::SetNewPoint(vector<Double_t>& v,Double_t value,UInt_t i)
{
  MSG("LILookup",Msg::kVerbose) 
    <<"Running SetNewPoint method..."<<endl;
  
  if (i<=v.size()){
    vector<Double_t>::iterator point;
    point=v.begin();
    point+=i;
    
    if (i==v.size()) MSG("LILookup",Msg::kVerbose)
      <<"Inserting at end v.size()="<<v.size()<<endl;
    
    //inserts value at the point immediately before the original ith
    //element so, if i=3 then 0=0, 1=1, 2=2, 3=new, 4=old3
    v.insert(point,value);

    if (i+1==v.size()) MSG("LILookup",Msg::kVerbose)
      <<"Inserted at end, now v.size()="<<v.size()<<endl;
  }
  else {
    MSG("LILookup",Msg::kWarning) 
      <<"Only "<<v.size()<<" elements available in vector"
      <<", cannot insert value at point "<<i<<endl;
  }

  MSG("LILookup",Msg::kVerbose) 
    <<"SetNewPoint method finished"<<endl;
}

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

Double_t LILookup::GetVectorPoint(const std::vector<Double_t>& v,
                                  UInt_t point)
{
  MSG("LILookup",Msg::kVerbose) 
    <<"Running GetVectorPoint method..."<<endl;
  
  if (point<v.size()) return v[point];
  else {
    MSG("LILookup",Msg::kWarning) 
      <<"Only "<<v.size()<<" elements available, returning -1"<<endl;
    return -1;
  }

  MSG("LILookup",Msg::kVerbose) 
    <<"GetVectorPoint method finished"<<endl;
}

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

UInt_t LILookup::FindInsertPoint(const std::vector<Double_t>& v,
                                 Double_t valueToInsert)
{
  MSG("LILookup",Msg::kVerbose) 
    <<"Running FindInsertPoint method..."<<endl;
  
  //insert point - the ith element of the vector
  UInt_t i=0;
  
  if (v.size()>=1){
    //get iterator
    vector<Double_t>::const_iterator vectValue;
    //set iterator to the begining
    vectValue=v.begin();
    //loop over the vector
    while (vectValue!=v.end()){
      //if the vector element is greater than the value to insert
      //then stop looping
      //else increment the vector element
      //the min value of i is 0, 
      //the max is v.size(), i.e. one past the end 

      MSG("LILookup",Msg::kDebug)
        <<"i="<<i<<", ith value="<<*vectValue
        <<", valueToInsert="<<valueToInsert<<endl;

      if (*vectValue>valueToInsert) break;
      i++;
      vectValue++;
    }
  }

  //check if first point
  if (v.size()==0){
    MSG("LILookup",Msg::kDebug)
      <<endl<<"First point to be inserted: i="<<i
      <<", vSize="<<v.size()
      <<", valueToInsert="<<valueToInsert<<endl;
  }
  //insert at beginning (of finite vector)
  else if (i==0){
    MSG("LILookup",Msg::kDebug)
      <<endl<<"Insert at beginning of vector: i="<<i
      <<", first current value="<<v[i]
      <<", vSize="<<v.size()
      <<", valueToInsert="<<valueToInsert<<endl;
  }
  //insert at end
  else if (i==v.size()){
    MSG("LILookup",Msg::kDebug)
      <<endl<<"Insert at end of vector: i="<<i
      <<", last current value="<<v[i-1]
      <<", vSize="<<v.size()
      <<", valueToInsert="<<valueToInsert<<endl;
  }
  //insert somewhere in the middle
  else{
    MSG("LILookup",Msg::kDebug)
      <<endl<<"Insert at point i="<<i
      <<", v[i-1]="<<v[i-1]
      <<", v[i]="<<v[i]
      <<", vSize="<<v.size()
      <<", valueToInsert="<<valueToInsert<<endl;
  }
  
  MSG("LILookup",Msg::kVerbose) 
    <<"FindInsertPoint method finished"<<endl;
  return i;
}

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

string LILookup::GetVectorAsString(std::vector<Double_t>& v,
                                   const std::string& prefix) const 
{
  MSG("LILookup",Msg::kVerbose) 
    <<"Running GetVectorAsString method..."<<endl;

  string sV="";

  MSG("LILookup",Msg::kVerbose)
    <<endl<<"Vector size = "<<v.size()<<", prefix="<<prefix<<endl;

  //loop over the vector
  for (UInt_t i=0;i<v.size();i++){
    if (i==0) sV+=prefix;
    sV+=Form("%d",static_cast<Int_t>(v[i]));
    MSG("LILookup",Msg::kVerbose)
      <<Form("%d",static_cast<Int_t>(v[i]))<<endl;
    if (i==v.size()-1) sV+="\n";
    else sV+=",";
  }

  MSG("LILookup",Msg::kDebug)<<"Returning string:"<<sV<<endl;

  MSG("LILookup",Msg::kVerbose) 
    <<"GetVectorAsString method finished"<<endl;
  return sV;
}

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

string LILookup::GetVectorAsString(std::vector<Int_t>& v,
                                   const std::string& prefix) const 
{
  MSG("LILookup",Msg::kVerbose) 
    <<"Running GetVectorAsString method..."<<endl;

  string sV="";

  MSG("LILookup",Msg::kVerbose)
    <<endl<<"Vector size = "<<v.size()<<", prefix="<<prefix<<endl;

  //loop over the vector
  for (UInt_t i=0;i<v.size();i++){
    if (i==0) sV+=prefix;
    sV+=Form("%d",static_cast<Int_t>(v[i]));
    MSG("LILookup",Msg::kVerbose)
      <<Form("%d",static_cast<Int_t>(v[i]))<<endl;
    if (i==v.size()-1) sV+="\n";
    else sV+=",";
  }

  MSG("LILookup",Msg::kDebug)<<"Returning string:"<<sV<<endl;

  MSG("LILookup",Msg::kVerbose) 
    <<"GetVectorAsString method finished"<<endl;
  return sV;
}

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

Double_t LILookup::CalcGain(Double_t mean,Double_t rms, Double_t QE)
{
  //gain=rms**2/mean * 1/(1-p)
  Double_t gain=-1;

  //protect against fpe
  if (mean!=0 && 1-QE!=0) gain=(rms*rms/mean)*(1/(1-QE));
  
  return gain;
}

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

Double_t LILookup::CalcNpe(Double_t mean,Double_t rms,Double_t QE)
{
  //npe=(mean/rms)**2 * (1-p)
  Double_t npe=-1;

  //protect against fpe
  if (rms!=0) npe=pow(mean/rms,2)*(1-QE);
  
  return npe;
}

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

Double_t LILookup::CalcRms(Double_t mean,Double_t gain,Double_t QE)
{
  //rms=sqrt(gain*mean*(1-p))
  Double_t rms=-1;

  //protect against fpe
  Double_t rms2=gain*mean*(1-QE);
  if (rms2>=0) rms=sqrt(rms2);
  
  return rms;
}

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

Double_t LILookup::CalcMean(Double_t gain,Double_t rms,Double_t QE)
{
  //mean=rms**2/gain * 1/(1-p)
  Double_t mean=-1;

  //protect against fpe
  if (gain!=0 && 1-QE!=0) mean=(rms*rms/gain)*(1/(1-QE));
  
  return mean;
}

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

Double_t LILookup::CalcMeanFromNpe(Double_t npe,Double_t rms,
                                   Double_t QE)
{
  //mean=sqrt(npe/(1-p)) * rms
  Double_t mean=-1;

  //protect against fpe
  Double_t x=0;
  if (1-QE!=0) x=npe/(1-QE);
  if (x>=0) mean=sqrt(x)*rms;
  
  return mean;
}

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

Int_t LILookup::ConvertEastWest(string sEastWest)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the ConvertEastWest method... ** "<<endl;

  Int_t eastWest=-1;
  
  //translate east west to an integer
  if (sEastWest=="E") eastWest=StripEnd::kEast;//kEast=1=kNeg
  else if (sEastWest=="W") eastWest=StripEnd::kWest;//kWest=2=kPos
  //else stays as -1

  if (StripEnd::kEast!=1) MSG("LILookup",Msg::kInfo)
    <<"Convention error!"<<endl; 

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the ConvertEastWest method **"<<endl;
  return eastWest;
}

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

Int_t LILookup::ConvertRackLevel(string sRackLevel)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the ConvertRackLevel method... ** "<<endl;

  Int_t rackLevel=-1;
  
  //translate east west to an integer
  if (sRackLevel=="L") rackLevel=0;
  else if (sRackLevel=="U") rackLevel=1;
  else if (sRackLevel=="?") rackLevel=-2;//this appears too often
  //else stays as -1

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the ConvertRackLevel method **"<<endl;
  return rackLevel;
}

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

Int_t LILookup::GetOppPb(Int_t pulserBox,Int_t detectorType)
{ 
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the GetOppPb method... ** "<<endl;

  Int_t oppPulserBox=-1;
  
  if (detectorType==Detector::kFar){
    if (pulserBox>=FIRSTPULSERBOX && pulserBox<=LASTPULSERBOX){ 
      if (pulserBox%2==0){//east
        oppPulserBox=pulserBox+1;
      }
      else if (pulserBox%2==1){//west
        oppPulserBox=pulserBox-1;
      }
    }    
  }
  else if(detectorType==Detector::kCalDet){
    //only 1 pulser box at CalDet!
    oppPulserBox=pulserBox;
  }
  else if(detectorType==Detector::kNear){
    //pulser boxes are only on one side so this is meaningless
    //but return it anyway
    oppPulserBox=pulserBox;
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the GetOppPb method **"<<endl;
  return oppPulserBox;
}

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

Int_t LILookup::GetOppCrate(Int_t crate,Int_t detectorType)
{ 
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the GetOppCrate method... ** "<<endl;

  Int_t oppCrate=-1;

  if (detectorType==Detector::kFar){
    if (crate>=FIRSTCRATE && crate<=LASTCRATE){ 
      if (crate%2==0){//east
        oppCrate=crate+1;
      }
      else if (crate%2==1){//west
        oppCrate=crate-1;
      }
    }
  }
  else if(detectorType==Detector::kCalDet){
    if (crate>=0 && crate<=1){ 
      if (crate==0){
        oppCrate=crate+1;
      }
      else if (crate==1){
        oppCrate=crate-1;
      }
    }
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the GetOppCrate method **"<<endl;
  return oppCrate;
}

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

Int_t LILookup::Pb2TrigPmtChannel(Int_t pulserBox,Int_t detectorType)
{ 
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Pb2TrigPmtChannel method... ** "<<endl;

  Int_t channel=-1;

  if (detectorType==Detector::kFar){
    //This list was made empirically by looking at the channels which had
    //saturated adc values
    Int_t pB2TrigPmtChannel[]=
      {14,  3, 12,  9,  6,
       11, 15,  4,  5, 16,
       7,  10, 13,  8,  2,
       17};

    if (pulserBox>=FIRSTPULSERBOX && pulserBox<=LASTPULSERBOX){ 
      channel=pB2TrigPmtChannel[pulserBox];
    }    
  }
  else if(detectorType==Detector::kCalDet){
    //varc 2 vmm 5 vfb 0 chip 1
    Int_t pB2TrigPmtChannel[]={4};
    
    if (pulserBox>=0){ 
      channel=pB2TrigPmtChannel[pulserBox];
    }    
  }
  else if(detectorType==Detector::kNear){
    //need to work out the tpmt channels for pb 1 and 2
    //QIE(0,16,0,14)
    Int_t pB2TrigPmtChannel[]={8,  14, -1};
    if (pulserBox>=FIRSTPULSERBOX && pulserBox<=LASTPULSERBOX){ 
      channel=pB2TrigPmtChannel[pulserBox];
    } 
    else{
      MSG("LILookup",Msg::kWarning)<<"No pulser box="<<pulserBox<<endl;
    }
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Pb2TrigPmtChannel method **"<<endl;
  return channel;
}

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

void LILookup::SetPbPlanes(Int_t *planeMin,Int_t *planeMax,
                           Int_t detectorType)
{ 
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the SetPbPlanes method... ** "<<endl;

  if (detectorType==Detector::kFar){
    for (Int_t j=0;j<2;j++){    
      planeMin[0+j]=PB0STARTPLANE;
      planeMax[0+j]=PB2STARTPLANE;
      planeMin[2+j]=PB2STARTPLANE;
      planeMax[2+j]=PB4STARTPLANE;
      planeMin[4+j]=PB4STARTPLANE;
      planeMax[4+j]=PB6STARTPLANE;
      planeMin[6+j]=PB6STARTPLANE;
      planeMax[6+j]=PB8STARTPLANE;
      planeMin[8+j]=PB8STARTPLANE;
      planeMax[8+j]=PB10STARTPLANE;
      planeMin[10+j]=PB10STARTPLANE;
      planeMax[10+j]=PB12STARTPLANE;
      planeMin[12+j]=PB12STARTPLANE;
      planeMax[12+j]=PB14STARTPLANE;
      planeMin[14+j]=PB14STARTPLANE;
      planeMax[14+j]=LASTPLANE+1;
    }
  }
  else if (detectorType==Detector::kCalDet){
    for (Int_t j=0;j<2;j++){    
      planeMin[0+j]=FIRSTPLANE;
      planeMax[0+j]=LASTPLANE+1;
      
      if (NUMCRATES==3){
        MSG("LILookup",Msg::kInfo)
          <<"Setting 3rd crate plane min and max - hack"<<endl;
        planeMin[2]=FIRSTSCINTPLANE;
        planeMax[2]=LASTPLANE+1;
      }
    }
  }

  // Near Detector:
  // pulser box 0 serves the spectrometer
  // pulser boxes 1,2 both serve the whole calorimeter
  // 1 the V planes and 2 the U planes

  //  else if (detectorType==Detector::kNear){
  //  planeMin[0] = FIRSTSPECTROMETERPLANE;
  //  planeMax[0] = LASTPLANE;
  //  for (Int_t j=1;j<NUMPULSERBOXES;j++){
  //    planeMin[j] = FIRSTSCINTPLANE;
  //    planeMax[j] = FIRSTSPECTROMETERPLANE;
  //  }
  // }
  
  // At the moment, use whole detector. All the gains will be in the
  // crate 0 plot.

  else if (detectorType==Detector::kNear){
    for (Int_t j=0;j<NUMCRATES;j++){  
      planeMin[j]=FIRSTPLANE;
      planeMax[j]=LASTPLANE+1;
    }
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }
  
  for (Int_t j=FIRSTPULSERBOX;j<NUMPULSERBOXES;j++){    
    MSG("LILookup",Msg::kInfo) 
      <<"PulserBox "<<j<<" has planes "<<planeMin[j]<<" -> " 
      <<planeMax[j]-1<<" inclusive"<<endl;
  }
  
  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the SetPbPlanes method **"<<endl;
}

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

Int_t LILookup::Chip2Pmt(Int_t chip,Int_t detectorType)
{ 
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Chip2Pmt method... ** "<<endl;

  Int_t pmt=-1;

  if (detectorType==Detector::kFar){
    if (chip==0) pmt=0;
    if (chip==1) pmt=2;
    if (chip==2) pmt=1;
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Chip2Pmt method **"<<endl;
  return pmt;
}

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

Int_t LILookup::Led2Ashtray(Int_t led,Int_t plane,Int_t detectorType)
{  //this should go in the plex!!

  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Led2Ashtray method... ** "<<endl;

  Int_t ashtray=-1;

  if (detectorType==Detector::kFar){
    Int_t led2Ashtray[20]={20,19,18,17,16,
                                15,14,13,12,11,
                                10, 9, 8, 7, 6,
                                5, 4, 3, 2, 1};
    
    if (led>=FIRSTLED && led<=NUMLEDS){
      ashtray=led2Ashtray[led-1];
      //SM1
      if (plane>=FIRSTSCINTPLANE && plane<=LASTSM1SCINTPLANE){
        if((plane-1)%4>1){
          ashtray=ashtray-1;
          if(ashtray<1) ashtray=20;
        }
      }
      //SM2
      else{
        if ((plane%4)<2) {
          ashtray=ashtray-1;
          if(ashtray<1) ashtray=20;
        }
      }
    }
    MSG("LILookup_Led2Ashtray", Msg::kDebug) 
    <<"  ashtray="<<ashtray
    <<", led="<<led
    <<endl;
  }
  else if (detectorType==Detector::kCalDet){
    //you need to know the side as well to do this
    //see ryans webpage for details
    ashtray=-1;
  }
  else if (detectorType==Detector::kNear){
    //not implemented yet
    ashtray=-1;
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Led2Ashtray method **"<<endl;
  return ashtray;
}

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

Int_t LILookup::Strip2Ashtray(Int_t strip,Int_t detectorType)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Strip2Ashtray method... ** "<<endl;

  Int_t ashtray=-1;

  if (detectorType==Detector::kFar){
    Int_t strip2Ashtray[192]={ 1,1,1,1,1,1,1,1,
                                     2,2,2,2,2,2,2,2,2,2,
                                     3,3,3,3,3,3,3,3,3,3,
                                     4,4,4,4,4,4,4,4,
                                     5,5,5,5,5,5,5,5,5,5,
                                     6,6,6,6,6,6,6,6,6,6,
                                     7,7,7,7,7,7,7,7,7,7,
                                     8,8,8,8,8,8,8,8,8,8,
                                     9,9,9,9,9,9,9,9,9,9,
                                     10,10,10,10,10,10,10,10,10,10,
                                     11,11,11,11,11,11,11,11,11,11,
                                     12,12,12,12,12,12,12,12,12,12,
                                     13,13,13,13,13,13,13,13,13,13,
                                     14,14,14,14,14,14,14,14,14,14,
                                     15,15,15,15,15,15,15,15,15,15,
                                     16,16,16,16,16,16,16,16,16,16,
                                     17,17,17,17,17,17,17,17,
                                     18,18,18,18,18,18,18,18,18,18,
                                     19,19,19,19,19,19,19,19,19,19,
                                     20,20,20,20,20,20,20,20};
    if (strip>=0 && strip<NUMSTRIPS){
      ashtray=strip2Ashtray[strip];
    }
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }
  
  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Strip2Ashtray method **"<<endl;
  return ashtray;
}

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

pair<Int_t,Int_t> LILookup::GetPinDiodePlanes(PlexPinDiodeId pinId,
                                              PlexHandle* plexHandle)
{
  //this function returns the planes associated with the pin
  //diode, i.e. readout by the same chip on the vfb

  //a pair to hold the potentially two planes associated 
  //with the pin diodes
  pair<Int_t,Int_t> planes(-1,-1);

  //get the raw channel ids of the pins
  RawChannelId rawChanId=plexHandle->GetRawChannelId(pinId);
  
  if (MsgService::Instance()->IsActive("LILookup",Msg::kDebug)){
    rawChanId.Print();
    cout<<endl;//the above doesn't leave a line annoyingly
  }
    
  MSG("LIPlexMaps",Msg::kDebug) 
    <<"Pin chip="<<rawChanId.GetVaChip()<<endl;

  //loop over all the channels on the va chip 
  //At caldet the first pin is on a non-shared pmt (chip 0),
  //the second pin is on the shared pmt and chip 1
  for (Int_t i=0;i<NUMVACHANNELS;i++){
    //change the channel, get the altlist and then the plane
    rawChanId.SetVaChannel(i);
      
    //Get strip-end alternative list
    PlexSEIdAltL altList=plexHandle->GetSEIdAltL(rawChanId);
    
    //the plane is known from the rawchannel via altlist
    Int_t currentPlane=altList.GetPlane();  
    if (currentPlane>-1 && planes.first==-1){
      planes.first=currentPlane;
    }
    else if (currentPlane>-1 && currentPlane!=planes.first){
      planes.second=currentPlane;
    }
    
    MSG("LIPlexMaps",Msg::kDebug) 
      <<"Looping over VA: channel="<<i<<", plane1="<<planes.first
      <<", plane2="<<planes.second<<endl;    

    //jump out of loop if you have both planes
    if (planes.second>-1) break;
  }

  //sort the planes so lowest is first (except if only one plane
  Int_t tempPlane=planes.first;
  if (planes.second<planes.first  && planes.second!=-1){
    planes.first=planes.second;
    planes.second=tempPlane;
  }

  return planes;  
}

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

pair<PlexPinDiodeId,PlexPinDiodeId> LILookup::
GetPinDiodeIds(PlexHandle plexHandle,Int_t led)
{
  //prior to march 2003
  //Int_t highpinchadds[6]={4146,4274,4402,4786,4914,5042};
  //Int_t lowpinchadds[6]={4114,4242,4370,4626,4882,5010};
 
  //The pin diode information in the plex is as follows
  //The electronics information is in descending hierarchial order
  //(x:y) is pulser box x and led y
  //e.g. (crate,varc,vmm,vfb,VA chip,VA channel)

  //(0:1) Planes=41&43 Pin1=VA(0,2,0,0,0,18)=4114 
  //Pin2=VA(0,2,0,0,1,18)=4146
  //(0:2) Planes=45&47 Pin1=VA(0,2,0,1,0,18)=4242 
  //Pin2=VA(0,2,0,1,1,18)=4274
  //(0:3) Planes=49&51 Pin1=VA(0,2,1,0,0,18)=4370 
  //Pin2=VA(0,2,1,0,1,18)=4402
  //(0:4) Planes=40&42 Pin1=VA(0,2,2,0,0,18)=4626 
  //Pin2=VA(0,2,2,1,1,18)=4786
  //(0:5) Planes=44&46 Pin1=VA(0,2,3,0,0,18)=4882 
  //Pin2=VA(0,2,3,0,1,18)=4914
  //(0:6) Planes=48&50 Pin1=VA(0,2,3,1,0,18)=5010 
  //Pin2=VA(0,2,3,1,1,18)=5042

  //since to march 2003
  Int_t highpinchadds[6]={4146,4274,4402,4786,4914,5042};
  Int_t lowpinchadds[6]={4114,4242,4370,4626,4882,5010};

  //get high
  PlexPinDiodeId high=plexHandle.GetPinDiodeId
    (RawChannelId(Detector::kCalDet,ElecType::kVA,
                  0,highpinchadds[led-1]));
  
  //get low
  PlexPinDiodeId low=plexHandle.GetPinDiodeId
    (RawChannelId(Detector::kCalDet,ElecType::kVA,
                  0,lowpinchadds[led-1]));
  
  //  cout<<"Therefore: "<<high.GetEncoded()<<"\t"
  //    << low.GetEncoded()<<endl;
    return make_pair(high,low);
}

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

Int_t LILookup::Strip2Led(Int_t strip,Int_t plane,Int_t detectorType,
                          Int_t crate)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Strip2Led method... ** "<<endl;

  Int_t led=-1;
  
  if (detectorType==Detector::kFar){
    Int_t strip2Led[192]={ 20,20,20,20,20,20,20,20,
                           19,19,19,19,19,19,19,19,19,19,
                           18,18,18,18,18,18,18,18,18,18,
                           17,17,17,17,17,17,17,17,
                           16,16,16,16,16,16,16,16,16,16,
                           15,15,15,15,15,15,15,15,15,15,
                           14,14,14,14,14,14,14,14,14,14,
                           13,13,13,13,13,13,13,13,13,13,
                           12,12,12,12,12,12,12,12,12,12,
                           11,11,11,11,11,11,11,11,11,11,
                           10,10,10,10,10,10,10,10,10,10,
                           9,9,9,9,9,9,9,9,9,9,
                           8,8,8,8,8,8,8,8,8,8,
                           7,7,7,7,7,7,7,7,7,7,
                           6,6,6,6,6,6,6,6,6,6,
                           5,5,5,5,5,5,5,5,5,5,
                           4,4,4,4,4,4,4,4,
                           3,3,3,3,3,3,3,3,3,3,
                           2,2,2,2,2,2,2,2,2,2,
                           1,1,1,1,1,1,1,1};
    
    if (strip>=0 && strip<NUMSTRIPS){
      led=strip2Led[strip];

      //due to the strange cyclic permutation caused by a mux box
      //numbering scheme cock up and another cock up to do with which
      //led was 1 and which was 20 you have the following complicated
      //scheme
      //SM1
      if (plane<249 && plane>0){
        if((plane-1)%4>1){
          led=led-1;
          if(led<1) led=20;
        }
      }
      //SM2
      else{
        if ((plane%4)<2) {
          led=led-1;
          if(led<1) led=20;
        }
      }
    }
  }
  else if (detectorType==Detector::kCalDet){
    //Thanks to Ryan for this piece of code

    //On the kPos=kWest=ND side the leds in plane 40 and 50 are switched
    //On the kNeg=kEast=FD side the leds in plane 56 and 58 were
    //switched but not since March 2003
    
    if(plane>59 || plane <0) {
      return -1;
    }
    
    //for crate 1 and 2
    if (crate==1 || crate ==2)
      if (strip<4) {
        if (plane==40) return 2;
        if ((plane%4)==0||(plane%4)==1) return 1;
        return 2;
      } 
      else if (strip<14) {
        if (plane==50) return 3;
        if (plane==40) return 1;
        if ((plane%4)==0||(plane%4)==1) return 2;
        return 1;
      } 
      else {
        if (plane==50) return 1;
        return 3;
      }
    //for crate 0
    else if (crate==0){
      if (strip<10) {
        //if (plane==56||plane==58||plane==12 ) return 4;
        return 6;
      } 
      else if (strip<20) {
        //if (plane==58) return 6;
        if ((plane%4)==0 || (plane%4)==1) return 5;
        return 4;
      } 
      else {
        //if(plane==56 || plane==12 ) return 6;
        if ((plane%4)==0 || (plane%4)==1) return 4;
        return 5;
      }
    }
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }
  
  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Strip2Led method **"<<endl;
  return led;
}

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

Int_t LILookup::Plane2Pb(Int_t plane,Int_t side)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2Pb method... ** "<<endl;

  Int_t pulserBox=-1;

  if (side==StripEnd::kEast){
    pulserBox=Plane2PbEast(plane);
  }
  if (side==StripEnd::kWest){
    if (side!=2) MSG("LILookup",Msg::kInfo)<<"Convention error!"<<endl; 
    pulserBox=Plane2PbWest(plane);
  }
  //else pulser box stays as -1

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2Pb method **"<<endl;
  return pulserBox;
}

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

Int_t LILookup::Plane2PbEast(Int_t plane)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2PbEast method... ** "<<endl;

  Int_t pulserBox=-1;

  if (plane>=FIRSTSCINTPLANE && plane<PB2STARTPLANE) pulserBox=0;
  else if (plane>=PB2STARTPLANE && plane<PB4STARTPLANE) pulserBox=2;
  else if (plane>=PB4STARTPLANE && plane<PB6STARTPLANE) pulserBox=4;
  else if (plane>=PB6STARTPLANE && plane<=LASTSM1SCINTPLANE) pulserBox=6;
  else if (plane>=PB8STARTPLANE && plane<PB10STARTPLANE) pulserBox=8;
  else if (plane>=PB10STARTPLANE && plane<PB12STARTPLANE) pulserBox=10;
  else if (plane>=PB12STARTPLANE && plane<PB14STARTPLANE) pulserBox=12;
  else if (plane>=PB14STARTPLANE && plane<=LASTSCINTPLANE) pulserBox=14;

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2PbEast method **"<<endl;
  return pulserBox;
}

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

Int_t LILookup::Plane2PbWest(Int_t plane)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2PbWest method... ** "<<endl;

  Int_t pulserBox=-1;
  pulserBox=Plane2PbEast(plane);
  if (pulserBox>=0 && pulserBox<NUMPULSERBOXES){
    pulserBox++;//west pulser box is always one more than east
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2PbWest method **"<<endl;
  return pulserBox;
}

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

Int_t LILookup::Plane2Crate(Int_t plane,Int_t side,Int_t detectorType)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2Crate method... **"<<endl;

  Int_t crate=-1;

  if (detectorType==Detector::kFar){
    if (side==StripEnd::kEast){
      crate=Plane2CrateEast(plane,detectorType);
    }
    else if (side==StripEnd::kWest){
      crate=Plane2CrateWest(plane,detectorType);
    }
    //else crate stays as -1
  }
  else if (detectorType==Detector::kCalDet){

    //this gets a bit messy for near only running
    if (side==StripEnd::kEast){
      crate=0;
    }
    if (side==StripEnd::kWest){
      crate=1;
    }
    //else crate stays as -1
  }
  else if (detectorType==Detector::kNear){
    MAXMSG("LILookup",Msg::kWarning,3)
      <<"Detector Type = "<<detectorType
      <<" not supported properly yet, returning crate=0"<<endl;
    crate=0;
  }
  else {
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2Crate method **"<<endl;
  return crate;
}

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

Int_t LILookup::Plane2CrateEast(Int_t plane,Int_t detectorType)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2CrateEast method... **"<<endl;


  Int_t crate=-1;

  if (detectorType==Detector::kFar){
    crate=Plane2PbEast(plane);//pb and cr have the same numbers
  }
  else if (detectorType==Detector::kCalDet){
    crate=0;//the left side
  }
  else {
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }
  
  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2CrateEast method **"<<endl;
  return crate;
}

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

Int_t LILookup::Plane2CrateWest(Int_t plane,Int_t detectorType)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the Plane2CrateWest method... ** "<<endl;

  Int_t crate=-1;

  if (detectorType==Detector::kFar){
    crate=Plane2PbWest(plane);//pb and cr have the same numbers
  }
  else if (detectorType==Detector::kCalDet){
    crate=1;//the right side
  }
  else {
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the Plane2CrateWest method **"<<endl;
  return crate;
}

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

Int_t LILookup::NearOrFar(Int_t crate,Int_t pulserBox,
                          Int_t nearPulserBox, Int_t farPulserBox,
                          Int_t led,Int_t detectorType,
                          Int_t plane,Int_t runNumber)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the NearOrFar method... ** "<<endl;


  //modified 16/08/03 to include the fact that the ND electronics
  //at caldet now has 2 crates

  Int_t nearOrFar=kUnknownSide;

  if (detectorType==Detector::kFar){ 

    if (pulserBox<FIRSTPULSERBOX || pulserBox>LASTPULSERBOX){
      MSG("LILookup",Msg::kWarning)
        <<"Near or far determination not possible, PB out of range="
        <<pulserBox<<endl;      
    }
    else if (pulserBox==nearPulserBox){
      nearOrFar=kNearSide;
    }
    else if (pulserBox==farPulserBox){
      nearOrFar=kFarSide;
    }
    else{
      nearOrFar=kUnknownSide;
    }
  }
  else if (detectorType==Detector::kCalDet){  

    if (runNumber<80000){
      if (led==1 || led==2 || led==3){
        if (crate==1 || crate==2) nearOrFar=kNearSide;
        else if (crate==0) nearOrFar=kFarSide;
      }
      else if (led==4 || led==5 || led==6){
        if (crate==0) nearOrFar=kNearSide;
        else if (crate==1 || crate==2) nearOrFar=kFarSide;
      }
      else{
        MSG("LILookup",Msg::kWarning)
          <<"Near or far determination not possible for led = "
          <<led<<endl;      }
    }
    else{//section for near only running=pain in the arse
      //even planes have leds 1-3 as near leds
      //odd planes have leds 4-6 as near leds
      if (led==1 || led==2 || led==3){
        if (plane%2==0) nearOrFar=kNearSide;
        else if (plane%2==1) nearOrFar=kFarSide;
      }
      else if (led==4 || led==5 || led==6){
        if (plane%2==1) nearOrFar=kNearSide;
        else if (plane%2==0) nearOrFar=kFarSide;
      }
      else{
        MSG("LILookup",Msg::kWarning)
          <<"Near or far determination not possible for led = "
          <<led<<endl;
      }
    }
  }
  else if (detectorType==Detector::kNear){
    //always return kNearSide, it's all it can be!
    nearOrFar=kNearSide;
  }
  else {
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the NearOrFar method **"<<endl;
  return nearOrFar;
}

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

void LILookup::UnencodePlnStripEndKey(Int_t plnStripEndKey,
                                       Detector::Detector_t det,
                                       Int_t& plane,Int_t& strip,
                                       Int_t& stripEnd)
{
  MSG("LILookup",Msg::kDebug) 
    <<" ** Running the UnencodePlnStripEndKey method... ** "<<endl;

  //this bit was stolen from the plex
  Int_t nStrips = 192;  // need some default
  switch (det) {
  case Detector::kNear:   nStrips =  96; break;
  case Detector::kFar:    nStrips = 192; break;
  case Detector::kCalDet: nStrips =  24; break;
  default:
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type is not Near/Far/CalDet"<<endl;
  }

  //the strip end is stored as the lowest bit so need to shift 
  //that bit off before dividing by nStrips
  //kEast is stored as a 0 and kWest as a 1 so need to add one
  //to get to their actual values

  //EXCEPT the ND does not have a strip end stored - no point!!!

  //00245    if (det == Detector::kNear) {
  //00246       // near detector only has west readout
  //00247      if (end != StripEnd::kWest) {
  //00248        MAXMSG("Plex",Msg::kWarning,10)
  //00249          << "PlexStripEndId " << *this << " has non-West readout" << endl;
  //00250      // but do nothing
  //00251      }
  //00252    }
  //00253    else {
  //00254       // make room for end bit
  //00255       hvalue <<= 1;
  //00256       switch (GetEnd()) {
  //00257       case StripEnd::kEast: hvalue += 0; break;
  //00258       case StripEnd::kWest: hvalue += 1; break;
  //0/0259       default:
  //00260          MAXMSG("Plex",Msg::kWarning,10)
  //00261             << "PlexStripEndId " << *this << " is not East/West" << endl;
  //00262       }
  //00263    }

  if (det==Detector::kFar || det==Detector::kCalDet){
    plane=(plnStripEndKey>>1)/nStrips;
    strip=(plnStripEndKey>>1)%nStrips;
    //look at only the lowest bit
    stripEnd=(plnStripEndKey&0x1)+1;
  }
  else if (det==Detector::kNear){
    plane=plnStripEndKey/nStrips;
    strip=plnStripEndKey%nStrips;
    stripEnd=2;//because it always is
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type is not Near/Far/CalDet"<<endl;
  }

  MSG("LILookup",Msg::kDebug) 
    <<" ** Finished the UnencodePlnStripEndKey method **"<<endl;
}

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

Int_t LILookup::GetNumericMuxBox(Int_t pmtNo,Int_t detectorType)
{
  MSG("LILookup",Msg::kDebug)
    <<" ** Running the GetNumericMuxBox method... ** "<<endl;

  Int_t MuxBox = -1;

  if (detectorType==Detector::kNear){

    Int_t numericMuxBox[194] = {4112,4113,5136,4114,5137,4115,5138,5139,4116,5140,4117,5141,4118,4119,5142,4128,
                                5143,4129,5152,5153,4130,5154,4131,5155,4132,4133,5156,4134,5157,4135,5158,5159,
                                4144,5168,4145,5169,4146,4147,5170,4148,5171,4149,5172,5173,4150,5174,4151,5175,
                                4160,4161,5184,4162,5185,4163,5186,5187,4164,5188,4165,5189,4166,4167,5190,4176,
                                5191,4177,5200,5201,4178,5202,4179,5203,4180,4181,5204,4182,5205,4183,5206,5207,
                                4192,5216,4193,5217,4194,4195,5218,4196,5219,4197,5220,5221,4198,5222,4199,5223,
                                4208,4209,5232,4210,5233,4211,5234,5235,4212,5236,4213,5237,4214,4215,5238,4224,
                                5239,4225,5248,5249,4226,5250,4227,5251,4228,4229,5252,4230,5253,4231,5254,5255,
                                4240,5264,4241,5265,4242,4243,5266,4244,5267,4245,5268,5269,4246,5270,4247,5271,
                                4257,4256,5280,5281,4258,5282,4261,4260,5284,5285,4262,5286,4273,4272,5296,5297,
                                4274,5298,4277,4276,5300,5301,4278,5302,4289,4288,5312,5313,4290,5314,4293,4292,
                                5316,5317,4294,5318,4305,4304,5328,5329,4306,5330,4309,4308,5332,5333,4310,5334,
                                4311,4307};
    MuxBox = numericMuxBox[pmtNo];
  }
  else{
    MSG("LILookup",Msg::kWarning)
      <<"Detector Type = "<<detectorType<<" not supported yet"<<endl;
  }

  MSG("LILookup",Msg::kDebug)
    <<" ** Finished the GetNumericMuxBox method **"<<endl;
  return MuxBox;
}

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

---