LIPlexMaps.cxx

Go to the documentation of this file.

// Program name: LIPlexMaps.cxx
//                                                                     
// Package: LISummary          
//                                                                    
// Coded by Jeff Hartnell 
//                                                                    
// Purpose: To interogate the plex and produce information in an
//          easy to digest way
//                                                                    
// Contact: jeffrey.hartnell@physics.ox.ac.uk                         

#include <iostream>
#include <vector>
#include <fstream>
#include <cmath>
#include <stdexcept>

#include "TCanvas.h"
#include "TDatime.h"
#include "TError.h"//needed for gErrorIgnoreLevel
#include "TF1.h"
#include "TH2.h"
#include "TObject.h"
#include "TPad.h"
#include "TPaveText.h"
#include "TProfile2D.h"
#include "TStyle.h"
#include "TText.h"
#include "TRandom.h"
#include "TStopwatch.h"
// #include "TFile.h"

#include "Calibrator/CalADCtoPE.h"
#include "Calibrator/CalADCtoPEs.h"
#include "Calibrator/CalMIPCalibration.h"
#include "Calibrator/CalStripToStrip.h"
#include "Calibrator/CalStripAtten.h"
#include "Conventions/Detector.h"
#include "Conventions/StripEnd.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiValidityRec.h"
#include "DatabaseInterface/DbiWriter.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexRawChannelToPinDiode.h"
#include "PulserCalibration/PulserRawDrift.h"
#include "PulserCalibration/PulserRawDriftF.h"
#include "PulserCalibration/PulserRefDrift.h"
#include "PulserCalibration/PulserRefDriftF.h"
#include "PulserCalibration/PulserRawDriftPin.h"
#include "PulserCalibration/PulserRefDriftPin.h"
#include "PulserCalibration/PulserRawGain.h"
#include "RawData/RawChannelId.h"
#include "Validity/VldContext.h"
#include "Validity/VldTimeStamp.h"

#include "LISummary/LIPlexMaps.h"
#include "LISummary/LIPmt.h"
#include "LISummary/LIRun.h"

CVSID("$Id: LIPlexMaps.cxx,v 1.72 2009/07/05 10:13:16 djauty Exp $");

ClassImp(LIPlexMaps)

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

class LedIdList : public std::vector<PlexLedId> 
{
  
public:
  
  LedIdList(const VldContext& context) { Reset(context);};
  LedIdList() { 
    VldTimeStamp ts;
    VldContext cx(Detector::kCalDet,SimFlag::kData,ts);
    Reset(cx);
  };

  void Reset(const VldContext& context) { 
    Int_t numRows=fResPtr.NewQuery(context,0);
    MSG("LIPlexMaps",Msg::kInfo)
      <<"New DB query produced "<<numRows<<" rows"<<endl;
    std::map<PlexLedId,int> tmpMap;

    for (UInt_t i=0;i<fResPtr.GetNumRows();i++) {
      const PlexPinDiodeToLed* datum = fResPtr.GetRow(i);
      if(datum){
        tmpMap[datum->GetPlexLedId()] += 1; // Add it to map.
      }
    }

    this->clear();
    for (std::map<PlexLedId,int>::iterator it=tmpMap.begin(); 
        it!=tmpMap.end(); it++) {
      this->push_back(it->first);
    }
  };

private:

  DbiResultPtr<PlexPinDiodeToLed> fResPtr;

};

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

LIPlexMaps::LIPlexMaps()
{
  MSG("LIPlexMaps",Msg::kDebug)<<"LIPlexMaps Constructor"<<endl;

  //set the pretty palette
  gStyle->SetPalette(1,(Int_t*)0);

}

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

LIPlexMaps::~LIPlexMaps()
{
  MSG("LIPlexMaps",Msg::kDebug)<<"LIPlexMaps Destructor"<<endl;
}

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

Bool_t LIPlexMaps::IsPermitted() const
{
  MSG("LIPlexMaps",Msg::kDebug) 
    <<" ** Running IsPermitted method... **"<<endl;

  char* envVariable=getenv("LITSQLPERMISSION");
  if (envVariable==NULL){
    MSG("LIAnalysis",Msg::kWarning)
      <<endl<<endl
      <<"*************************************************************"
      <<endl
      <<"WARNING: You have tried to do a sensitive operation."<<endl
      <<"This feature is designed to make you stop and think."<<endl
      <<"If you know what you are doing then look at the code."<<endl
      <<"*************************************************************"
      <<endl<<endl;
    return false;
  }

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

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

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

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

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

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

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

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

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

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

      //create the histo
      //30/Aug/04 - changed to using fabs, not sure if this will work!
      TH1F* h=new TH1F("h","h",numBins,vMin-fabs(0.1*vMin),
                       vMax+fabs(0.1*vMin));
      h->SetBit(TH1::kCanRebin);

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

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

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

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

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

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

      delete h;
    }
  }

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

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

void LIPlexMaps::BinomialGen(vector<Double_t>& v,Int_t N,Double_t p)
{
  MSG("LIPlexMaps",Msg::kDebug) 
    <<" ** Running BinomialGen method... **"<<endl;

  //Note: This analytical method goes wrong for N>170 
  //because the precision of 
  //the doubles can't handle the large factorials
  //in this case the approximation to a gaussian will be used

  //prob of r events in N is:
  //N!/r!*(N-r)! * p**r * (1-p)**(N-r)
  //where p is the probability of a success

  Double_t totalProb=0;

  if (N<=170){
    vector<Double_t> factorials(N+1);
    this->FactorialGen(factorials);
    
    for (UInt_t r=0;r<v.size();r++){
      Double_t perm=factorials[N]/(factorials[r]*factorials[N-r]);
      Double_t successes=pow(p,(Int_t)(r));
      Double_t failures=pow(1-p,(Int_t)(N-r));
      v[r]=perm*successes*failures;
      totalProb+=v[r];
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Prob of "<<r<<" events = "<<v[r]
        <<" (perm="<<perm
        <<", succ="<<successes
        <<", fail="<<failures<<")"
        <<endl;

      MSG("LIPlexMaps",Msg::kInfo)<<"Total prob = "<<totalProb<<endl;
    }
  }
  else if (N>170){
    //use gaussian distribution with following
    //mean=prob*ntot+0.5
    //standard deviation = sqrt(ntot*prob*(1-prob).
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Above N=170 this has not been implemented"<<endl;
  }

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

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

void LIPlexMaps::FactorialGen(vector<Double_t>& v)
{
  MSG("LIPlexMaps",Msg::kDebug) 
    <<" ** Running FactorialGen method... **"<<endl;

  //Note: The precision of the double is not enough above 170!
  //166 factorial = 9.00369e+297
  //167 factorial = 1.50362e+300
  //168 factorial = 2.52608e+302
  //169 factorial = 4.26907e+304
  //170 factorial = 7.25742e+306
  //171 factorial = inf
  
  if (v.size()>=2){
    v[0]=1;
    v[1]=1;
  }

  for (UInt_t i=2;i<v.size();i++){
    v[i]=v[i-1]*i;
    MSG("LIPlexMaps",Msg::kInfo)<<i<<" factorial = "<<v[i]<<endl;
  }

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

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

Int_t LIPlexMaps::SampleDist(vector<Double_t> v,TRandom* tRand)
{
  MSG("LIPlexMaps",Msg::kVerbose) 
    <<" ** Running SampleDist method... **"<<endl;

  //Note: v's maximum entry must be 1

  Int_t size=v.size();
  Int_t p=-1;

  Int_t foundPoint=0;
  while (foundPoint==0){
    
    p=tRand->Integer(size);
    Double_t probToChose=v[p];
    Double_t r1=tRand->Rndm();
    
    MSG("LIPlexMaps",Msg::kVerbose) 
      <<"point="<<p<<", probToChose="<<probToChose<<", r1="<<r1<<endl;
    
    if (probToChose>=r1) foundPoint=1;
  }

  MSG("LIPlexMaps",Msg::kVerbose) 
    <<" ** Finished SampleDist method **"<<endl;
  return p;
}

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

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

  vector<Double_t> x;
  vector<Double_t> xNorm;
  vector<Double_t> yGreenAtt1;
  vector<Double_t> yGreenAtt2;
  vector<Double_t> yGreen;
  vector<Double_t> yClear;
  vector<Double_t> y12C;
  vector<Double_t> y6G;
  vector<Double_t> y2G;
  vector<Double_t> y1G_12C_1G_1;
  vector<Double_t> y1G_12C_1G_2;
  vector<Double_t> y1G_12C_1G_3;
  vector<Double_t> x1G_12C_1G_1;
  vector<Double_t> x1G_12C_1G_2;
  vector<Double_t> x1G_12C_1G_3;
  vector<Double_t> y8G;
  vector<Double_t> y3GNear;
  vector<Double_t> y6CNear;
  vector<Double_t> y3GFar;
  vector<Double_t> y6CFar;

  vector<Double_t> boost12C;
  vector<Double_t> boost6G;
  vector<Double_t> boost8G;
  vector<Double_t> boost1G_12C_1G;
  vector<Double_t> reflectivity;

  Double_t maxCableLength=20;
  Int_t numPoints=1000;

  //attenuation lengths in meters
  Double_t greenAtt1=1;
  Double_t greenAtt2=10;//6m from Leo, 10m from KR off-axis talk
  Double_t clearAtt=12;

  //from MK
  //Double_t greenAtt1=0.5;
  //Double_t greenAtt2=6.7;
  //Double_t clearAtt=12.5;

  Double_t ref=1.0;

  Double_t ref12C=exp(-12./clearAtt);
  Double_t ref6G=0.5*(exp(-6./greenAtt1)+exp(-6./greenAtt2));
  Double_t ref2G=0.5*(exp(-2./greenAtt1)+exp(-2./greenAtt2));
  Double_t ref8G=0.5*(exp(-8./greenAtt1)+exp(-8./greenAtt2));
  Double_t ref1G_12C_1G=ref2G*ref12C;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Reflectivity = "<<ref
    <<endl
    <<"6m green = "<<ref6G<<" (0.22)"
    <<endl
    <<"12m clear = "<<ref12C<<" (0.20)"
    <<endl
    <<"8m green = "<<ref8G<<" (0.06)"
    <<endl
    <<"1mG & 12mC & 1mG = "<<ref1G_12C_1G<<" (0.09)"
    <<endl;

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating boosts..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    reflectivity.push_back(0);
    boost12C.push_back(0);
    boost6G.push_back(0);
    boost1G_12C_1G.push_back(0);
    boost8G.push_back(0);

    Double_t connectorEff=1.0;

    reflectivity[i]=i*1./numPoints;
    boost12C[i]=connectorEff*reflectivity[i]*ref12C;
    boost1G_12C_1G[i]=connectorEff*reflectivity[i]*ref12C*ref2G;

    boost6G[i]=reflectivity[i]*ref6G;
    boost8G[i]=reflectivity[i]*ref8G;
  }

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating basic attenuation curves..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    x.push_back(0);
    yGreenAtt1.push_back(0);
    yGreenAtt2.push_back(0);
    yGreen.push_back(0);
    yClear.push_back(0);
    
    x[i]=i*maxCableLength/numPoints;
    yGreenAtt1[i]=exp(-x[i]/greenAtt1);
    yGreenAtt2[i]=exp(-x[i]/greenAtt2);
    yGreen[i]=0.5*(exp(-x[i]/greenAtt1)+exp(-x[i]/greenAtt2));
    yClear[i]=exp(-x[i]/clearAtt);
  }

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating for 1st 1 m of green..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    Double_t x=i*1./numPoints;
    xNorm.push_back(0);
    y12C.push_back(0);
    y6G.push_back(0);
    y2G.push_back(0);
    y8G.push_back(0);

    //only 1 (~meter) for fractional reflected length
    xNorm[i]=i*1./numPoints;
    
    y12C[i]=exp(-12*xNorm[i]/clearAtt);
    y6G[i]=0.5*(exp(-6*xNorm[i]/greenAtt1)+exp(-6*xNorm[i]/greenAtt2));
    y2G[i]=0.5*(exp(-2*xNorm[i]/greenAtt1)+exp(-2*xNorm[i]/greenAtt2));

    if (x<1./14){
      Double_t x2=i*1./((1./14)*numPoints);
      y1G_12C_1G_1.push_back(0);
      x1G_12C_1G_1.push_back(0);
      x1G_12C_1G_1[i]=x;
      y1G_12C_1G_1[i]=0.5*(exp(-1*x2/greenAtt1)+exp(-1*x2/greenAtt2));
      MSG("LIPlexMaps",Msg::kDebug) 
        <<"x="<<x<<", x2="<<x2
        <<", x1G_12C_1G_1[i]="<<x1G_12C_1G_1[i]
        <<", y1G_12C_1G_1[i]="<<y1G_12C_1G_1[i]
        <<endl;
    }
    y8G[i]=0.5*(exp(-8*xNorm[i]/greenAtt1)+exp(-8*xNorm[i]/greenAtt2));
  }

  UInt_t size_1=y1G_12C_1G_1.size();
  Int_t counter=0;

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating for 12 m of clear..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    Double_t x=i*1./numPoints;

    if (x>1./14 && x<13./14){
      Double_t x2=counter*1./((12./14)*numPoints);
      y1G_12C_1G_2.push_back(0);
      x1G_12C_1G_2.push_back(0);
      x1G_12C_1G_2[counter]=x;
      y1G_12C_1G_2[counter]=y1G_12C_1G_1[size_1-1]*exp(-12*x2/clearAtt);
      MSG("LIPlexMaps",Msg::kDebug) 
        <<"x="<<x<<", x2="<<x2
        <<", x1G_12C_1G_2[i]="<<x1G_12C_1G_2[counter]
        <<", y1G_12C_1G_2[i]="<<y1G_12C_1G_2[counter]
        <<endl;
      counter++;
    }
  }
  
  UInt_t size_2=y1G_12C_1G_2.size();
  counter=0;

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating for last 1 m of green..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    Double_t x=i*1./numPoints;

    if (x>13./14){
      Double_t x2=counter*1./((1./14)*numPoints);
      y1G_12C_1G_3.push_back(0);
      x1G_12C_1G_3.push_back(0);
      x1G_12C_1G_3[counter]=x;

      //take account of the x2+1 using scaleFactor
      Double_t scaleFactor=1./y1G_12C_1G_1[size_1-1];
      y1G_12C_1G_3[counter]=scaleFactor*y1G_12C_1G_2[size_2-1]*0.5*
        (exp(-1*(x2+1)/greenAtt1)+
         exp(-1*(x2+1)/greenAtt2));
      MSG("LIPlexMaps",Msg::kDebug) 
        <<"x="<<x<<", x2="<<x2
        <<", x1G_12C_1G_3[i]="<<x1G_12C_1G_3[counter]
        <<", y1G_12C_1G_3[i]="<<y1G_12C_1G_3[counter]
        <<endl;
      counter++;
    }
  }

  UInt_t size_3=y1G_12C_1G_3.size();
  UInt_t size_8G=y8G.size();

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Calculating for last section to PMT..."<<endl;
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Near side..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    Double_t x=i*1./numPoints;

    y3GNear.push_back(0);
    y6CNear.push_back(0);
    
    y3GNear[i]=y1G_12C_1G_3[size_3-1]*0.5*
      (exp(-3.*x/greenAtt1)+exp(-3.*x/greenAtt2));
    y6CNear[i]=y8G[size_8G-1]*exp(-6.*x/clearAtt);
    
    MSG("LIPlexMaps",Msg::kDebug) 
      <<"x="<<x
      <<", y3GNear[i]="<<y3GNear[i]
      <<", y6CNear[i]"<<y6CNear[i]
      <<endl;
  }

  UInt_t size_12C=y12C.size();
  UInt_t size_6G=y6G.size();

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Far side..."<<endl;
  for (Int_t i=0;i<numPoints;i++){
    Double_t x=i*1./numPoints;

    y3GFar.push_back(0);
    y6CFar.push_back(0);
    
    y3GFar[i]=y12C[size_12C-1]*0.5*
      (exp(-3.*x/greenAtt1)+exp(-3.*x/greenAtt2));
    y6CFar[i]=y6G[size_6G-1]*exp(-6.*x/clearAtt);
    
    MSG("LIPlexMaps",Msg::kDebug) 
      <<"x="<<x
      <<", y3GFar[i]="<<y3GFar[i]
      <<", y6CFar[i]"<<y6CFar[i]
      <<endl;
  }

  //create canvas
  TCanvas *cAttenuation=new TCanvas("cAttenuation","cAttenuation",
                                  1,1,1000,800);
  cAttenuation->SetFillColor(0);
  cAttenuation->Divide(2,2);

  //create graph
  TGraph* gGreen=TGraphVect(x,yGreen);
  gGreen->SetTitle("Green Attenuation length (1+2)");
  gGreen->SetMarkerStyle(3);
  gGreen->SetMarkerColor(3);
  gGreen->SetMarkerSize(0.2);
  cAttenuation->cd(1);
  gGreen->Draw("AP");
  gGreen->GetXaxis()->SetTitle("Cable length");
  gGreen->GetYaxis()->SetTitle("Intensity");
  gGreen->GetXaxis()->CenterTitle();
  gGreen->GetYaxis()->CenterTitle();
  gGreen->SetMinimum(0);
  
  //create graph
  TGraph* gGreenAtt1=TGraphVect(x,yGreenAtt1);
  gGreenAtt1->SetTitle("Green Attenuation length 1");
  gGreenAtt1->SetMarkerStyle(3);
  gGreenAtt1->SetMarkerColor(30);
  gGreenAtt1->SetMarkerSize(0.2);
  cAttenuation->cd(2);
  gGreenAtt1->Draw("AP");
  gGreenAtt1->GetXaxis()->SetTitle("Cable length");
  gGreenAtt1->GetYaxis()->SetTitle("Intensity");
  gGreenAtt1->GetXaxis()->CenterTitle();
  gGreenAtt1->GetYaxis()->CenterTitle();
  gGreenAtt1->SetMinimum(0);

  //create graph
  TGraph* gGreenAtt2=TGraphVect(x,yGreenAtt2);
  gGreenAtt2->SetTitle("Green Attenuation length 2");
  gGreenAtt2->SetMarkerStyle(3);
  gGreenAtt2->SetMarkerColor(8);
  gGreenAtt2->SetMarkerSize(0.2);
  cAttenuation->cd(3);
  gGreenAtt2->Draw("AP");
  gGreenAtt2->GetXaxis()->SetTitle("Cable length");
  gGreenAtt2->GetYaxis()->SetTitle("Intensity");
  gGreenAtt2->GetXaxis()->CenterTitle();
  gGreenAtt2->GetYaxis()->CenterTitle();
  gGreenAtt2->SetMinimum(0);

  //create graph
  TGraph* gClear=TGraphVect(x,yClear);
  gClear->SetTitle("Clear Attenuation length");
  gClear->SetMarkerStyle(3);
  gClear->SetMarkerColor(1);
  gClear->SetMarkerSize(0.2);
  cAttenuation->cd(4);
  gClear->Draw("AP");
  gClear->GetXaxis()->SetTitle("Cable length");
  gClear->GetYaxis()->SetTitle("Intensity");
  gClear->GetXaxis()->CenterTitle();
  gClear->GetYaxis()->CenterTitle();
  gClear->SetMinimum(0);

  //create canvas
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cAttCalDet canvas..."<<endl;
  TCanvas *cAttCalDet=new TCanvas("cAttCalDet","cAttCalDet",
                                  1,1,1000,800);
  cAttCalDet->SetFillColor(0);
  //cAttCalDet->Divide(2,2);

  //create graph
  TGraph* g12C=TGraphVect(xNorm,y12C);
  g12C->SetTitle("Fractional Attenuation (LI Far Side)");
  g12C->SetMarkerStyle(3);
  g12C->SetMarkerColor(1);
  g12C->SetMarkerSize(0.2);
  cAttCalDet->cd(1);
  g12C->Draw("AP");
  g12C->GetXaxis()->SetTitle("Fraction of reflected distance (m)");
  g12C->GetYaxis()->SetTitle("Intensity");
  g12C->GetXaxis()->CenterTitle();
  g12C->GetYaxis()->CenterTitle();
  g12C->SetMinimum(0);

  //create graph
  TGraph* g6G=TGraphVect(xNorm,y6G);
  g6G->SetTitle("Fractional Attenuation");
  g6G->SetMarkerStyle(3);
  g6G->SetMarkerColor(3);
  g6G->SetMarkerSize(0.2);
  cAttCalDet->cd(1);
  g6G->Draw("P");

  //create graph
  TGraph* g12C_2=TGraphVect(xNorm,y12C);
  g12C_2->SetTitle("12 m Clear Attenuation");
  g12C_2->SetMarkerStyle(3);
  g12C_2->SetMarkerColor(1);
  g12C_2->SetMarkerSize(0.2);
  //cAttCalDet->cd(2);
  //g12C_2->Draw("AP");
  g12C_2->GetXaxis()->SetTitle("Fraction of reflected distance (m)");
  g12C_2->GetYaxis()->SetTitle("Intensity");
  g12C_2->GetXaxis()->CenterTitle();
  g12C_2->GetYaxis()->CenterTitle();
  g12C_2->SetMinimum(0);

  //create graph
  g6G->SetTitle("6 m Green Attenuation");
  g6G->SetMarkerStyle(3);
  g6G->SetMarkerColor(3);
  g6G->SetMarkerSize(0.2);
  //cAttCalDet->cd(3);
  //g6G->Draw("AP");
  g6G->GetXaxis()->SetTitle("Fraction of reflected distance (m)");
  g6G->GetYaxis()->SetTitle("Intensity");
  g6G->GetXaxis()->CenterTitle();
  g6G->GetYaxis()->CenterTitle();
  g6G->SetMinimum(0);
  
  //create canvas
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cAttCalDet2 canvas..."<<endl;
  TCanvas *cAttCalDet2=new TCanvas("cAttCalDet2","cAttCalDet2",
                                   1,1,1000,800);
  cAttCalDet2->SetFillColor(0);
  cAttCalDet2->Divide(1,1);

  //create graph
  TGraph* gDummy=TGraphVect(xNorm,xNorm);
  gDummy->SetTitle("Fractional Attenuation (LI Near Side)");
  gDummy->SetMinimum(0);
  gDummy->SetMaximum(1.2);
  gDummy->SetMarkerColor(0);
  cAttCalDet2->cd(1);
  gDummy->Draw("AP");
  gDummy->GetXaxis()->SetTitle("Fraction of reflected distance (m)");
  gDummy->GetYaxis()->SetTitle("Intensity");
  gDummy->GetXaxis()->CenterTitle();
  gDummy->GetYaxis()->CenterTitle();

  //create graph
  TGraph* g1G_12C_1G_1=TGraphVect(x1G_12C_1G_1,y1G_12C_1G_1);
  g1G_12C_1G_1->SetTitle("Fractional Attenuation");
  g1G_12C_1G_1->SetMarkerStyle(3);
  g1G_12C_1G_1->SetMarkerColor(3);
  g1G_12C_1G_1->SetMarkerSize(0.2);
  cAttCalDet2->cd(1);
  g1G_12C_1G_1->Draw("p");
  g1G_12C_1G_1->SetMinimum(0);

  //create graph
  TGraph* g1G_12C_1G_2=TGraphVect(x1G_12C_1G_2,y1G_12C_1G_2);
  g1G_12C_1G_2->SetTitle("Fractional Attenuation");
  g1G_12C_1G_2->SetMarkerStyle(3);
  g1G_12C_1G_2->SetMarkerColor(1);
  g1G_12C_1G_2->SetMarkerSize(0.2);
  cAttCalDet2->cd(1);
  g1G_12C_1G_2->Draw("P");
  g1G_12C_1G_2->SetMinimum(0);

  //create graph
  TGraph* g1G_12C_1G_3=TGraphVect(x1G_12C_1G_3,y1G_12C_1G_3);
  g1G_12C_1G_3->SetTitle("Fractional Attenuation");
  g1G_12C_1G_3->SetMarkerStyle(3);
  g1G_12C_1G_3->SetMarkerColor(3);
  g1G_12C_1G_3->SetMarkerSize(0.2);
  cAttCalDet2->cd(1);
  g1G_12C_1G_3->Draw("P");
  g1G_12C_1G_3->SetMinimum(0);

  //create graph
  TGraph* g8G=TGraphVect(xNorm,y8G);
  g8G->SetTitle("Fractional Attenuation");
  g8G->SetMarkerStyle(3);
  g8G->SetMarkerColor(8);
  g8G->SetMarkerSize(0.2);
  cAttCalDet2->cd(1);
  g8G->Draw("P");
  g8G->SetMinimum(0);

  //create canvas
  /*
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cAttCalDetNear canvas..."<<endl;
  TCanvas *cAttCalDetNear=new TCanvas("cAttCalDetNear","cAttCalDetNear",
                                      1,1,1000,800);
  cAttCalDetNear->SetFillColor(0);
  cAttCalDetNear->Divide(1,1);

  //create graph
  TGraph* g3GNear=TGraphVect(xNorm,y3GNear);
  g3GNear->SetTitle("Fractional Attenuation (LI Near Side)");
  g3GNear->SetMarkerStyle(3);
  g3GNear->SetMarkerColor(3);
  g3GNear->SetMarkerSize(0.2);
  cAttCalDetNear->cd(1);
  g3GNear->Draw("AP");
  g3GNear->GetXaxis()->SetTitle("Fraction of distance to PMT (m)");
  g3GNear->GetYaxis()->SetTitle("Intensity");
  g3GNear->GetXaxis()->CenterTitle();
  g3GNear->GetYaxis()->CenterTitle();
  g3GNear->SetMaximum(1.2);
  g3GNear->SetMinimum(0);

  //create graph
  TGraph* g6CNear=TGraphVect(xNorm,y6CNear);
  g6CNear->SetTitle("Fractional Attenuation (LI Near Side)");
  g6CNear->SetMarkerStyle(3);
  g6CNear->SetMarkerColor(1);
  g6CNear->SetMarkerSize(0.2);
  cAttCalDetNear->cd(1);
  g6CNear->Draw("P");
  g6CNear->SetMinimum(0);

  //create canvas
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cAttCalDetFar canvas..."<<endl;
  TCanvas *cAttCalDetFar=new TCanvas("cAttCalDetFar","cAttCalDetFar",
                                     1,1,1000,800);
  cAttCalDetFar->SetFillColor(0);
  cAttCalDetFar->Divide(1,1);

  //create graph
  TGraph* g3GFar=TGraphVect(xNorm,y3GFar);
  g3GFar->SetTitle("Fractional Attenuation (LI Far Side)");
  g3GFar->SetMarkerStyle(3);
  g3GFar->SetMarkerColor(3);
  g3GFar->SetMarkerSize(0.2);
  cAttCalDetFar->cd(1);
  g3GFar->Draw("AP");
  g3GFar->GetXaxis()->SetTitle("Fraction of distance to PMT (m)");
  g3GFar->GetYaxis()->SetTitle("Intensity");
  g3GFar->GetXaxis()->CenterTitle();
  g3GFar->GetYaxis()->CenterTitle();
  g3GFar->SetMaximum(1.2);
  g3GFar->SetMinimum(0);

  //create graph
  TGraph* g6CFar=TGraphVect(xNorm,y6CFar);
  g6CFar->SetTitle("Fractional Attenuation (LI Far Side)");
  g6CFar->SetMarkerStyle(3);
  g6CFar->SetMarkerColor(1);
  g6CFar->SetMarkerSize(0.2);
  cAttCalDetFar->cd(1);
  g6CFar->Draw("P");
  g6CFar->SetMinimum(0);
  */

  //create canvas
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cBoostsFar canvas..."<<endl;
  TCanvas *cBoostsFar=new TCanvas("cBoostsFar","cBoostsFar",
                                  1,1,1000,800);
  cBoostsFar->SetFillColor(0);
  cBoostsFar->Divide(1,1);

  //create graph
  TGraph* cBoost6G=TGraphVect(reflectivity,boost6G);
  cBoost6G->SetTitle("Fractional Boost vs Reflectivity");
  cBoost6G->SetMarkerStyle(3);
  cBoost6G->SetMarkerColor(3);
  cBoost6G->SetMarkerSize(0.2);
  cBoostsFar->cd(1);
  cBoost6G->Draw("AP");
  cBoost6G->GetXaxis()->SetTitle("Reflectivity");
  cBoost6G->GetYaxis()->SetTitle("Fractional Boost");
  cBoost6G->GetXaxis()->CenterTitle();
  cBoost6G->GetYaxis()->CenterTitle();
  cBoost6G->SetMaximum(1.2);
  cBoost6G->SetMinimum(0);

  //create graph
  TGraph* cBoost12C=TGraphVect(reflectivity,boost12C);
  cBoost12C->SetTitle("Fractional Boost vs Reflectivity");
  cBoost12C->SetMarkerStyle(3);
  cBoost12C->SetMarkerColor(1);
  cBoost12C->SetMarkerSize(0.2);
  cBoostsFar->cd(1);
  cBoost12C->Draw("P");
  cBoost12C->SetMinimum(0);


  //create canvas
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Drawing cBoostsNear canvas..."<<endl;
  TCanvas *cBoostsNear=new TCanvas("cBoostsNear","cBoostsNear",
                                  1,1,1000,800);
  cBoostsNear->SetFillColor(0);
  cBoostsNear->Divide(1,1);

  //create graph
  TGraph* cBoost8G=TGraphVect(reflectivity,boost8G);
  cBoost8G->SetTitle("Fractional Boost vs Reflectivity");
  cBoost8G->SetMarkerStyle(3);
  cBoost8G->SetMarkerColor(3);
  cBoost8G->SetMarkerSize(0.2);
  cBoostsNear->cd(1);
  cBoost8G->Draw("AP");
  cBoost8G->GetXaxis()->SetTitle("Reflectivity");
  cBoost8G->GetYaxis()->SetTitle("Fractional Boost");
  cBoost8G->GetXaxis()->CenterTitle();
  cBoost8G->GetYaxis()->CenterTitle();
  cBoost8G->SetMaximum(1.2);
  cBoost8G->SetMinimum(0);

  //create graph
  TGraph* cBoost1G_12C_1G=TGraphVect(reflectivity,boost1G_12C_1G);
  cBoost1G_12C_1G->SetTitle("Fractional Boost vs Reflectivity");
  cBoost1G_12C_1G->SetMarkerStyle(3);
  cBoost1G_12C_1G->SetMarkerColor(1);
  cBoost1G_12C_1G->SetMarkerSize(0.2);
  cBoostsNear->cd(1);
  cBoost1G_12C_1G->Draw("P");
  cBoost1G_12C_1G->SetMinimum(0);

  MSG("LIPlexMaps",Msg::kInfo) 
    <<" ** Finished Attenuation method **"<<endl;
}

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

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

  //Theory
  //gain=rms**2/mean * 1/(1-p)
  //thus
  //rms=sqrt(gain*mean*(1-p))
  //and
  //npe=(mean/rms)**2 * (1-p)

  //use the pretty palette
  gStyle->SetPalette(1);
  //include the under and overflow counts
  gStyle->SetOptStat(1111111);

  TStopwatch stopwatch;

  //these two are defined
  const Double_t kQE=0.13;
  
  //TRandom has a periodicity of 10^8 so if you have >100 photons
  //then you shouldn't use more than 1e6 points in the binomial 
  //distribution since you will have started at the beginning of 
  //the list of random numbers again
  //not sure how this will affect things but it seems dodgy
  const Int_t kNumBinomPoints=static_cast<Int_t>(1e6);//1e7 is slow

  MSG("LIPlexMaps",Msg::kInfo) 
    <<endl<<"The following parameters are used in the MC:"<<endl
    <<"kQE="<<kQE<<endl
    <<"kNumBinomPoints="<<kNumBinomPoints<<endl;

  Int_t maxN=150;
  TH1F *hBinomial= new TH1F("hBinomial","Binomial distribution",
                            maxN+5,-1,maxN+4);
  hBinomial->SetFillColor(0);
  hBinomial->SetBit(TH1::kCanRebin);

  TH1F *hBinomial2= new TH1F("hBinomial2","Binomial distribution",
                            maxN+5,-1,maxN+4);
  hBinomial2->SetFillColor(0);
  hBinomial2->SetLineColor(2);
  hBinomial2->SetBit(TH1::kCanRebin);

  TH1F *hBinomial3= new TH1F("hBinomial3","Binomial distribution",
                            maxN+5,-1,maxN+4);
  hBinomial3->SetFillColor(0);
  hBinomial3->SetLineColor(3);
  hBinomial3->SetBit(TH1::kCanRebin);

  //create a histogram based on the binomial
  TRandom *tRandom=new TRandom(0);
  
  for (Int_t N=100;N<160;N+=20){
    static Int_t counter=0;
    counter++;
    
    MSG("LIPlexMaps",Msg::kInfo) 
      <<endl<<"Generating binomial distribution..."<<endl;
    for (Int_t i=0;i<kNumBinomPoints;i++){
      //generate a binomial distribution and fill histo
      //this works by performing a little MC
      //It does N trials and see how many are below the probability p
      Int_t r1=tRandom->Binomial(static_cast<Int_t>(N),
                                 static_cast<Double_t>(kQE));
    
      //apply rail
      if (r1>15) r1=15;

      if (counter==1) hBinomial->Fill(r1);
      if (counter==2) hBinomial2->Fill(r1);
      if (counter==3) hBinomial3->Fill(r1);

      //print out loop progress
      Float_t fract=ceil(kNumBinomPoints/5.);
      if (ceil(((Float_t)i)/fract)==((Float_t)i)/fract){
        MSG("LIPlexMaps",Msg::kInfo) 
          <<"Fraction of loop complete: "<<i 
          <<"/"<<kNumBinomPoints<<"  ("
          <<(Int_t)(100.*i/kNumBinomPoints)<<"%)"<<endl;
      }    
    }
    MSG("LIPlexMaps",Msg::kInfo) 
      <<"Binomial distribution done"<<endl;
  }

  //draw binomial distribution
  TCanvas *cBinomial=new TCanvas("cBinomial","cBinomial",1,1,1000,800);
  cBinomial->SetFillColor(0);
  cBinomial->cd();
  hBinomial->Draw();
  hBinomial2->Draw("sames");
  hBinomial3->Draw("sames");

  MSG("LIPlexMaps",Msg::kInfo) 
    <<" ** Finished ADCRailEffect method **"<<endl;
}

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

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

  //use the pretty palette
  gStyle->SetPalette(1);
  //include the under and overflow counts
  gStyle->SetOptStat(1111111);

  Int_t maxN=1000;

  TH1F *hBinomial= new TH1F("hBinomial","Binomial distribution",
                            maxN+5,-1,maxN+4);
  hBinomial->SetFillColor(0);
  hBinomial->SetLineColor(3);
  hBinomial->SetBit(TH1::kCanRebin);

  TH1F *hAdc= new TH1F("hAdc","Binomial distribution",
                            60*maxN+5,-1,60*maxN+4);
  hAdc->SetFillColor(0);
  hAdc->SetLineColor(3);
  hAdc->SetBit(TH1::kCanRebin);

  TH1F *hGauss= new TH1F("hGauss","Binomial distribution",
                            maxN+5,-1,maxN+4);
  hGauss->SetFillColor(0);
  hGauss->SetLineColor(2);
  hGauss->SetBit(TH1::kCanRebin);

  //create a histogram based on the binomial
  TRandom *tRandom=new TRandom(0);
  //Double_t kQE=0.13;
  Int_t kNumBinomPoints=10000;
  vector<Double_t> vPe;
  vector<Double_t> vAdc;

  for (Int_t N=120;N<270;N+=2){
    static Int_t counter=0;
    counter++;
    
    hBinomial->Reset();
    hAdc->Reset();
    hGauss->Reset();

    MSG("LIPlexMaps",Msg::kInfo) 
      <<endl<<"Generating distribution, N="<<N<<endl;
    for (Int_t i=0;i<kNumBinomPoints;i++){

      Double_t gauss=tRandom->Gaus(1.*N,sqrt(1.*N));
      hGauss->Fill(gauss);

      Double_t adc=70.*gauss-(1.3e-6*pow(1.*gauss,4.));

      //apply the rail at 237
      if (gauss>237) adc=70*237-(1.3e-6*pow(237,4.));
    
      hAdc->Fill(adc);
    }

    vPe.push_back(1.*N);
    vAdc.push_back(hAdc->GetMean());
  }

  //original numbers, but 420 pe for saturation is too high
  /*
  for (Int_t N=250;N<480;N+=2){
    static Int_t counter=0;
    counter++;
    
    hBinomial->Reset();
    hAdc->Reset();
    hGauss->Reset();

    MSG("LIPlexMaps",Msg::kInfo) 
      <<endl<<"Generating distribution, N="<<N<<endl;
    for (Int_t i=0;i<kNumBinomPoints;i++){
      //generate a binomial distribution and fill histo
      //this works by performing a little MC
      //It does N trials and see how many are below the probability p
      //Int_t r1=tRandom->Binomial(static_cast<Int_t>(N),
      //                         static_cast<Double_t>(kQE));
      //hBinomial->Fill(r1);

      //Double_t gauss=tRandom->Gaus(N*kQE,3.29);
      Double_t gauss=tRandom->Gaus(1.*N,sqrt(1.*N));
      hGauss->Fill(gauss);

      Double_t adc=60.*gauss-(2e-7*pow(1.*gauss,4.));

      //apply the rail at 420
      if (gauss>420) adc=60*420-(2e-7*pow(420,4.));

      hAdc->Fill(adc);
    }

    vPe.push_back(1.*N);
    vAdc.push_back(hAdc->GetMean());
  }
  */

  //draw binomial distribution
  TCanvas *cBinomial=new TCanvas("cBinomial","cBinomial",1,1,1000,800);
  cBinomial->SetFillColor(0);
  cBinomial->cd();
  hBinomial->Draw();
  hGauss->Draw("sames");

  //draw distribution
  TCanvas *cAdc=new TCanvas("cAdc","cAdc",1,1,1000,800);
  cAdc->SetFillColor(0);
  cAdc->cd();
  hAdc->Draw();

  vector<Double_t> vx;
  vector<Double_t> vy;
  vector<Double_t> vStraight;

  for (Double_t i=0;i<300;i+=1){
    Double_t x=i;
    Double_t y=70*x-(1.3e-6*pow(x,4.));

    //apply the rail at 237
    if (x>237) y=70*237-(1.3e-6*pow(237,4.));

    vx.push_back(x);
    vy.push_back(y);
    vStraight.push_back(70*x);

  }

  TGraph* g=this->TGraphVect(vx,vy);
  TGraph* gStraight=this->TGraphVect(vx,vStraight);
  TGraph* gAdcVsPe=this->TGraphVect(vPe,vAdc);

  //draw graph
  TCanvas *cNonLin=new TCanvas("cNonLin","cNonLin",1,1,1000,800);
  cNonLin->SetFillColor(0);
  cNonLin->cd();
  g->Draw("AP");
  g->SetMarkerSize(1);
  g->SetMarkerStyle(3);
  g->SetMarkerColor(3);
  gStraight->Draw("p");
  gStraight->SetMarkerSize(1);
  gStraight->SetMarkerStyle(3);
  gStraight->SetMarkerColor(1);
  gAdcVsPe->Draw("p");
  gAdcVsPe->SetMarkerSize(1);
  gAdcVsPe->SetMarkerStyle(3);
  gAdcVsPe->SetMarkerColor(2);
  //these graphs show that the measured nonlinearity is not
  //the same as the actual nonlinearity near the saturation
  //level. But the two only differ by <1% so it shouldn't
  //matter too much.

  MSG("LIPlexMaps",Msg::kInfo) 
    <<" ** Finished NonLinearity method **"<<endl;
}

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

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

  //Theory
  //gain=rms**2/mean * 1/(1-p)
  //thus
  //rms=sqrt(gain*mean*(1-p))
  //and
  //npe=(mean/rms)**2 * (1-p)

  //use the pretty palette
  gStyle->SetPalette(1);
  //include the under and overflow counts
  gStyle->SetOptStat(1111111);

  TStopwatch stopwatch;

  //these two are defined
  const Double_t kQE=0.13;
  const Double_t kGain=80;

  //these rough numbers allow a number of photons to be derived
  //by specifying the roughMean
  //probably a bit pointless!!!
  Double_t roughMean=500;
  Double_t roughRms=fLookup.CalcRms(roughMean,kGain,kQE);
  Double_t roughNpe=fLookup.CalcNpe(roughMean,roughRms,kQE);
  
  //round up the number of photons
  Double_t tempN=-1;
  Double_t rem=0;
  rem=modf(roughNpe/kQE,&tempN);
  if (rem>=0.5) tempN++;
  
  //the number of photons is the number from which all others
  //must be derived
  const Int_t kN=static_cast<Int_t>(tempN);//number of photons
  const Double_t kNpe=kN*kQE;
  const Double_t kMean=kGain*kNpe;
  const Double_t kRms=fLookup.CalcRms(kMean,kGain,kQE);
  const Double_t kAdcsPerPe=kMean/kNpe;

  //TRandom has a periodicity of 10^8 so if you have >100 photons
  //then you shouldn't use more than 1e6 points in the binomial 
  //distribution since you will have started at the beginning of 
  //the list of random numbers again
  //not sure how this will affect things but it seems dodgy
  const Int_t kNumBinomPoints=static_cast<Int_t>(1e6);//1e7 is slow

  MSG("LIPlexMaps",Msg::kInfo) 
    <<endl<<"The following parameters are used in the MC:"<<endl
    <<"kQE="<<kQE<<endl
    <<"kN="<<kN<<endl
    <<"kMean="<<kMean<<endl
    <<"kRms="<<kRms<<endl
    <<"kGain="<<kGain<<endl
    <<"kNpe="<<kNpe<<endl
    <<"kAdcsPerPe="<<kAdcsPerPe<<endl
    <<"kNumBinomPoints="<<kNumBinomPoints<<endl;

  TH1F *hBinomial= new TH1F("hBinomial","Binomial distribution",
                            kN+3,-1,kN+2);
  hBinomial->SetFillColor(0);
  hBinomial->SetBit(TH1::kCanRebin);

  TH1F *hADC= new TH1F("hADC","hADC",15000,-1,15000);
  hADC->SetFillColor(0);
  hADC->SetBit(TH1::kCanRebin);
  TH1F *hADC2= new TH1F("hADC2","hADC2",15000,-1,15000);
  hADC2->SetFillColor(0);
  hADC2->SetBit(TH1::kCanRebin);

  vector<Double_t> vBinomial(kN+1);
  Double_t maxInBinomial=0;  
  Int_t maxInBinomialPos=0;  

  //create a histogram based on the binomial
  TRandom *tRandom=new TRandom(0);
  MSG("LIPlexMaps",Msg::kInfo) 
    <<endl<<"Generating binomial distribution..."<<endl;
  for (Int_t i=0;i<kNumBinomPoints;i++){
    //generate a binomial distribution and fill histo
    //this works by performing a little MC
    //It does N trials and see how many are below the probability p
    Int_t r1=tRandom->Binomial(static_cast<Int_t>(kN),
                               static_cast<Double_t>(kQE));
    hBinomial->Fill(r1);
    vBinomial[r1]++;

    //keep track of the maximum in the distribution
    if (vBinomial[r1]>maxInBinomial){
      maxInBinomial=vBinomial[r1];
      maxInBinomialPos=r1;
    }

    //print out loop progress
    Float_t fract=ceil(kNumBinomPoints/5.);
    if (ceil(((Float_t)i)/fract)==((Float_t)i)/fract){
      MSG("LIPlexMaps",Msg::kInfo) 
        <<"Fraction of loop complete: "<<i 
        <<"/"<<kNumBinomPoints<<"  ("
        <<(Int_t)(100.*i/kNumBinomPoints)<<"%)"<<endl;
    }    
  }
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Binomial distribution done"<<endl;

  //draw binomial distribution
  TCanvas *cBinomial=new TCanvas("cBinomial","cBinomial",1,1,1000,800);
  cBinomial->SetFillColor(0);
  cBinomial->cd();
  hBinomial->Draw();

  //scale the binomial by the max
  this->ScaleVector(vBinomial,1/maxInBinomial);

  //fill a histogram that will look like the adc distribution
  //you would get from the binomial distribution above
  for (Int_t i=0;i<2500;i++){
    MSG("LIPlexMaps",Msg::kVerbose)<<"i="<<i<<endl;
    hADC->Fill(kAdcsPerPe*hBinomial->GetRandom());
    Int_t npe=this->SampleDist(vBinomial,tRandom);
    hADC2->Fill(kAdcsPerPe*npe);
  }

  //draw the adc distribution you would expect from the binomial above
  TCanvas *cAdc=new TCanvas("cAdc","cAdc",1,1,1000,800);
  cAdc->SetFillColor(0);
  cAdc->Divide(2,1);
  cAdc->cd(1);
  hADC->Draw();
  cAdc->cd(2);
  hADC2->Draw();

  const Int_t kNumPoints=20;
  const Int_t kFlashes=500; 
  Double_t *numFlashes=new Double_t[kNumPoints];

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<"Calculating errors analytically"<<endl;
  //analytically
  for (Int_t j=0;j<kNumPoints;j++){
    numFlashes[j]=static_cast<Double_t>((j+1)*kFlashes);
    MSG("LIPlexMaps",Msg::kInfo)
      <<endl<<"Point "<<j+1<<"/"<<kNumPoints
      <<", numFlashes="<<numFlashes[j]<<endl;

    //calcualte and print out the errors analytically
    //error on mean = rms/sqrt(NumFlashes)
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Mean="<<kMean<<", rms="<<kRms
      <<", N="<<numFlashes[j]
      <<", Errors: eMean="<<kRms/sqrt(numFlashes[j])
      <<" ("<<((kRms/sqrt(numFlashes[j]))/kMean)*100<<"%)"
      <<", eRms="<<kRms/sqrt(numFlashes[j])
      <<" ("<<(1/sqrt(numFlashes[j]))*100<<"%)"
      <<", eGain="
      <<"("<<((1/sqrt(numFlashes[j]))*2+
              (kRms/sqrt(numFlashes[j]))/kMean)*100<<"%)"
      <<" quad="
      <<"("<<sqrt((1/numFlashes[j])*2+
                  pow((kRms/sqrt(numFlashes[j]))/kMean,2))*100<<"%)"
      <<endl;      
  }

  Double_t *mean=new Double_t[kNumPoints*kFlashes];
  Double_t *rms=new Double_t[kNumPoints*kFlashes];
  Double_t *gain=new Double_t[kNumPoints*kFlashes];
  Double_t *xAxis=new Double_t[kNumPoints*kFlashes];

  Double_t *rmsOfMean=new Double_t[kNumPoints];
  Double_t *rmsOfGain=new Double_t[kNumPoints];
  Double_t *rmsOfRms=new Double_t[kNumPoints];
  Double_t *errorOnMean=new Double_t[kNumPoints];
  Double_t *errorOnGain=new Double_t[kNumPoints];
  Double_t *errorOnRms=new Double_t[kNumPoints];
  Double_t *errorOnMeanN=new Double_t[kNumPoints];
  Double_t *errorOnGainN=new Double_t[kNumPoints];
  Double_t *errorOnRmsN=new Double_t[kNumPoints];

  const Int_t kNumLiRuns=1000;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<"Calculating errors by MC"<<endl;
  //MC
  for (Int_t j=0;j<kNumPoints;j++){
    numFlashes[j]=static_cast<Double_t>((j+1)*kFlashes);
    MSG("LIPlexMaps",Msg::kInfo)
      <<endl<<"Point "<<j+1<<"/"<<kNumPoints
      <<", numFlashes="<<numFlashes[j]<<endl;
    
    stopwatch.Start();
    
    //take many "runs"
    for (Int_t k=0;k<kNumLiRuns;k++){
      hADC->Reset();
      for (Int_t i=0;i<(j+1)*kFlashes;i++){
        //hADC->Fill(kAdcsPerPe*hBinomial->GetRandom());
        hADC->Fill(kAdcsPerPe*this->SampleDist(vBinomial,tRandom));
      }
      mean[k]=hADC->GetMean();
      rms[k]=hADC->GetRMS();
      gain[k]=fLookup.CalcGain(mean[k],rms[k],kQE);
      xAxis[k]=static_cast<Double_t>(k);
      rmsOfMean[j]+=pow(kMean-mean[k],2);
      rmsOfGain[j]+=pow(kGain-gain[k],2);
      rmsOfRms[j]+=pow(kRms-rms[k],2);
    }
    
    stopwatch.Stop();
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Time elapsed, real="<<stopwatch.RealTime()
      <<", cpu="<<stopwatch.CpuTime()
      <<endl;
    
    //final step in rms calculation
    rmsOfMean[j]=sqrt(rmsOfMean[j]/kNumLiRuns);
    rmsOfGain[j]=sqrt(rmsOfGain[j]/kNumLiRuns);
    rmsOfRms[j]=sqrt(rmsOfRms[j]/kNumLiRuns);
    
    //don't do sqrt of numLiRuns because you don't want
    //the error on the gain if you take 1000 runs
    //but rather the error on each individual run!!!
    errorOnMean[j]=rmsOfMean[j]/sqrt(1.);
    errorOnGain[j]=rmsOfGain[j]/sqrt(1.);
    errorOnRms[j]=rmsOfRms[j]/sqrt(1.);

    //calcualte fractional errors
    errorOnMeanN[j]=errorOnMean[j]/kMean;
    errorOnGainN[j]=errorOnGain[j]/kGain;
    errorOnRmsN[j]=errorOnRms[j]/kRms;
    
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Errors: eMean="<<errorOnMean[j]
      <<" ("<<errorOnMeanN[j]*100<<"%)"
      <<", eGain="<<errorOnGain[j]
      <<" ("<<errorOnGainN[j]*100<<"%)"
      <<", eRms="<<errorOnRms[j]
      <<" ("<<errorOnRmsN[j]*100<<"%)"
      <<endl;
  }

  //
  TCanvas *cGain=new TCanvas("cGain","cGain",1,1,1000,800);
  cGain->SetFillColor(0);
  cGain->Divide(1,2);

  TGraph *gGain=new TGraph(kNumLiRuns,xAxis,gain);
  gGain->SetTitle("Gain Vs 'run'");
  gGain->SetMarkerStyle(3);
  gGain->SetMarkerColor(2);
  gGain->SetMarkerSize(0.4);
  cGain->cd(1);
  gGain->Draw("AP");
  gGain->GetXaxis()->SetTitle("'run' number");
  gGain->GetYaxis()->SetTitle("Gain");
  gGain->GetXaxis()->CenterTitle();
  gGain->GetYaxis()->CenterTitle();

  TGraph *gMean=new TGraph(kNumLiRuns,xAxis,mean);
  gMean->SetTitle("Mean Vs 'run'");
  gMean->SetMarkerStyle(3);
  gMean->SetMarkerColor(2);
  gMean->SetMarkerSize(0.4);
  cGain->cd(2);
  gMean->Draw("AP");
  gMean->GetXaxis()->SetTitle("'run' number");
  gMean->GetYaxis()->SetTitle("Mean");
  gMean->GetXaxis()->CenterTitle();
  gMean->GetYaxis()->CenterTitle();

  //plot the errors on the gain
  //create canvas
  TCanvas *cGainError=new TCanvas("cGainError","cGainError",
                                  1,1,1000,800);
  cGainError->SetFillColor(0);
  cGainError->Divide(1,2);
  
  //create graph
  TGraph *gGainErrorNormVsFlashes=new TGraph(kNumPoints,
                                             numFlashes,errorOnGainN);
  gGainErrorNormVsFlashes->SetTitle
    ("Fractional Error on Gain Vs Flashes");
  gGainErrorNormVsFlashes->SetMarkerStyle(3);
  gGainErrorNormVsFlashes->SetMarkerColor(2);
  gGainErrorNormVsFlashes->SetMarkerSize(0.2);
  cGainError->cd(1);
  gGainErrorNormVsFlashes->Draw("AP");
  gGainErrorNormVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gGainErrorNormVsFlashes->GetYaxis()->SetTitle
    ("Fractional Error on Gain");
  gGainErrorNormVsFlashes->GetXaxis()->CenterTitle();
  gGainErrorNormVsFlashes->GetYaxis()->CenterTitle();
  gGainErrorNormVsFlashes->SetMinimum(0);

  //create graph
  TGraph *gGainErrorVsFlashes=new TGraph(kNumPoints,
                                         numFlashes,errorOnGain);
  gGainErrorVsFlashes->SetTitle("Error on Gain Vs Flashes");
  gGainErrorVsFlashes->SetMarkerStyle(3);
  gGainErrorVsFlashes->SetMarkerColor(2);
  gGainErrorVsFlashes->SetMarkerSize(0.2);
  cGainError->cd(2);
  gGainErrorVsFlashes->Draw("AP");
  gGainErrorVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gGainErrorVsFlashes->GetYaxis()->SetTitle("Error on Gain");
  gGainErrorVsFlashes->GetXaxis()->CenterTitle();
  gGainErrorVsFlashes->GetYaxis()->CenterTitle();

  //plot the errors on the mean
  //create canvas
  TCanvas *cGainMean=new TCanvas("cGainMean","cGainMean",1,1,1000,800);
  cGainMean->SetFillColor(0);
  cGainMean->Divide(1,2);
  
  //create graph
  TGraph *gMeanErrorNormVsFlashes=new TGraph(kNumPoints,
                                             numFlashes,errorOnMeanN);
  gMeanErrorNormVsFlashes->SetTitle
    ("Fractional Error on Mean Vs Flashes");
  gMeanErrorNormVsFlashes->SetMarkerStyle(3);
  gMeanErrorNormVsFlashes->SetMarkerColor(2);
  gMeanErrorNormVsFlashes->SetMarkerSize(0.2);
  cGainMean->cd(1);
  gMeanErrorNormVsFlashes->Draw("AP");
  gMeanErrorNormVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gMeanErrorNormVsFlashes->GetYaxis()->SetTitle
    ("Fractional Error on Mean");
  gMeanErrorNormVsFlashes->GetXaxis()->CenterTitle();
  gMeanErrorNormVsFlashes->GetYaxis()->CenterTitle();
  gMeanErrorNormVsFlashes->SetMinimum(0);

  //create graph
  TGraph *gMeanErrorVsFlashes=new TGraph(kNumPoints,
                                         numFlashes,errorOnMean);
  gMeanErrorVsFlashes->SetTitle("Error on Mean Vs Flashes");
  gMeanErrorVsFlashes->SetMarkerStyle(3);
  gMeanErrorVsFlashes->SetMarkerColor(2);
  gMeanErrorVsFlashes->SetMarkerSize(0.2);
  cGainMean->cd(2);
  gMeanErrorVsFlashes->Draw("AP");
  gMeanErrorVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gMeanErrorVsFlashes->GetYaxis()->SetTitle("Error on Mean");
  gMeanErrorVsFlashes->GetXaxis()->CenterTitle();
  gMeanErrorVsFlashes->GetYaxis()->CenterTitle();

  //plot the errors on the rms
  //create canvas
  TCanvas *cRmsErr=new TCanvas("cRmsErr","cRmsErr",1,1,1000,800);
  cRmsErr->SetFillColor(0);
  cRmsErr->Divide(1,2);
  
  //create graph
  TGraph *gRmsErrorNormVsFlashes=new TGraph(kNumPoints,
                                             numFlashes,errorOnRmsN);
  gRmsErrorNormVsFlashes->SetTitle
    ("Fractional Error on Rms Vs Flashes");
  gRmsErrorNormVsFlashes->SetMarkerStyle(3);
  gRmsErrorNormVsFlashes->SetMarkerColor(2);
  gRmsErrorNormVsFlashes->SetMarkerSize(0.2);
  cRmsErr->cd(1);
  gRmsErrorNormVsFlashes->Draw("AP");
  gRmsErrorNormVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gRmsErrorNormVsFlashes->GetYaxis()->SetTitle
    ("Fractional Error on Rms");
  gRmsErrorNormVsFlashes->GetXaxis()->CenterTitle();
  gRmsErrorNormVsFlashes->GetYaxis()->CenterTitle();
  gRmsErrorNormVsFlashes->SetMinimum(0);

  //create graph
  TGraph *gRmsErrorVsFlashes=new TGraph(kNumPoints,
                                         numFlashes,errorOnRms);
  gRmsErrorVsFlashes->SetTitle("Error on Rms Vs Flashes");
  gRmsErrorVsFlashes->SetMarkerStyle(3);
  gRmsErrorVsFlashes->SetMarkerColor(2);
  gRmsErrorVsFlashes->SetMarkerSize(0.2);
  cRmsErr->cd(2);
  gRmsErrorVsFlashes->Draw("AP");
  gRmsErrorVsFlashes->GetXaxis()->SetTitle("Number of Flashes");
  gRmsErrorVsFlashes->GetYaxis()->SetTitle("Error on Rms");
  gRmsErrorVsFlashes->GetXaxis()->CenterTitle();
  gRmsErrorVsFlashes->GetYaxis()->CenterTitle();

  /*
  // get a random energy value between 0-40 GeV
  enNeutrino=(Float_t)(gRandom->Rndm())*39.99;
  enNeutrinoBin=(Int_t)(enNeutrino*5.+1.);
  enNeutrinoProb=leevents[enNeutrinoBin]; 

      if ((Float_t)(gRandom->Rndm())<=enNeutrinoProb){

        // get a random y value between 0-1 
        yValue=(Float_t)(gRandom->Rndm())*0.99999999;
        
        // determine the energy range  
        yEnergyRange=(Int_t)(enNeutrino/5.);
        if (yEnergyRange>5) {yEnergyRange=5;}
        
        // select y value prob from suitable y 
        //distribution given the energy range
        yValueProb=ydist[yEnergyRange*10+(Int_t)(yValue*10.)];
        
        if ((Float_t)(gRandom->Rndm())<=yValueProb){
          eventSelectedFlag=1;
          neutrinoEnergy[i]=enNeutrino;
          
          neutrinoEn=enNeutrino;
          if (neutrinoEn>29.9999999){neutrinoEn=29.999999;}

          muEffProb[i]=mueff[((Int_t)(yValue*10.)*30)+
                            (Int_t)(neutrinoEn)];
          ncEffProb[i]=nceff[((Int_t)(yValue*10.)*30)+
                            (Int_t)(neutrinoEn)];
          
          eHadSmeared[i]=(yValue*enNeutrino)*
            (1.+0.55*(gRandom->Gaus(0.,1.))/
             sqrt(yValue*enNeutrino));
          if (eHadSmeared[i]<0.) {(eHadSmeared[i]=0.);}
        
          eMuSmeared=((1-yValue)*enNeutrino)*
            (1+0.11*(gRandom->Gaus(0.,1.)));
          reconEnergy[i]=eHadSmeared[i]+eMuSmeared;
          //Double_t Gaus(Double_t mean, Double_t sigma) 
        } //end of if 
      } //end of if
    } //end of while
  } //end of for
  */

  MSG("LIPlexMaps",Msg::kInfo)
    <<" ** Finished the PeGen method ** "<<endl;
}

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

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

  //use the pretty palette
  gStyle->SetPalette(1);
  //include the under and overflow counts
  gStyle->SetOptStat(1111111);

  //these two are defined
  const Double_t kQE=0.13;
  const Double_t kGain=80;

  const Int_t kNumPoints=50;  

  TGraph *gGainErrorNormVsMean=new TGraph(kNumPoints);
  TGraph *gMeanErrorNormVsMean=new TGraph(kNumPoints);
  TGraph *gRmsErrorNormVsMean=new TGraph(kNumPoints);

  for (Int_t i=0;i<kNumPoints;i++){

    //these rough numbers allow a number of photons to be derived
    //by specifying the roughMean
    //probably a bit pointless!!!
    Double_t roughMean=200*(i+1);
    Double_t roughRms=fLookup.CalcRms(roughMean,kGain,kQE);
    Double_t roughNpe=fLookup.CalcNpe(roughMean,roughRms,kQE);
    
    //round up the number of photons
    Double_t tempN=-1;
    Double_t rem=0;
    rem=modf(roughNpe/kQE,&tempN);
    if (rem>=0.5) tempN++;
    
    //the number of photons is the number from which all others
    //must be derived
    const Int_t kN=static_cast<Int_t>(tempN);//number of photons
    const Double_t kNpe=kN*kQE;
    const Double_t kMean=kGain*kNpe;
    const Double_t kRms=fLookup.CalcRms(kMean,kGain,kQE);
    const Double_t kAdcsPerPe=kMean/kNpe;
    
    MSG("LIPlexMaps",Msg::kInfo) 
      <<endl<<"The following parameters are used in the MC:"<<endl
      <<"kQE="<<kQE<<endl
      <<"kN="<<kN<<endl
      <<"kMean="<<kMean<<endl
      <<"kRms="<<kRms<<endl
      <<"kGain="<<kGain<<endl
      <<"kNpe="<<kNpe<<endl
      <<"kAdcsPerPe="<<kAdcsPerPe<<endl;

    Double_t numFlashes=1000;    
    Double_t errorOnMeanN=-1;
    Double_t errorOnGainN=-1;
    Double_t errorOnRmsN=-1;
    
    //calcualte the errors analytically
    //error on mean (and rms) = rms/sqrt(NumFlashes)
      
    //calcualte fractional errors
    errorOnMeanN=(kRms/sqrt(numFlashes))/kMean;
    errorOnRmsN=1/sqrt(numFlashes);
    errorOnGainN=sqrt(pow(errorOnRmsN,2)*2+
                         pow(errorOnMeanN,2));
    
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Mean="<<kMean<<", rms="<<kRms
      <<", N="<<numFlashes
      <<", Errors: eMean="
      <<"("<<errorOnMeanN*100<<"%)"
      <<", eRms="
      <<"("<<errorOnRmsN*100<<"%)"
      <<", eGain="<<"("<<errorOnGainN*100<<"%)"
      <<endl;      
    
    gGainErrorNormVsMean->SetPoint(i,kMean,errorOnGainN);
    gMeanErrorNormVsMean->SetPoint(i,kMean,errorOnMeanN);
    gRmsErrorNormVsMean->SetPoint(i,kMean,errorOnRmsN);
  }
    
  //plot the errors on the gain
  //create canvas
  TCanvas *cGainErrorVsMean=new TCanvas("cGainErrorVsMean",
                                        "cGainErrorVsMean",
                                        1,1,1000,800);
  cGainErrorVsMean->SetFillColor(0);
    
  gGainErrorNormVsMean->SetTitle("Fractional Error on Gain Vs Mean");
  gGainErrorNormVsMean->SetMarkerStyle(3);
  gGainErrorNormVsMean->SetMarkerColor(2);
  gGainErrorNormVsMean->SetMarkerSize(0.2);
  cGainErrorVsMean->cd(1);
  gGainErrorNormVsMean->Draw("AP");
  gGainErrorNormVsMean->GetXaxis()->SetTitle("Mean");
  gGainErrorNormVsMean->GetYaxis()->SetTitle
    ("Fractional Error on Gain");
  gGainErrorNormVsMean->GetXaxis()->CenterTitle();
  gGainErrorNormVsMean->GetYaxis()->CenterTitle();
  gGainErrorNormVsMean->SetMinimum(0);
    
  //plot the errors on the mean
  //create canvas
  TCanvas *cMeanErrorVsMean=new TCanvas("cMeanErrorVsMean",
                                        "cMeanErrorVsMean",
                                        1,1,1000,800);
  cMeanErrorVsMean->SetFillColor(0);

  gMeanErrorNormVsMean->SetTitle("Fractional Error on Mean Vs Mean");
  gMeanErrorNormVsMean->SetMarkerStyle(3);
  gMeanErrorNormVsMean->SetMarkerColor(2);
  gMeanErrorNormVsMean->SetMarkerSize(0.2);
  cMeanErrorVsMean->cd(1);
  gMeanErrorNormVsMean->Draw("AP");
  gMeanErrorNormVsMean->GetXaxis()->SetTitle("Mean");
  gMeanErrorNormVsMean->GetYaxis()->SetTitle
    ("Fractional Error on Mean");
  gMeanErrorNormVsMean->GetXaxis()->CenterTitle();
  gMeanErrorNormVsMean->GetYaxis()->CenterTitle();
  gMeanErrorNormVsMean->SetMinimum(0);
    
  //plot the errors on the rms
  //create canvas
  TCanvas *cRmsErrVsMean=new TCanvas("cRmsErrVsMean","cRmsErrVsMean",
                                     1,1,1000,800);
  cRmsErrVsMean->SetFillColor(0);

  gRmsErrorNormVsMean->SetTitle
    ("Fractional Error on Rms Vs Mean");
  gRmsErrorNormVsMean->SetMarkerStyle(3);
  gRmsErrorNormVsMean->SetMarkerColor(2);
  gRmsErrorNormVsMean->SetMarkerSize(0.2);
  cRmsErrVsMean->cd(1);
  gRmsErrorNormVsMean->Draw("AP");
  gRmsErrorNormVsMean->GetXaxis()->SetTitle("Mean");
  gRmsErrorNormVsMean->GetYaxis()->SetTitle
    ("Fractional Error on Rms");
  gRmsErrorNormVsMean->GetXaxis()->CenterTitle();
  gRmsErrorNormVsMean->GetYaxis()->CenterTitle();
  gRmsErrorNormVsMean->SetMinimum(0);
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<" ** Finished the LIErrors method ** "<<endl;
}
        
//......................................................................

void LIPlexMaps::PlotPlexPinMap()
{
  MSG("LIAnalysis",Msg::kInfo) 
    <<"Running PlotPlexPinMap method..."<<endl;

  //commented out whole method to prevent array warnings!!!
  //should use an object or something instead, no time at the mo

  /*    
  //set validity context to todays date and far detector and real data
  VldTimeStamp timeStamp(2002,10,1,1,1,1,1,0,0);
  VldContext validityContext(Detector::kFar,SimFlag::kData,
                             timeStamp);

  MSG("LIAnalysis",Msg::kInfo) 
    <<"Using validity context: "<<validityContext.AsString()<<endl;

  PlexHandle *myplexhandle= new PlexHandle(validityContext);   

  Float_t numMux=8.;
  Float_t numRacks=16.;
  const Int_t const_numCrates=static_cast<Int_t>(numRacks/2.);

  const Int_t const_numEastWest=2;
  const Int_t const_numRackLevels=2;
  const Int_t const_numRacks=static_cast<Int_t>(numRacks);
  const Int_t const_numMux=static_cast<Int_t>(numMux);
  const Int_t const_numPins=2;
  const Int_t const_numGains=2;

  //declare arrays
  Int_t pinPulserBox[const_numEastWest][const_numRackLevels]
    [const_numRacks][const_numMux][const_numPins][const_numGains];

  Int_t pinLed[const_numEastWest][const_numRackLevels]
    [const_numRacks][const_numMux][const_numPins][const_numGains];

  Int_t pinNumEntries[const_numEastWest][const_numRackLevels]
    [const_numRacks][const_numMux][const_numPins][const_numGains];

  Int_t pinVaChip[const_numEastWest][const_numRackLevels]
    [const_numRacks][const_numMux][const_numPins][const_numGains];

  //initialise arrays
  for (Int_t i=0; i<const_numEastWest; i++){
    for (Int_t j=0; j<const_numRackLevels; j++){
      for (Int_t k=0; k<const_numRacks;k++){
        for (Int_t l=0; l<const_numMux;l++){
          for (Int_t m=0; m<const_numPins;m++){
            for (Int_t n=0; n<const_numGains;n++){
              pinPulserBox[i][j][k][l][m][n]=-1;
              pinLed[i][j][k][l][m][n]=-1;
              pinNumEntries[i][j][k][l][m][n]=0;
              pinVaChip[i][j][k][l][m][n]=-1;
            }
          }
        }
      }
    }
  }
  
  //variables 
  Char_t eastWest='!'; //E=0 and W=1
  Char_t rackLevel='!';//L=0 and U=1
  UInt_t rackBay=0; 
  UInt_t inRack=0;
  UInt_t inBox=0;
  UInt_t gain=0;

  //loop over every possible combination of variables
  for (Int_t iEastWest=0;iEastWest<const_numEastWest;iEastWest++){
    //convert integers into characters
    //E=0 and W=1
    if (iEastWest==0){
      eastWest='E';
    }
    else if (iEastWest==1){
      eastWest='W';
    }
    
    for (Int_t iRackLevel=0;iRackLevel<const_numRackLevels;
         iRackLevel++){
      //convert integers into characters
      //L=0 and U=1
      if (iRackLevel==1){
        rackLevel='U';
      }
      else if (iRackLevel==0){
        rackLevel='L';
      }
      
      for (rackBay=0;rackBay<static_cast<UInt_t>(const_numRacks);
           rackBay++){
        for (inRack=0;inRack<static_cast<UInt_t>(const_numMux);
             inRack++){
          for (inBox=0;inBox<static_cast<UInt_t>(const_numPins);
               inBox++){
            for (gain=0;gain<static_cast<UInt_t>(const_numPins);gain++){
            
              //create a pindiodeId according to 
              //loop iteration variables
              const PlexPinDiodeId *plexPinId =new PlexPinDiodeId
                (Detector::kFar,ElecType::kVA,eastWest,rackLevel,
                 rackBay+1,inRack,inBox,gain); 
              
              //check if pindiodeid is valid
              //if not then print to screen and go to next iteration
              if (plexPinId->IsValid()){
                
                PlexLedId plexLedId=myplexhandle->GetLedId(*plexPinId);
                
                RawChannelId plexRawChId=myplexhandle->
                  GetRawChannelId(*plexPinId);
                
                //get va chip associated with rawchannel
                pinVaChip[iEastWest][iRackLevel][rackBay][inRack]
                  [inBox][gain]=plexRawChId.GetVaChip();

                //only set array values is ledid is valid
                //else leave initial values, e.g. led=-1
                if (plexLedId.IsValid()){
                  //get LED info
                  Int_t plexLedInBox=plexLedId.GetLedInBox();
                  Int_t plexPulserBox=plexLedId.GetPulserBox();
                  
                  pinLed[iEastWest][iRackLevel][rackBay][inRack]
                    [inBox][gain]=plexLedInBox;

                  pinPulserBox[iEastWest][iRackLevel][rackBay][inRack]
                    [inBox][gain]=plexPulserBox;

                  pinNumEntries[iEastWest][iRackLevel][rackBay][inRack]
                    [inBox][gain]++;

                  MSG("LIAnalysis",Msg::kVerbose) 
                    <<"plexLedInBox="<<plexLedInBox
                    <<", plexPulserBox="<<plexPulserBox
                    <<endl;
                  MSG("LIAnalysis",Msg::kVerbose) 
                    <<"plexLedId="<<plexLedId.AsString() 
                    <<endl;
                }
                else{
                  MSG("LIAnalysis",Msg::kVerbose) 
                    <<"ledId not valid:"
                    <<" plexLedId="<<plexLedId.AsString() 
                    <<endl
                    <<"plexPinId="<<plexPinId->AsString() 
                    <<endl;
                }
              }
              else{
                MSG("LIAnalysis",Msg::kVerbose) 
                  <<"pinId not valid:"
                  <<" plexPinId="<<plexPinId->AsString()<<endl;
              }
              delete plexPinId;
            }//end of for
          }//end of for
        }//end of for
      }//end of for
    }//end of for
  }//end of for

  TCanvas *cEast=new TCanvas("cEast","cEast",0,0,1200,800);
  cEast->SetFillColor(0);

  TCanvas *cWest=new TCanvas("cWest","cWest",0,0,1200,800);
  cWest->SetFillColor(0);
  cWest->cd();

  TText *titleE = new TText(0.28,0.955,
                            "Plex PIN Diode Map (East Side)");
  titleE->SetTextSize(0.045);
  TText *titleW = new TText(0.28,0.955,
                            "Plex PIN Diode Map (West Side)");
  titleW->SetTextSize(0.045);
  cEast->cd();
  titleE->Draw();
  cWest->cd();
  titleW->Draw();

  TPaveText *info=new TPaveText(0.75,0.94,1.0,1.0);
  info->SetBorderSize(0);
  info->SetFillColor(0);
  info->SetTextSize(0.018);
  info->SetTextColor(4);
  info->AddText("Numbers in mux boxes are LED numbers"); 
  info->AddText("Dark colour number is high gain pin");
  info->AddText("Mux box shading indicates Pulser Box"); 
  cEast->cd();
  info->Draw();
  cWest->cd();
  info->Draw();
  
  TPad *levelUE= new TPad("levelUE","pad for mux boxes",
                          0.01,0.59,0.99,0.94);
  TPad *levelME= new TPad("levelME","pad for crates",
                          0.01,0.39,0.99,0.56);
  TPad *levelLE= new TPad("levelLE","pad for mux boxes",
                          0.01,0.01,0.99,0.36);
  TPad *levelUW= new TPad("levelUW","pad for mux boxes",
                          0.01,0.59,0.99,0.94);
  TPad *levelMW= new TPad("levelMW","pad for crates",
                          0.01,0.39,0.99,0.56);
  TPad *levelLW= new TPad("levelLW","pad for mux boxes",
                          0.01,0.01,0.99,0.36);

  levelUE->SetFillColor(11);
  levelUE->SetBorderSize(3);
  levelUW->SetFillColor(11);
  levelUW->SetBorderSize(3);

  levelME->SetFillColor(11);
  levelME->SetBorderSize(2);
  levelMW->SetFillColor(11);
  levelMW->SetBorderSize(2);

  levelLE->SetFillColor(11);
  levelLE->SetBorderSize(1);
  levelLE->SetBorderMode(0);
  levelLW->SetFillColor(11);
  levelLW->SetBorderSize(1);
  levelLW->SetBorderMode(0);

  cEast->cd();
  levelUE->Draw();
  levelME->Draw();
  levelLE->Draw();
  cWest->cd();
  levelUW->Draw();
  levelMW->Draw();
  levelLW->Draw();

  
  TText *tLevelUE = new TText(0.01,0.89,
                              "Mux Box Racks (East Side, Upper Level)");
  TText *tLevelUW = new TText(0.01,0.89,
                              "Mux Box Racks (West Side, Upper Level)");
  TText *tLevelME = new TText
    (0.01,0.89,"Electronics Crates (East Side, Middle Level)");
  TText *tLevelMW = new TText
    (0.01,0.89,"Electronics Crates (West Side, Middle Level)");
  TText *tLevelLE = new TText(0.01,0.89,
                              "Mux Box Racks (East Side, Lower Level)");
  TText *tLevelLW = new TText(0.01,0.89,
                              "Mux Box Racks (West Side, Lower Level)");

  tLevelUE->SetTextSize(0.1);
  tLevelUW->SetTextSize(0.1);
  tLevelME->SetTextSize(0.08);
  tLevelMW->SetTextSize(0.08);
  tLevelLE->SetTextSize(0.1);
  tLevelLW->SetTextSize(0.1);

  levelUE->cd();
  tLevelUE->Draw();
  levelUW->cd();
  tLevelUW->Draw();

  levelME->cd();
  tLevelME->Draw();
  levelMW->cd();
  tLevelMW->Draw();
  
  levelLE->cd();
  tLevelLE->Draw();
  levelLW->cd();
  tLevelLW->Draw();
  
  Float_t rackSpace=0.07/(numRacks+1.);
  Float_t crateSpace=3.0*rackSpace;
  Float_t rackWidth=(1.-((numRacks/2)+2)*rackSpace-
                     ((numRacks/2)-1)*crateSpace)/numRacks;
  Float_t xMin=-1.;
  MSG("LIAnalysis",Msg::kDebug) 
    <<"rackSpace="<<rackSpace<<", crateSpace="<<crateSpace
    <<", rackWidth="<<rackWidth<<endl;

  TPad **rackUE=0;
  TPad **rackUW=0;
  TPad **rackLE=0;
  TPad **rackLW=0;
  
  rackUE=new TPad*[const_numRacks];
  rackUW=new TPad*[const_numRacks];
  rackLE=new TPad*[const_numRacks];
  rackLW=new TPad*[const_numRacks];

  for (Int_t rack=0;rack<const_numRacks;rack++){
    Float_t crate=floor(static_cast<Float_t>(rack)/2.);
    
    xMin=rackSpace
      +floor((static_cast<Float_t>(rack)+1)/2)*rackSpace
      +crate*crateSpace
      +static_cast<Float_t>(rack)*rackWidth;
    
    rackUE[rack]= new TPad("rackUE","Upper East Racks",
                           xMin,0.,xMin+rackWidth,0.87,17,3);
    rackUW[rack]= new TPad("rackUW","Upper West Racks",
                           xMin,0.,xMin+rackWidth,0.87,17,3);
    rackLE[rack]= new TPad("rackLE","Lower East Racks",
                           xMin,0.,xMin+rackWidth,0.87,17,3);
    rackLW[rack]= new TPad("rackLW","Lower West Racks",
                           xMin,0.,xMin+rackWidth,0.87,17,3);


    rackUE[rack]->SetFillColor(5);
    rackUW[rack]->SetFillColor(5);
    rackLE[rack]->SetFillColor(5);
    rackLW[rack]->SetFillColor(5);

    rackUE[rack]->SetBorderSize(0);
    rackUW[rack]->SetBorderSize(0);
    rackLE[rack]->SetBorderSize(0);
    rackLW[rack]->SetBorderSize(0);

    rackUE[rack]->SetBorderMode(0);
    rackUW[rack]->SetBorderMode(0);
    rackLE[rack]->SetBorderMode(0);
    rackLW[rack]->SetBorderMode(0);

    levelUE->cd();
    rackUE[rack]->Draw();
    levelUW->cd();
    rackUW[rack]->Draw();
    levelLE->cd();
    rackLE[rack]->Draw();
    levelLW->cd();
    rackLW[rack]->Draw();
  }
  
  //create mux boxes and draw
  TPaveText **muxBoxBg=0;
  muxBoxBg=new TPaveText*[const_numRacks];

  for (Int_t rack=0;rack<const_numRacks;rack++){
    
    muxBoxBg[rack]=new TPaveText(0.06,0.01,0.94,0.97);
    muxBoxBg[rack]->SetBorderSize(0);
    muxBoxBg[rack]->SetFillColor(0);

    rackUE[rack]->cd();
    muxBoxBg[rack]->Draw();
    rackUW[rack]->cd();
    muxBoxBg[rack]->Draw();
    rackLE[rack]->cd();
    muxBoxBg[rack]->Draw();
    rackLW[rack]->cd(); 
    muxBoxBg[rack]->Draw();
  }

  //create mux boxes labels
  TPaveText ***muxTextUE=0;
  muxTextUE=new TPaveText**[const_numRacks];
  TPaveText ***muxTextUW=0;
  muxTextUW=new TPaveText**[const_numRacks];
  TPaveText ***muxTextLE=0;
  muxTextLE=new TPaveText**[const_numRacks];
  TPaveText ***muxTextLW=0;
  muxTextLW=new TPaveText**[const_numRacks];
  for (Int_t rack=0;rack<const_numRacks;rack++){
    muxTextUE[rack]=new TPaveText*[2*const_numMux]; 
    muxTextUW[rack]=new TPaveText*[2*const_numMux]; 
    muxTextLE[rack]=new TPaveText*[2*const_numMux]; 
    muxTextLW[rack]=new TPaveText*[2*const_numMux];
 
    for (Int_t pin=0;pin<2*const_numMux;pin++){
      (muxTextUE[rack])[pin]=new TPaveText
        (0.09,
         0.015+static_cast<Int_t>(pin)*0.06,
         0.93,
         0.015+static_cast<Int_t>(pin+1)*0.06-0.010*(pin%2));
      (muxTextUW[rack])[pin]=new TPaveText
        (0.09,
         0.015+static_cast<Int_t>(pin)*0.06,
         0.93,
         0.015+static_cast<Int_t>(pin+1)*0.06-0.010*(pin%2));
      (muxTextLE[rack])[pin]=new TPaveText
        (0.09,
         0.015+static_cast<Int_t>(pin)*0.06,
         0.93,
         0.015+static_cast<Int_t>(pin+1)*0.06-0.010*(pin%2));
      (muxTextLW[rack])[pin]=new TPaveText
        (0.09,
         0.015+static_cast<Int_t>(pin)*0.06,
         0.93,
         0.015+static_cast<Int_t>(pin+1)*0.06-0.010*(pin%2));
      (muxTextUE[rack])[pin]->SetBorderSize(0);
      (muxTextUW[rack])[pin]->SetBorderSize(0);
      (muxTextLE[rack])[pin]->SetBorderSize(0);
      (muxTextLW[rack])[pin]->SetBorderSize(0);

      (muxTextUE[rack])[pin]->SetTextSize(0.2);
      (muxTextUW[rack])[pin]->SetTextSize(0.2);
      (muxTextLE[rack])[pin]->SetTextSize(0.2);
      (muxTextLW[rack])[pin]->SetTextSize(0.2);

      (muxTextUE[rack])[pin]->SetTextColor(5);
      (muxTextUW[rack])[pin]->SetTextColor(5);
      (muxTextLE[rack])[pin]->SetTextColor(5);
      (muxTextLW[rack])[pin]->SetTextColor(5);

      (muxTextUE[rack])[pin]->SetTextFont(2);
      (muxTextUW[rack])[pin]->SetTextFont(2);
      (muxTextLE[rack])[pin]->SetTextFont(2);
      (muxTextLW[rack])[pin]->SetTextFont(2);

      (muxTextUE[rack])[pin]->SetFillColor(20);//18
      (muxTextUW[rack])[pin]->SetFillColor(20);//18
      (muxTextLE[rack])[pin]->SetFillColor(20);//18
      (muxTextLW[rack])[pin]->SetFillColor(20);//18
    }
  }
 
  MSG("LIAnalysis",Msg::kInfo) 
    <<"Filling and drawing mux box labels..."<<endl;
  //fill and draw mux box labels
  for (Int_t iEastWest=0;iEastWest<const_numEastWest;iEastWest++){
    for (Int_t iRackLevel=0;iRackLevel<const_numRackLevels;
         iRackLevel++){
      for (rackBay=0;rackBay<static_cast<UInt_t>(const_numRacks);
           rackBay++){
        
        //draw in the correct rack bay
        if (iRackLevel==0){
          if (iEastWest==0){
            rackLE[rackBay]->cd();
            MSG("LIAnalysis",Msg::kInfo)<<"Lower East:"<<endl;
          }
          else if (iEastWest==1){
            rackLW[const_numRacks-1-rackBay]->cd();
            MSG("LIAnalysis",Msg::kInfo)<<"Lower West:"<<endl;
          }
        }
        else if (iRackLevel==1){
          if (iEastWest==0){
            rackUE[rackBay]->cd();
            MSG("LIAnalysis",Msg::kInfo)<<"Upper East:"<<endl;
          }
          else if (iEastWest==1){
            rackUW[const_numRacks-1-rackBay]->cd();
            MSG("LIAnalysis",Msg::kInfo)<<"Upper West:"<<endl;
          }
        }
        for (inRack=0;inRack<static_cast<UInt_t>(const_numMux);
             inRack++){
          for (inBox=0;inBox<static_cast<UInt_t>(const_numPins);
               inBox++){
            for (gain=0;gain<static_cast<UInt_t>(const_numPins);gain++){

              //The vfbs are flipped on the east side relative
              //to the west side, thus whether pin 1 is plotted
              //nearest the floor or the ceiling must change
              //depending on the side
              Int_t pin=-1;
              //On the east side pin 1 is nearest floor and pin one
              //nearest ceiling
              if (iEastWest==0){//East
                //pins ordered ordered: 1,0, 3,2, 5,4, 7,6 etc
                if (inBox==0){
                  pin=2*inRack+1;
                }
                else if (inBox==1){
                  pin=2*inRack+0;
                }
              }
              //On the west side pin 1 is nearest ceiling and pin one
              //nearest floor
              else if (iEastWest==1){//West
                pin=2*inRack+inBox;//0-15 from bottom to top
              }

              MSG("LIAnalysis",Msg::kInfo)
                <<"E/W="<<iEastWest
                <<", U/L="<<iRackLevel
                <<", rack="<<rackBay
                <<", mux="<<inRack
                <<", inBox="<<inBox
                <<", gain="<<gain
                <<", pin="<<pin
                <<", pb=" 
                <<pinPulserBox[iEastWest][iRackLevel][rackBay]
                [inRack][inBox][gain]
                <<", led=" 
                <<pinLed[iEastWest][iRackLevel][rackBay][inRack]
                [inBox][gain]
                <<", va=" 
                <<pinVaChip[iEastWest][iRackLevel][rackBay][inRack]
                [inBox][gain]
                <<endl;
              
              //check if led illuminates pin
              if (pinNumEntries[iEastWest][iRackLevel][rackBay][inRack]
                  [inBox][gain]==1){

                string s = Form("%d",pinLed[iEastWest][iRackLevel][rackBay][inRack][inBox][gain]);

                if (iEastWest==0){//East
                  if (iRackLevel==1){
                    //label mux box according to led number
                    (muxTextUE[rackBay])[pin]->AddText
                      (0.5,0.5,s.c_str());
                    //set fill colour according to pulser box number
                    (muxTextUE[rackBay])[pin]->SetFillColor
                      (19-pinPulserBox[iEastWest][iRackLevel][rackBay]
                       [inRack][inBox][gain]/2);

                    if (gain==0){//low gain
                      (muxTextUE[rackBay])[pin]->SetTextColor(7);
                      //7=aqua
                    }
                    else if (gain==1){//high gain
                      (muxTextUE[rackBay])[pin]->SetTextColor(4);
                      //4=bright blue
                    }
                  }
                  else if (iRackLevel==0){
                    //label mux box according to led number
                    (muxTextLE[rackBay])[pin]->AddText
                      (0.5,0.5,s.c_str()); 
                    //set fill colour according to pulser box number
                    (muxTextLE[rackBay])[pin]->SetFillColor
                      (19-pinPulserBox[iEastWest][iRackLevel][rackBay]
                       [inRack][inBox][gain]/2);

                    if (gain==0){//low gain
                      (muxTextLE[rackBay])[pin]->SetTextColor(7);
                      //7=aqua
                    }
                    else if (gain==1){//high gain
                      (muxTextLE[rackBay])[pin]->SetTextColor(4);
                      //4=bright blue
                    }
                  }
                }                 
                else if (iEastWest==1){//West
                  if (iRackLevel==1){
                    //label mux box according to led number
                    (muxTextUW[rackBay])[pin]->AddText
                      (0.5,0.5,s.c_str()); 
                    //set fill colour according to pulser box number
                    (muxTextUW[rackBay])[pin]->
                      SetFillColor
                      (19-pinPulserBox[iEastWest][iRackLevel][rackBay]
                       [inRack][inBox][gain]/2);

                    if (gain==0){//low gain
                      (muxTextUW[rackBay])[pin]->
                        SetTextColor(7);
                      //7=aqua
                    }
                    else if (gain==1){//high gain
                      (muxTextUW[rackBay])[pin]->
                        SetTextColor(4);
                      //4=bright blue
                    }
                  }
                  else if (iRackLevel==0){  
                    //label mux box according to led number
                    (muxTextLW[rackBay])[pin]->
                      AddText
                      (0.5,0.5,s.c_str()); 
                    //set fill colour according to pulser box number
                    (muxTextLW[rackBay])[pin]->
                      SetFillColor
                      (19-pinPulserBox[iEastWest][iRackLevel][rackBay]
                       [inRack][inBox][gain]/2);

                    if (gain==0){//low gain
                      (muxTextLW[rackBay])[pin]->
                        SetTextColor(7);
                      //7=aqua
                    }
                    else if (gain==1){//high gain
                      (muxTextLW[rackBay])[pin]->
                        SetTextColor(4);
                      //4=bright blue
                    }
                  }
                }
              }
              //there should be zero entries if the pin socket is empty
              else if(pinNumEntries[iEastWest][iRackLevel][rackBay]
                      [inRack][inBox][gain]==0){
                if (gain==0){
                  //check if there is an led on the high gain [1] pin
                  //because you don't want to write in the same
                  //box twice
                  if (pinNumEntries[iEastWest][iRackLevel][rackBay]
                      [inRack][inBox][1]==0){               
                    //there was no led on either h or l pin so:
                    if (iEastWest==0){
                      if (iRackLevel==1){
                        (muxTextUE[rackBay])[pin]->AddText
                          (0.5,0.5,"NO LED"); 
                      }
                      else if (iRackLevel==0){
                        (muxTextLE[rackBay])[pin]->AddText
                          (0.5,0.5,"NO LED"); 
                      }
                    }
                    else if (iEastWest==1){
                      if (iRackLevel==1){
                        (muxTextUW[rackBay])[pin]->
                          AddText(0.5,0.5,"NO LED"); 
                      }
                      else if (iRackLevel==0){
                        (muxTextLW[rackBay])[pin]->
                          AddText(0.5,0.5,"NO LED"); 
                      }
                    }
                  }
                }
                else {//gain==1
                  //this will have already been set, if required, 
                  //because you get to the gain==0 pin first
                }
              }
              else{
                if (iEastWest==0){
                  if (iRackLevel==1){
                    (muxTextUE[rackBay])[pin]->AddText
                      (0.5,0.5,"Error!"); 
                  }
                  else if (iRackLevel==0){
                    (muxTextLE[rackBay])[pin]->AddText
                      (0.5,0.5,"Error!"); 
                  }
                }
                else if (iEastWest==1){
                  if (iRackLevel==1){
                    (muxTextUW[rackBay])[pin]->AddText
                      (0.5,0.5,"Error!"); 
                  }
                  else if (iRackLevel==0){
                    (muxTextLW[rackBay])[pin]->AddText
                      (0.5,0.5,"Error!"); 
                  }
                }               
                MSG("LIAnalysis",Msg::kWarning) 
                  <<"Warning: numEntries=" 
                  <<pinNumEntries[iEastWest][iRackLevel][rackBay]
                  [inRack][inBox][gain]
                  <<" for rackBay="<<rackBay<<", pin="<<pin
                  <<endl;
              }

              //determine which set of mux boxes need drawing         
              if (iEastWest==0){
                if (iRackLevel==1){
                  (muxTextUE[rackBay])[pin]->Draw();
                }
                else if (iRackLevel==0){
                  (muxTextLE[rackBay])[pin]->Draw();
                }
              }
              else if (iEastWest==1){
                if (iRackLevel==1){
                  (muxTextUW[rackBay])[pin]->Draw();
                }
                else if (iRackLevel==0){
                  (muxTextLW[rackBay])[pin]->Draw();
                }
              }
            }
          }
        }
      }
    }
  }
  MSG("LIAnalysis",Msg::kInfo)<<"... OK"<<endl;
  
  //draw crates
  MSG("LIAnalysis",Msg::kInfo)<<"Drawing crates..."<<endl;
  TPad **cratesE=0;
  cratesE=new TPad*[const_numCrates];
  TPad **cratesW=0;
  cratesW=new TPad*[const_numCrates];
  
  TPaveText **crateLabelE=0;
  crateLabelE=new TPaveText*[const_numCrates];
  TPaveText **crateLabelW=0;
  crateLabelW=new TPaveText*[const_numCrates];

  //calculate space between crates
  crateSpace=(1
              -(numRacks/2)*rackWidth
              -2*(1.5*rackSpace+(rackWidth/2))
              )/((numRacks/2)-1);

  //loop over crates
  for (Int_t cra=0;cra<static_cast<Int_t>(numRacks/2);cra++){

    xMin=1.5*rackSpace+(rackWidth/2)
      +static_cast<Float_t>(cra)*crateSpace
      +static_cast<Float_t>(cra)*rackWidth;

    cratesE[cra]=new TPad("crates","Crates",
                          xMin,0.,xMin+rackWidth,0.85,17,3);
    cratesE[cra]->SetFillColor(5);
    cratesE[cra]->SetBorderSize(0);
    cratesE[cra]->SetBorderMode(0);
    levelME->cd();
    cratesE[cra]->Draw();

    cratesW[cra]=new TPad("crates","Crates",
                          xMin,0.,xMin+rackWidth,0.85,17,3);
    cratesW[cra]->SetFillColor(5);
    cratesW[cra]->SetBorderSize(0);
    cratesW[cra]->SetBorderMode(0);
    levelMW->cd();
    cratesW[cra]->Draw();

    crateLabelE[cra]=new TPaveText(0.1,0.01,0.9,0.95);
    crateLabelE[cra]->SetBorderSize(0);
    crateLabelW[cra]=new TPaveText(0.1,0.01,0.9,0.95);
    crateLabelW[cra]->SetBorderSize(0);

    string s=Form("%d",2*cra);
    crateLabelE[cra]->AddText(0.5,0.95,"Pulser");
    crateLabelE[cra]->AddText(0.5,0.8,"Box");
    crateLabelE[cra]->AddText(0.5,0.65,s.c_str());
    crateLabelE[cra]->SetTextSize(0.25);
    //set fill colour according to pulser box number
    crateLabelE[cra]->SetFillColor(19-cra);
    //crateLabelE[cra]->SetFillStyle(3008-cra);
    cratesE[cra]->cd();
    crateLabelE[cra]->Draw();

    string sW=Form("%d",15-(2*cra));
    crateLabelW[cra]->AddText(0.5,0.95,"Pulser");
    crateLabelW[cra]->AddText(0.5,0.8,"Box");
    crateLabelW[cra]->AddText(0.5,0.65,sW.c_str());
    crateLabelW[cra]->SetTextSize(0.25);
    //set fill colour according to pulser box number
    crateLabelW[cra]->SetFillColor(12+cra);
    //crateLabelE[cra]->SetFillStyle(3001+cra);
    cratesW[cra]->cd();
    crateLabelW[cra]->Draw();
  }
  MSG("LIAnalysis",Msg::kInfo)<<"... OK"<<endl;

  delete myplexhandle;
*/
  MSG("LIAnalysis",Msg::kInfo) 
    <<"PlotPlexPinMap method finished"<<endl;
}

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

void LIPlexMaps::PrintDbPinDiodeInfo()
{
  VldTimeStamp timeStamp;//now
  
  //get validity context for detector
  VldContext vldc(Detector::kFar,SimFlag::kData,timeStamp);
  
  DbiResultPtr<PlexRawChannelToPinDiode> rc2pdResPtr(vldc);

  cout<<"Num of PlexRawChannelToPinDiode rows="
      <<rc2pdResPtr.GetNumRows()<<endl;
  
  for (UInt_t irow = 0; irow < rc2pdResPtr.GetNumRows(); ++irow) {
    
    const PlexRawChannelToPinDiode* rc2pd = rc2pdResPtr.GetRow(irow);
    
    RawChannelId    rcid = rc2pd->GetRawChannelId();
    PlexPinDiodeId pinid = rc2pd->GetPlexPinDiodeId();

    cout<<"row="<<irow<<", rcid="<<this->GetElecString(rcid)
        <<", pinid="<<pinid<<", g="<<pinid.GetGain()
        <<", inbox="<<pinid.GetInBox()<<endl;
  }
  
  //print gain==0
  cout<<"gain==0"<<endl;
  for (UInt_t irow = 0; irow < rc2pdResPtr.GetNumRows(); ++irow) {
    
    const PlexRawChannelToPinDiode* rc2pd = rc2pdResPtr.GetRow(irow);
    
    RawChannelId    rcid = rc2pd->GetRawChannelId();
    PlexPinDiodeId pinid = rc2pd->GetPlexPinDiodeId();

    if (pinid.GetGain()==0){
      cout<<"row="<<irow<<", rcid="<<this->GetElecString(rcid)
          <<", pinid="<<pinid<<", g="<<pinid.GetGain()
        //<<", inbox="<<pinid.GetInBox()
          <<endl;
    }
  }

  //print gain==1
  cout<<"gain==1"<<endl;
  for (UInt_t irow = 0; irow < rc2pdResPtr.GetNumRows(); ++irow) {
    
    const PlexRawChannelToPinDiode* rc2pd = rc2pdResPtr.GetRow(irow);
    
    RawChannelId    rcid = rc2pd->GetRawChannelId();
    PlexPinDiodeId pinid = rc2pd->GetPlexPinDiodeId();

    if (pinid.GetGain()==1){
      cout<<"row="<<irow<<", rcid="<<this->GetElecString(rcid)
          <<", pinid="<<pinid<<", g="<<pinid.GetGain()
        //<<", inbox="<<pinid.GetInBox()
          <<endl;
    }
  }

}

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

void LIPlexMaps::PrintPlexPinDiodeInfo(Int_t detectorType)
{
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Running PrintPlexPinDiodeInfo method..."<<endl;

  //set validity context to todays date and real data
  //VldTimeStamp timeStamp(2002,9,14,1,1,1,1,0,0);
  VldTimeStamp timeStamp;//now
  //VldTimeStamp timeStamp(2003,8,17,1,1,1,1,0,0);
  //  VldTimeStamp timeStamp(2003,3,1,1,1,1,1,0,0);

  //get validity context for detector
  VldContext* validityContext;
  if (detectorType==Detector::kFar){
    validityContext=new VldContext(Detector::kFar,SimFlag::kData,
                                   timeStamp);
  }
  else if (detectorType==Detector::kCalDet){
    validityContext=new VldContext(Detector::kCalDet,SimFlag::kData,
                                   timeStamp);
  }
  else if (detectorType==Detector::kNear){
    validityContext=new VldContext(Detector::kNear,SimFlag::kData,
                                   timeStamp);
  }
  else{
    MSG("LIPlexMaps",Msg::kError)
      <<"Detector type not known = "<<detectorType
      <<endl<<"Program will exit here!"<<endl;
    exit(1);
  }

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Using validity context: "<<validityContext->AsString()<<endl;

  //create a plex handle to access the database
  PlexHandle *plexHandle=new PlexHandle(*validityContext);   

  //get list of leds with given validity context
  LedIdList leds(*validityContext);
  LedIdList::iterator ledId=leds.begin();

  //leave a line
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl
    <<"The pin diode information in the plex is as follows"<<endl
    <<"The electronics information is in descending hierarchial order"
    <<endl
    <<"(x:y) is pulser box x and led y"<<endl
    <<"e.g. (crate,varc,vmm,vfb,VA chip,VA channel)"<<endl<<endl;

  //start to loop over leds
  while (ledId!=leds.end()){
    
    if (!(*ledId).IsValid()){
      MSG("LIPlexMaps",Msg::kWarning)
        <<"LedId not valid = "<<ledId->AsString()<<endl;
    }
    
    //create a pair to hold the two possible pin diode ids
    pair<PlexPinDiodeId,PlexPinDiodeId> plexPins=plexHandle->
      GetPinDiodeIds(*ledId);
  
    //first is gain=1, second is gain=0
    MSG("LIPlexMaps",Msg::kVerbose) 
      <<"first pin gain="<<plexPins.first.GetGain()
      <<", second pin gain="<<plexPins.second.GetGain()<<endl;
  
    //get the two planes associated with the pin diodes
    pair<Int_t,Int_t> pin1Planes=fLookup.GetPinDiodePlanes
      (plexPins.first,plexHandle);
    pair<Int_t,Int_t> pin2Planes=fLookup.GetPinDiodePlanes
      (plexPins.second,plexHandle);

    //get the raw channel ids of the pins
    pair<RawChannelId,RawChannelId> rawChanIds;
    rawChanIds.first=plexHandle->GetRawChannelId(plexPins.first);
    rawChanIds.second=plexHandle->GetRawChannelId(plexPins.second);
    
    //create the planes string 
    //either 1 or 2 planes depending on whether shared pmt is used
    string sPlane1=Form("%d",pin1Planes.first);
    string sPlane2=Form("%d",pin1Planes.second);

    string sPin1Planes="  Planes="+sPlane1+"&"+sPlane2;
    if (pin1Planes.second==-1){
      sPin1Planes="  Plane="+sPlane1;
    }

    sPlane1=Form("%d",pin2Planes.first);
    sPlane2=Form("%d",pin2Planes.second);
    string sPin2Planes="  Planes="+sPlane1+"&"+sPlane2;
    if (pin2Planes.second==-1){
      sPin2Planes="  Plane="+sPlane1;
    }

    MSG("LIPlexMaps",Msg::kInfo)
      <<endl
      <<"("<<ledId->GetPulserBox()<<":"<<ledId->GetLedInBox()<<")"
      <<"  Pin1="<<this->GetElecString(rawChanIds.first)
      <<"="<<rawChanIds.first.GetChAdd()
      <<"  MUX BOX: E/W="<<plexPins.first.GetEastWest()
      <<", rLevel="<<plexPins.first.GetRackLevel()
      <<", rBay="<<plexPins.first.GetRackBay()
      <<", inRack="<<plexPins.first.GetInRack()
      <<sPin1Planes
      <<endl
      //now pin2
      <<"("<<ledId->GetPulserBox()<<":"<<ledId->GetLedInBox()<<")"
      <<"  Pin2="<<this->GetElecString(rawChanIds.second)
      <<"="<<rawChanIds.second.GetChAdd()
      <<"  MUX BOX: E/W="<<plexPins.second.GetEastWest()
      <<", rLevel="<<plexPins.second.GetRackLevel()
      <<", rBay="<<plexPins.second.GetRackBay()
      <<", inRack="<<plexPins.second.GetInRack()
      <<sPin2Planes
      <<endl;

    ledId++;
  }
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the PrintPlexPinDiodeInfo method ** " 
    <<endl;
}

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

string LIPlexMaps::GetElecString(RawChannelId rChId)
{
  MSG("LISummarySorter",Msg::kVerbose) 
    <<"Running GetElecString method..."<<endl;

  string elecString="";
  string sCrate=Form("%d",rChId.GetCrate());
  string sElecType=ElecType::AsString(rChId.GetElecType());

  if (rChId.GetElecType()==ElecType::kVA){
    string sVarc=Form("%d",rChId.GetVarcId());
    string sVmm=Form("%d",rChId.GetVmm());
    string sVfb=Form("%d",rChId.GetVaAdcSel());
    string sChip=Form("%d",rChId.GetVaChip());
    string sChannel=Form("%d",rChId.GetVaChannel());

    elecString=sElecType+
      "("+sCrate+","+sVarc+","+sVmm+","+sVfb+","+sChip+","+sChannel+")";
  }     
  else if (rChId.GetElecType()==ElecType::kQIE){
    string sGeoAdd=Form("%d",rChId.GetGeographicAddress());
    string sMaster=Form("%d",rChId.GetMasterChannel());
    string sMinder=Form("%d",rChId.GetMinderChannel());
        
    elecString=sElecType+
      "("+sCrate+","+sGeoAdd+","+sMaster+","+sMinder+")";
  }
  return elecString;
}

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

void LIPlexMaps::PlotPlexStripMap(Int_t detectorType)
{
  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Running PlotPlexStripMap method..."<<endl;

  Int_t planeMax=-1;
  Int_t planeMin=-1;

  planeMin=FIRSTSCINTPLANE-2;
  planeMax=LASTSCINTPLANE+5;

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200 for fardet;
  const Int_t bins=lastStripBin-firstStripBin;

  //set validity context to todays date and far detector and real data
  //VldTimeStamp timeStamp(2002,9,14,1,1,1,1,0,0);
  //VldTimeStamp timeStamp(2003,8,17,1,1,1,1,0,0);
  VldTimeStamp timeStamp(2001,7,1,1,1,1,1,0,0);
  //VldTimeStamp timeStamp;//now

  VldContext* validityContext;

  if (detectorType==Detector::kFar){
    validityContext=new VldContext(Detector::kFar,
                                   SimFlag::kData,timeStamp);
  }
  else if (detectorType==Detector::kCalDet){
    validityContext=new VldContext(Detector::kCalDet,
                                   SimFlag::kData,timeStamp);
  }
  else if (detectorType==Detector::kNear){
    validityContext=new VldContext(Detector::kNear,
                                   SimFlag::kData,timeStamp);
  }
  else{
    MSG("LIPlexMaps",Msg::kError)
      <<"Detector type not known = "<<detectorType
      <<endl<<"Program will exit here!"<<endl;
    exit(1);
  }

  MSG("LIPlexMaps",Msg::kInfo) 
    <<"Using validity context: "<<validityContext->AsString()<<endl;

  PlexHandle *plexhandle=new PlexHandle(*validityContext);   

  TH2F *hStripVsPlaneLed=new TH2F("hStripVsPlaneLed",
                                   "Led (StripEnd=kNeg=kEast)",
                                   planeMax-planeMin,
                                   planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlaneLed->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneLed->GetXaxis()->CenterTitle();
  hStripVsPlaneLed->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneLed->GetYaxis()->CenterTitle();
  hStripVsPlaneLed->SetFillColor(0);
  //hStripVsPlaneLed->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlanePix=new TH2F("hStripVsPlanePix",
                                   "Pixel (StripEnd=kNeg=kEast)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlanePix->GetXaxis()->SetTitle("Plane");
  hStripVsPlanePix->GetXaxis()->CenterTitle();
  hStripVsPlanePix->GetYaxis()->SetTitle("Strip");
  hStripVsPlanePix->GetYaxis()->CenterTitle();
  hStripVsPlanePix->SetFillColor(0);
  hStripVsPlanePix->SetMinimum(-2);
  //hStripVsPlanePix->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneCrate=new TH2F("hStripVsPlaneCrate",
                                     "Crate (StripEnd=kNeg=kEast)",
                                     planeMax-planeMin,planeMin,
                                    planeMax,
                                     bins,firstStripBin,lastStripBin);
  hStripVsPlaneCrate->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneCrate->GetXaxis()->CenterTitle();
  hStripVsPlaneCrate->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneCrate->GetYaxis()->CenterTitle();
  hStripVsPlaneCrate->SetFillColor(0);
  hStripVsPlaneCrate->SetMinimum(-2);
  //hStripVsPlaneCrate->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneVarc=new TH2F("hStripVsPlaneVarc",
                                    "Varc (StripEnd=kNeg=kEast)",
                                    planeMax-planeMin,planeMin,planeMax,
                                    bins,firstStripBin,lastStripBin);
  hStripVsPlaneVarc->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneVarc->GetXaxis()->CenterTitle();
  hStripVsPlaneVarc->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneVarc->GetYaxis()->CenterTitle();
  hStripVsPlaneVarc->SetFillColor(0);
  hStripVsPlaneVarc->SetMinimum(-2);
  //hStripVsPlaneVarc->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneVmm=new TH2F("hStripVsPlaneVmm",
                                   "Vmm (StripEnd=kNeg=kEast)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlaneVmm->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneVmm->GetXaxis()->CenterTitle();
  hStripVsPlaneVmm->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneVmm->GetYaxis()->CenterTitle();
  hStripVsPlaneVmm->SetFillColor(0);
  hStripVsPlaneVmm->SetMinimum(-2);
  //hStripVsPlaneVmm->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneVfb=new TH2F("hStripVsPlaneVfb",
                                   "Vfb (StripEnd=kNeg=kEast)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlaneVfb->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneVfb->GetXaxis()->CenterTitle();
  hStripVsPlaneVfb->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneVfb->GetYaxis()->CenterTitle();
  hStripVsPlaneVfb->SetFillColor(0);
  hStripVsPlaneVfb->SetMinimum(-2);
  //hStripVsPlaneVfb->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneVaChip=new TH2F("hStripVsPlaneVaChip",
                                  "VA Chip (StripEnd=kNeg=kEast)",
                                  planeMax-planeMin,planeMin,planeMax,
                                  bins,firstStripBin,lastStripBin);
  hStripVsPlaneVaChip->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneVaChip->GetXaxis()->CenterTitle();
  hStripVsPlaneVaChip->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneVaChip->GetYaxis()->CenterTitle();
  hStripVsPlaneVaChip->SetFillColor(0);
  hStripVsPlaneVaChip->SetMinimum(-2);
  //hStripVsPlaneVaChip->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneCh=new TH2F("hStripVsPlaneCh",
                                  "VA Channel (StripEnd=kNeg=kEast)",
                                  planeMax-planeMin,planeMin,planeMax,
                                  bins,firstStripBin,lastStripBin);
  hStripVsPlaneCh->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneCh->GetXaxis()->CenterTitle();
  hStripVsPlaneCh->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneCh->GetYaxis()->CenterTitle();
  hStripVsPlaneCh->SetFillColor(0);
  hStripVsPlaneCh->SetMinimum(-2);
  //hStripVsPlaneCh->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneGeoAdd=new TH2F("hStripVsPlaneGeoAdd",
                                     "Geographic Address (StripEnd=kNeg=kEast)",
                                     planeMax-planeMin,planeMin,
                                     planeMax,
                                     bins,firstStripBin,lastStripBin);
  hStripVsPlaneGeoAdd->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneGeoAdd->GetXaxis()->CenterTitle();
  hStripVsPlaneGeoAdd->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneGeoAdd->GetYaxis()->CenterTitle();
  hStripVsPlaneGeoAdd->SetFillColor(0);
  hStripVsPlaneGeoAdd->SetMinimum(-2);
  //hStripVsPlaneGeoAdd->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneMasterCh=new TH2F("hStripVsPlaneMasterCh",
                                       "Master Channel (StripEnd=kNeg=kEast)",
                                        planeMax-planeMin,
                                        planeMin,planeMax,
                                        bins,
                                        firstStripBin,lastStripBin);
  hStripVsPlaneMasterCh->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneMasterCh->GetXaxis()->CenterTitle();
  hStripVsPlaneMasterCh->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneMasterCh->GetYaxis()->CenterTitle();
  hStripVsPlaneMasterCh->SetFillColor(0);
  hStripVsPlaneMasterCh->SetMinimum(-2);
  //hStripVsPlaneMasterCh->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneMinderCh=new TH2F("hStripVsPlaneMinderCh",
                                       "Minder Channel (StripEnd=kNeg=kEast)",
                                       planeMax-planeMin,
                                       planeMin,planeMax,
                                       bins,
                                       firstStripBin,lastStripBin);
  hStripVsPlaneMinderCh->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneMinderCh->GetXaxis()->CenterTitle();
  hStripVsPlaneMinderCh->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneMinderCh->GetYaxis()->CenterTitle();
  hStripVsPlaneMinderCh->SetFillColor(0);
  hStripVsPlaneMinderCh->SetMinimum(-2);
  //hStripVsPlaneMinderCh->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneSpot=new TH2F("hStripVsPlaneSpot",
                                   "Pixel Spot (StripEnd=kNeg=kEast)",
                                    planeMax-planeMin,planeMin,planeMax,
                                    bins,firstStripBin,lastStripBin);
  hStripVsPlaneSpot->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneSpot->GetXaxis()->CenterTitle();
  hStripVsPlaneSpot->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneSpot->GetYaxis()->CenterTitle();
  hStripVsPlaneSpot->SetFillColor(0);
  hStripVsPlaneSpot->SetMinimum(-2);
  //hStripVsPlaneSpot->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlaneEnt=new TH2F("hStripVsPlaneEnt",
                                  "Number Entries (StripEnd=kNeg=kEast)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlaneEnt->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneEnt->GetXaxis()->CenterTitle();
  hStripVsPlaneEnt->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneEnt->GetYaxis()->CenterTitle();
  hStripVsPlaneEnt->SetFillColor(0);
  hStripVsPlaneEnt->SetMinimum(-2);
  //hStripVsPlaneEnt->SetBit(TH1::kCanRebin);

  //histos for the second side
  TH2F *hStripVsPlane2Led=new TH2F("hStripVsPlane2Led",
                                    "Led (StripEnd=kPos=kWest)",
                                   planeMax-planeMin,
                                   planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlane2Led->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Led->GetXaxis()->CenterTitle();
  hStripVsPlane2Led->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Led->GetYaxis()->CenterTitle();
  hStripVsPlane2Led->SetFillColor(0);
  //hStripVsPlane2Led->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Pix=new TH2F("hStripVsPlane2Pix",
                                   "Pixel (StripEnd=kPos=kWest)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlane2Pix->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Pix->GetXaxis()->CenterTitle();
  hStripVsPlane2Pix->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Pix->GetYaxis()->CenterTitle();
  hStripVsPlane2Pix->SetFillColor(0);
  hStripVsPlane2Pix->SetMinimum(-2);
  //hStripVsPlane2Pix->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Crate=new TH2F("hStripVsPlane2Crate",
                                     "Crate (StripEnd=kPos=kWest)",
                                     planeMax-planeMin,planeMin,planeMax,
                                     bins,firstStripBin,lastStripBin);
  hStripVsPlane2Crate->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Crate->GetXaxis()->CenterTitle();
  hStripVsPlane2Crate->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Crate->GetYaxis()->CenterTitle();
  hStripVsPlane2Crate->SetFillColor(0);
  hStripVsPlane2Crate->SetMinimum(-2);
  //hStripVsPlane2Crate->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Varc=new TH2F("hStripVsPlane2Varc",
                                    "Varc (StripEnd=kPos=kWest)",
                                    planeMax-planeMin,planeMin,planeMax,
                                    bins,firstStripBin,lastStripBin);
  hStripVsPlane2Varc->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Varc->GetXaxis()->CenterTitle();
  hStripVsPlane2Varc->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Varc->GetYaxis()->CenterTitle();
  hStripVsPlane2Varc->SetFillColor(0);
  hStripVsPlane2Varc->SetMinimum(-2);
  //hStripVsPlane2Varc->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Vmm=new TH2F("hStripVsPlane2Vmm",
                                   "Vmm (StripEnd=kPos=kWest)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlane2Vmm->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Vmm->GetXaxis()->CenterTitle();
  hStripVsPlane2Vmm->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Vmm->GetYaxis()->CenterTitle();
  hStripVsPlane2Vmm->SetFillColor(0);
  hStripVsPlane2Vmm->SetMinimum(-2);
  //hStripVsPlane2Vmm->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Vfb=new TH2F("hStripVsPlane2Vfb",
                                   "Vfb (StripEnd=kPos=kWest)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlane2Vfb->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Vfb->GetXaxis()->CenterTitle();
  hStripVsPlane2Vfb->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Vfb->GetYaxis()->CenterTitle();
  hStripVsPlane2Vfb->SetFillColor(0);
  hStripVsPlane2Vfb->SetMinimum(-2);
  //hStripVsPlane2Vfb->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2VaChip=new TH2F("hStripVsPlane2VaChip",
                                  "Va Chip(StripEnd=kPos=kWest)",
                                  planeMax-planeMin,planeMin,planeMax,
                                  bins,firstStripBin,lastStripBin);
  hStripVsPlane2VaChip->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2VaChip->GetXaxis()->CenterTitle();
  hStripVsPlane2VaChip->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2VaChip->GetYaxis()->CenterTitle();
  hStripVsPlane2VaChip->SetFillColor(0);
  hStripVsPlane2VaChip->SetMinimum(-2);
  //hStripVsPlane2VaChip->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Ch=new TH2F("hStripVsPlane2Ch",
                                  "VA Channel (StripEnd=kPos=kWest)",
                                  planeMax-planeMin,planeMin,planeMax,
                                  bins,firstStripBin,lastStripBin);
  hStripVsPlane2Ch->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Ch->GetXaxis()->CenterTitle();
  hStripVsPlane2Ch->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Ch->GetYaxis()->CenterTitle();
  hStripVsPlane2Ch->SetFillColor(0);
  hStripVsPlane2Ch->SetMinimum(-2);
  //hStripVsPlane2Ch->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2GeoAdd=new TH2F("hStripVsPlane2GeoAdd",
                                      "Geographic Address (StripEnd=kPos=kWest)",
                                      planeMax-planeMin,
                                      planeMin,planeMax,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlane2GeoAdd->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2GeoAdd->GetXaxis()->CenterTitle();
  hStripVsPlane2GeoAdd->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2GeoAdd->GetYaxis()->CenterTitle();
  hStripVsPlane2GeoAdd->SetFillColor(0);
  hStripVsPlane2GeoAdd->SetMinimum(-2);
  //hStripVsPlane2GeoAdd->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2MasterCh=new TH2F("hStripVsPlane2MasterCh",
                                        "Master Channel (StripEnd=kPos=kWest)",
                                        planeMax-planeMin,
                                        planeMin,planeMax,
                                        bins,
                                        firstStripBin,lastStripBin);
  hStripVsPlane2MasterCh->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2MasterCh->GetXaxis()->CenterTitle();
  hStripVsPlane2MasterCh->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2MasterCh->GetYaxis()->CenterTitle();
  hStripVsPlane2MasterCh->SetFillColor(0);
  hStripVsPlane2MasterCh->SetMinimum(-2);
  //hStripVsPlane2MasterCh->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2MinderCh=new TH2F("hStripVsPlane2MinderCh",
                                        "Minder Channel (StripEnd=kPos=kWest)",
                                        planeMax-planeMin,planeMin,
                                        planeMax,
                                        bins,firstStripBin,
                                        lastStripBin);
  hStripVsPlane2MinderCh->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2MinderCh->GetXaxis()->CenterTitle();
  hStripVsPlane2MinderCh->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2MinderCh->GetYaxis()->CenterTitle();
  hStripVsPlane2MinderCh->SetFillColor(0);
  hStripVsPlane2MinderCh->SetMinimum(-2);
  //hStripVsPlane2MinderCh->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Spot=new TH2F("hStripVsPlane2Spot",
                                    "Pixel Spot (StripEnd=kPos=kWest)",
                                    planeMax-planeMin,planeMin,planeMax,
                                    bins,firstStripBin,lastStripBin);
  hStripVsPlane2Spot->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Spot->GetXaxis()->CenterTitle();
  hStripVsPlane2Spot->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Spot->GetYaxis()->CenterTitle();
  hStripVsPlane2Spot->SetFillColor(0);
  hStripVsPlane2Spot->SetMinimum(-2);
  //hStripVsPlane2Spot->SetBit(TH1::kCanRebin);

  TH2F *hStripVsPlane2Ent=new TH2F("hStripVsPlane2Ent",
                                   "Number Entries (StripEnd=kPos=kWest)",
                                   planeMax-planeMin,planeMin,planeMax,
                                   bins,firstStripBin,lastStripBin);
  hStripVsPlane2Ent->GetXaxis()->SetTitle("Plane");
  hStripVsPlane2Ent->GetXaxis()->CenterTitle();
  hStripVsPlane2Ent->GetYaxis()->SetTitle("Strip");
  hStripVsPlane2Ent->GetYaxis()->CenterTitle();
  hStripVsPlane2Ent->SetFillColor(0);
  hStripVsPlane2Ent->SetMinimum(-2);
  //hStripVsPlane2Ent->SetBit(TH1::kCanRebin);

  //create the plex plane id for use below
  PlexPlaneId* planeId;


  for (Int_t pl=planeMin;pl<planeMax;pl++){

    //get the plane ids
    if (detectorType==Detector::kFar){
      planeId=new PlexPlaneId(Detector::kFar,pl);
    }
    else if (detectorType==Detector::kCalDet){
      planeId=new PlexPlaneId(Detector::kCalDet,pl);
    }
    else{
      planeId=new PlexPlaneId(Detector::kNear,pl);
    }

    MSG("LIPlexMaps",Msg::kInfo) 
      <<"pl="<<pl<<", gPl="<<planeId->GetPlane()
      <<", view="<<planeId->GetPlaneView()
      <<", valid="<<planeId->IsValid()
      <<endl;

    for (Int_t st=-1;st<NUMSTRIPS+2;st++){
      for (Int_t se=0;se<NUMSIDES;se++){

        //create the strip end type
        StripEnd::EStripEnd stripEnd = StripEnd::kUnknown;
        
        //set the strip end type
        if (se==0) stripEnd=StripEnd::kEast;//FD=kNeg
        else if (se==1) stripEnd=StripEnd::kWest;//ND=kPos

        //Generate strip end id      
        PlexStripEndId stripEndId(*planeId,st,stripEnd);    
  
        //get led and pixel ids from strip end
        PlexLedId ledId=plexhandle->GetLedId(stripEndId);
        PlexPixelSpotId pixelId=plexhandle->GetPixelSpotId(stripEndId);

        Int_t crate=plexhandle->GetRawChannelId(stripEndId).
          GetCrate();
        Int_t varc=plexhandle->GetRawChannelId(stripEndId).GetVarcId();
        Int_t vmm=plexhandle->GetRawChannelId(stripEndId).GetVmm();
        Int_t vfb=plexhandle->GetRawChannelId(stripEndId).GetVaAdcSel();
        Int_t vaChip=plexhandle->GetRawChannelId(stripEndId).GetVaChip();
        Int_t ch=plexhandle->GetRawChannelId(stripEndId).GetVaChannel();

        Int_t masterCh=plexhandle->GetRawChannelId(stripEndId).
          GetMasterChannel();
        Int_t minderCh=plexhandle->GetRawChannelId(stripEndId).
          GetMinderChannel();
        Int_t geoAdd=plexhandle->GetRawChannelId(stripEndId).
          GetGeographicAddress();

        if (geoAdd>60000) geoAdd=-1;
        if (masterCh>60000) masterCh=-1;
        if (minderCh>60000) minderCh=-1;

        if (varc>60000) varc=-1;
        if (vmm>60000) vmm=-1;
        if (vfb>60000) vfb=-1;
        if (vaChip>60000) vaChip=-1;
        if (ch>60000) ch=-1;

        //get led and pixel from ids
        Int_t led=static_cast<Int_t>(ledId.GetLedInBox());
        Int_t pix=static_cast<Int_t>(pixelId.GetPixel());
        Int_t spot=pixelId.GetSpot();

        MSG("LIPlexMaps",Msg::kVerbose) 
          <<"st="<<st<<", gSt="<<stripEndId.GetStrip()
          <<", end="<<stripEndId.GetEnd()
          <<", val="<<stripEndId.IsValid()
          <<", gled="<<led
          <<", gpB="<<ledId.GetPulserBox()
          <<", val="<<ledId.IsValid()
          <<", pixel="<<pix
          <<", val="<<pixelId.IsValid()
          <<endl;

        if (se==0){
          //fill histograms
          hStripVsPlanePix->Fill(pl,st,pix);
          hStripVsPlaneSpot->Fill(pl,st,spot);
          hStripVsPlaneCrate->Fill(pl,st,crate);
          hStripVsPlaneVarc->Fill(pl,st,varc);
          hStripVsPlaneVmm->Fill(pl,st,vmm);
          hStripVsPlaneVfb->Fill(pl,st,vfb);
          hStripVsPlaneVaChip->Fill(pl,st,vaChip);
          hStripVsPlaneCh->Fill(pl,st,ch);
          hStripVsPlaneGeoAdd->Fill(pl,st,geoAdd);
          hStripVsPlaneMasterCh->Fill(pl,st,masterCh);
          hStripVsPlaneMinderCh->Fill(pl,st,minderCh);
          hStripVsPlaneLed->Fill(pl,st,led);
          hStripVsPlaneEnt->Fill(pl,st,1.);
        }
        else if (se==1){
          //fill histograms
          hStripVsPlane2Pix->Fill(pl,st,pix);
          hStripVsPlane2Spot->Fill(pl,st,spot);
          hStripVsPlane2Crate->Fill(pl,st,crate);
          hStripVsPlane2Varc->Fill(pl,st,varc);
          hStripVsPlane2Vmm->Fill(pl,st,vmm);
          hStripVsPlane2Vfb->Fill(pl,st,vfb);
          hStripVsPlane2VaChip->Fill(pl,st,vaChip);
          hStripVsPlane2Ch->Fill(pl,st,ch);
          hStripVsPlane2GeoAdd->Fill(pl,st,geoAdd);
          hStripVsPlane2MasterCh->Fill(pl,st,masterCh);
          hStripVsPlane2MinderCh->Fill(pl,st,minderCh);
          hStripVsPlane2Led->Fill(pl,st,led);
          hStripVsPlane2Ent->Fill(pl,st,1.);
        }
      }
    }
  }


  //get rid of the stats info
  gStyle->SetOptStat(0);

  Int_t draw=1;
  if (draw==1){
  TCanvas *cStripVsPlaneLed=new TCanvas
    ("cStripVsPlaneLed","StripVsPlane: Led",0,0,1000,800);
  cStripVsPlaneLed->SetFillColor(0);
  cStripVsPlaneLed->cd();
  hStripVsPlaneLed->Draw("colz");

  TCanvas *cStripVsPlanePix=new TCanvas
    ("cStripVsPlanePix","StripVsPlane: Pixel",0,0,1000,800);
  cStripVsPlanePix->SetFillColor(0);
  cStripVsPlanePix->cd();
  hStripVsPlanePix->Draw("textcolz");
  
  TCanvas *cStripVsPlaneCrate=new TCanvas
    ("cStripVsPlaneCrate","StripVsPlane: Crate",0,0,1000,800);
  cStripVsPlaneCrate->SetFillColor(0);
  cStripVsPlaneCrate->cd();
  hStripVsPlaneCrate->Draw("textcolz");

  TCanvas *cStripVsPlaneVarc=new TCanvas
    ("cStripVsPlaneVarc","StripVsPlane: Varc",0,0,1000,800);
  cStripVsPlaneVarc->SetFillColor(0);
  cStripVsPlaneVarc->cd();
  hStripVsPlaneVarc->Draw("textcolz");
 
  TCanvas *cStripVsPlaneVmm=new TCanvas
    ("cStripVsPlaneVmm","StripVsPlane: Vmm",0,0,1000,800);
  cStripVsPlaneVmm->SetFillColor(0);
  cStripVsPlaneVmm->cd();
  hStripVsPlaneVmm->Draw("textcolz");

  TCanvas *cStripVsPlaneVfb=new TCanvas
    ("cStripVsPlaneVfb","StripVsPlane: Vfb",0,0,1000,800);
  cStripVsPlaneVfb->SetFillColor(0);
  cStripVsPlaneVfb->cd();
  hStripVsPlaneVfb->Draw("textcolz");

  TCanvas *cStripVsPlaneVaChip=new TCanvas
    ("cStripVsPlaneVaChip","StripVsPlane: VaChip",0,0,1000,800);
  cStripVsPlaneVaChip->SetFillColor(0);
  cStripVsPlaneVaChip->cd();
  hStripVsPlaneVaChip->Draw("textcolz");

  TCanvas *cStripVsPlaneCh=new TCanvas
    ("cStripVsPlaneCh","StripVsPlane: Ch",0,0,1000,800);
  cStripVsPlaneCh->SetFillColor(0);
  cStripVsPlaneCh->cd();
  hStripVsPlaneCh->Draw("textcolz");

  TCanvas *cStripVsPlaneGeoAdd=new TCanvas
    ("cStripVsPlaneGeoAdd","StripVsPlane: GeoAdd",0,0,1000,800);
  cStripVsPlaneGeoAdd->SetFillColor(0);
  cStripVsPlaneGeoAdd->cd();
  hStripVsPlaneGeoAdd->Draw("textcolz");

  TCanvas *cStripVsPlaneMasterCh=new TCanvas
    ("cStripVsPlaneMasterCh","StripVsPlane: Master Channel",
     0,0,1000,800);
  cStripVsPlaneMasterCh->SetFillColor(0);
  cStripVsPlaneMasterCh->cd();
  hStripVsPlaneMasterCh->Draw("textcolz");

  }

  TCanvas *cStripVsPlaneMinderCh=new TCanvas
    ("cStripVsPlaneMinderCh","StripVsPlane: MinderCh",0,0,1000,800);
  cStripVsPlaneMinderCh->SetFillColor(0);
  cStripVsPlaneMinderCh->cd();
  hStripVsPlaneMinderCh->Draw("textcolz");

  TCanvas *cStripVsPlaneSpot=new TCanvas
    ("cStripVsPlaneSpot","StripVsPlane: Spot",0,0,1000,800);
  cStripVsPlaneSpot->SetFillColor(0);
  cStripVsPlaneSpot->cd();
  hStripVsPlaneSpot->Draw("textcolz");

  TCanvas *cStripVsPlaneEnt=new TCanvas
    ("cStripVsPlaneEnt","StripVsPlane: NumEntries",0,0,1000,800);
  cStripVsPlaneEnt->SetFillColor(0);
  cStripVsPlaneEnt->cd();
  hStripVsPlaneEnt->Draw("textcolz");
  

  //Draw the kPos=kWest side

  TCanvas *cStripVsPlane2Led=new TCanvas
    ("cStripVsPlane2Led","StripVsPlane2: Led",0,0,1000,800);
  cStripVsPlane2Led->SetFillColor(0);
  cStripVsPlane2Led->cd();
  hStripVsPlane2Led->Draw("colz");

  TCanvas *cStripVsPlane2Pix=new TCanvas
    ("cStripVsPlane2Pix","StripVsPlane2: Pixel",0,0,1000,800);
  cStripVsPlane2Pix->SetFillColor(0);
  cStripVsPlane2Pix->cd();
  hStripVsPlane2Pix->Draw("textcolz");
  
  TCanvas *cStripVsPlane2Crate=new TCanvas
    ("cStripVsPlane2Crate","StripVsPlane2: Crate",0,0,1000,800);
  cStripVsPlane2Crate->SetFillColor(0);
  cStripVsPlane2Crate->cd();
  hStripVsPlane2Crate->Draw("textcolz");

  TCanvas *cStripVsPlane2Varc=new TCanvas
    ("cStripVsPlane2Varc","StripVsPlane2: Varc",0,0,1000,800);
  cStripVsPlane2Varc->SetFillColor(0);
  cStripVsPlane2Varc->cd();
  hStripVsPlane2Varc->Draw("textcolz");
 
  TCanvas *cStripVsPlane2Vmm=new TCanvas
    ("cStripVsPlane2Vmm","StripVsPlane2: Vmm",0,0,1000,800);
  cStripVsPlane2Vmm->SetFillColor(0);
  cStripVsPlane2Vmm->cd();
  hStripVsPlane2Vmm->Draw("textcolz");

  TCanvas *cStripVsPlane2Vfb=new TCanvas
    ("cStripVsPlane2Vfb","StripVsPlane2: Vfb",0,0,1000,800);
  cStripVsPlane2Vfb->SetFillColor(0);
  cStripVsPlane2Vfb->cd();
  hStripVsPlane2Vfb->Draw("textcolz");

  TCanvas *cStripVsPlane2VaChip=new TCanvas
    ("cStripVsPlane2VaChip","StripVsPlane2: VaChip",0,0,1000,800);
  cStripVsPlane2VaChip->SetFillColor(0);
  cStripVsPlane2VaChip->cd();
  hStripVsPlane2VaChip->Draw("textcolz");

  TCanvas *cStripVsPlane2Ch=new TCanvas
    ("cStripVsPlane2Ch","StripVsPlane2: Ch",0,0,1000,800);
  cStripVsPlane2Ch->SetFillColor(0);
  cStripVsPlane2Ch->cd();
  hStripVsPlane2Ch->Draw("textcolz");

  TCanvas *cStripVsPlane2GeoAdd=new TCanvas
    ("cStripVsPlane2GeoAdd","StripVsPlane2: GeoAdd",0,0,1000,800);
  cStripVsPlane2GeoAdd->SetFillColor(0);
  cStripVsPlane2GeoAdd->cd();
  hStripVsPlane2GeoAdd->Draw("textcolz");

  TCanvas *cStripVsPlane2MasterCh=new TCanvas
    ("cStripVsPlane2MasterCh","StripVsPlane2: Master Channel",
     0,0,1000,800);
  cStripVsPlane2MasterCh->SetFillColor(0);
  cStripVsPlane2MasterCh->cd();
  hStripVsPlane2MasterCh->Draw("textcolz");

  TCanvas *cStripVsPlane2MinderCh=new TCanvas
    ("cStripVsPlane2MinderCh","StripVsPlane2: MinderCh",0,0,1000,800);
  cStripVsPlane2MinderCh->SetFillColor(0);
  cStripVsPlane2MinderCh->cd();
  hStripVsPlane2MinderCh->Draw("textcolz");

  TCanvas *cStripVsPlane2Spot=new TCanvas
    ("cStripVsPlane2Spot","StripVsPlane2: Spot",0,0,1000,800);
  cStripVsPlane2Spot->SetFillColor(0);
  cStripVsPlane2Spot->cd();
  hStripVsPlane2Spot->Draw("textcolz");

  TCanvas *cStripVsPlane2Ent=new TCanvas
    ("cStripVsPlane2Ent","StripVsPlane2: NumEntries",0,0,1000,800);
  cStripVsPlane2Ent->SetFillColor(0);
  cStripVsPlane2Ent->cd();
  hStripVsPlane2Ent->Draw("textcolz");
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the PlotPlexStripMap method ** " 
    <<endl;
}

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

void LIPlexMaps::MakePinPlexTables() 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakePinPlexTables() method... ** "
    <<endl; 
  
  //Thanks to Ryan for the DB code of this method
  
  //First fill the pin diode table
  VldTimeStamp farpinstart = VldTimeStamp(2000,1,1,12,0,0);
  VldTimeStamp farpinend = VldTimeStamp(2010,1,1,12,0,0);
  VldRange farpinvr(Detector::kFar,SimFlag::kData,farpinstart,
                    farpinend,"LIPlexMaps");
  VldTimeStamp create; // now!
  VldContext vc(Detector::kFar,SimFlag::kData,create);
  PlexHandle plexHandle(vc);

  for(Int_t pb=0;pb<NUMPULSERBOXES;pb++){
    for(Int_t led=1;led<=LASTPULSERBOX;led++){

      PlexLedId ledId(Detector::kFar,pb,led);

      int aggNo = 0x7ff & ledId.GetEncoded();

      DbiWriter<PlexPinDiodeToLed> writer(farpinvr,aggNo,0,create);

      std::pair<PlexPinDiodeId,PlexPinDiodeId> newPins=fLookup.
        GetPinDiodeIds(plexHandle,ledId.GetLedInBox());

      PlexPinDiodeToLed hpin2led(newPins.first.GetDetector(),
                                 newPins.first.GetElecType(),
                                 newPins.first.GetEastWest(),
                                 newPins.first.GetRackLevel(),
                                 newPins.first.GetRackBay(),
                                 newPins.first.GetInRack(),
                                 newPins.first.GetInBox(),
                                 newPins.first.GetGain(),
                                 ledId.GetPulserBox(),
                                 ledId.GetLedInBox());
      PlexPinDiodeToLed lpin2led(newPins.second.GetDetector(),
                                 newPins.second.GetElecType(),
                                 newPins.second.GetEastWest(),
                                 newPins.second.GetRackLevel(),
                                 newPins.second.GetRackBay(),
                                 newPins.second.GetInRack(),
                                 newPins.second.GetInBox(),
                                 newPins.second.GetGain(),
                                 ledId.GetPulserBox(),
                                 ledId.GetLedInBox());
      writer <<hpin2led;
      writer <<lpin2led;
      //writer.Close();
    }
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakePinPlexTables() method... ** "
    <<endl; 
}

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

void LIPlexMaps::MakeCalAdcToPe(string sGainsFileName,
                                Detector::Detector_t det,
                                SimFlag::ESimFlag simFlag,
                                VldTimeStamp vldStart,
                                VldTimeStamp vldEnd,
                                Int_t aggNo,
                                Int_t task,
                                Int_t aggStat[484],
                                VldTimeStamp creationDate,
                                std::string dbName,
                                std::string sLogComment,
                                Int_t gainTooHigh,Int_t gainCeiling,
                                Bool_t writeToDb)
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakeCalAdcToPe() method... **"<<endl; 

  //Thanks to Ryan for the DB code of this method  

  //Q: What about bookends?
  //A: Just don't put any data in database, can't calibrate steel!

  //Q: What about stripends with no info?
  //A: Use average of that pixel.

  //Q: What if no info for a pixel?
  //A: Use the average of nearest neighbours.

  //Q: What about pmts with no info?
  //A: Use spot from a pmt that is the average of the whole detector.

  //Q: What about really high gains? 
  //A: Set error of gains over "gainTooHigh" to a high value.
  //   For gains over gainCeiling set gain to equal gainCeiling.
  //   Set the error to that for gainTooHigh.

  //Q: What to do about errors in above cases?
  //A: The errors are set to values that represent the worse case,
  //   where you had a two pmts from the tails of the distributions.

  //Q: Where to store the special values of the errors?
  //A: Somewhere proper eventually, but for now in cvs!

  //Q: What 1PE width to use?
  //A: The 1PE width that corresponds to the 0.8 in the gain calc
  //   is 0.5 of the gain. So just times gain by 0.5.

  //Q: How is the error calculated?
  //A: It is the sum of the relative errors of rms*rms/mean
  //   but does not include the error on the 0.8 factor.

  //Q: What validity range should be used?
  //A: For the first pass the validity is for the lifetime of the det.

  //Q: How would the aggregate tables be done?
  //A: There is a switch (aggNo). The default is "-1" for the non-aggregate tables.
  //   Otherwise, the tables are aggregated with the crate or the numericMuxBox
  //   unless aggStat of each crate or numericMuxBox has a negative value.

  //some old validities
  //VldTimeStamp fvldstart(102,9,14,15,0,1,0);   // T11 (Far-Far) 2002
  //VldTimeStamp fvldend(102,10,2,0,0,0,0);   // T11 (Far-Far)2002
  //VldTimeStamp fvldstart(102,6,6,0,0,0,0);  // T7 June 2002
  //VldTimeStamp fvldend(102,6,30,0,0,0,0);  // T7 June 2002
  //VldTimeStamp fvldstart=VldTimeStamp(2002,10,2,0,0,1); //T7 Oct 2002
  //VldTimeStamp fvldend=VldTimeStamp(2002,10,18,0,0,0);  //T7 Oct 2002
  //VldTimeStamp fvldstart=VldTimeStamp(2003,9,26,0,0,1); //T7 ND 2003
  //VldTimeStamp fvldend=VldTimeStamp(2003,10,8,0,0,1);  //T7 ND 2003

  //only do this once to set up variables
  this->SetDetector(det);

  //get a plex handle
  MSG("LIPlexMaps",Msg::kInfo)<<"Getting plex handle..."<<endl;
  VldContext vldCtx(det,SimFlag::kData,creationDate);
  PlexHandle plexHandle(vldCtx);

  gStyle->SetOptStat(1111111);

  TH1F *hGain=new TH1F("hGain","PMT Gains",300,-1,gainTooHigh);
  hGain->GetXaxis()->SetTitle("PMT Gain");
  hGain->GetXaxis()->CenterTitle();
  hGain->GetYaxis()->SetTitle("");
  hGain->GetYaxis()->CenterTitle();
  hGain->SetLineColor(2);
  hGain->SetFillStyle(3015);
  hGain->SetFillColor(2);
  hGain->SetLineWidth(2);
  //hGain->SetBit(TH1::kCanRebin);

  TH1F *hGainHighPmt=new TH1F("hGainHighPmt","PMT Gains: HighPmts",
          100,gainTooHigh,gainCeiling+5);
  hGainHighPmt->GetXaxis()->SetTitle("PMT Gain");
  hGainHighPmt->GetXaxis()->CenterTitle();
  hGainHighPmt->GetYaxis()->SetTitle("");
  hGainHighPmt->GetYaxis()->CenterTitle();
  hGainHighPmt->SetLineColor(2);
  hGainHighPmt->SetFillStyle(3015); 
  hGainHighPmt->SetFillColor(2); 
  hGainHighPmt->SetLineWidth(2);
  //hGainHighPmt->SetBit(TH1::kCanRebin);

  TH1F *hGainCrazyHighPmt=new TH1F("hGainCrazyHighPmt",
          "PMT Gains: CrazyHighPmts",
          200,gainCeiling,gainCeiling+100);
  hGainCrazyHighPmt->GetXaxis()->SetTitle("PMT Gain");
  hGainCrazyHighPmt->GetXaxis()->CenterTitle();
  hGainCrazyHighPmt->GetYaxis()->SetTitle("");
  hGainCrazyHighPmt->GetYaxis()->CenterTitle();
  hGainCrazyHighPmt->SetLineColor(2);
  hGainCrazyHighPmt->SetFillStyle(3015); 
  hGainCrazyHighPmt->SetFillColor(2); 
  hGainCrazyHighPmt->SetLineWidth(2);
  hGainCrazyHighPmt->SetBit(TH1::kCanRebin);

  TH1F *hGainAvDet=new TH1F("hGainAvDet","PMT Gains in Av Detector PMT",
          100,55,85);
  hGainAvDet->GetXaxis()->SetTitle("PMT Gain");
  hGainAvDet->GetXaxis()->CenterTitle();
  hGainAvDet->GetYaxis()->SetTitle("");
  hGainAvDet->GetYaxis()->CenterTitle();
  hGainAvDet->SetLineColor(2);
  hGainAvDet->SetFillStyle(3015); 
  hGainAvDet->SetFillColor(2); 
  hGainAvDet->SetLineWidth(2);
  hGainAvDet->SetBit(TH1::kCanRebin);

  TH1F *hGainErr=new TH1F("hGainErr","PMT GainErrs",
          400,0,110);
  hGainErr->GetXaxis()->SetTitle("PMT GainErr");
  hGainErr->GetXaxis()->CenterTitle();
  hGainErr->GetYaxis()->SetTitle("");
  hGainErr->GetYaxis()->CenterTitle();
  hGainErr->SetLineColor(2);
  hGainErr->SetFillStyle(3015); 
  hGainErr->SetFillColor(2); 
  hGainErr->SetLineWidth(5);
  hGainErr->SetBit(TH1::kCanRebin);

  TH1F *hGainErrZoom=new TH1F("hGainErrZoom","PMT GainErrs (Zoomed)",
          400,0,10);
  hGainErrZoom->GetXaxis()->SetTitle("PMT GainErrZoom");
  hGainErrZoom->GetXaxis()->CenterTitle();
  hGainErrZoom->GetYaxis()->SetTitle("");
  hGainErrZoom->GetYaxis()->CenterTitle();
  hGainErrZoom->SetLineColor(2);
  hGainErrZoom->SetFillStyle(3015); 
  hGainErrZoom->SetFillColor(2); 
  hGainErrZoom->SetLineWidth(2);
  //hGainErrZoom->SetBit(TH1::kCanRebin);

  TH1F *hGainErrFract=new TH1F("hGainErrFract",
          "Fractional PMT GainErrs",
          800,0.005,0.05);
  hGainErrFract->GetXaxis()->SetTitle("Fractional PMT GainErr");
  hGainErrFract->GetXaxis()->CenterTitle();
  hGainErrFract->GetYaxis()->SetTitle("");
  hGainErrFract->GetYaxis()->CenterTitle();
  hGainErrFract->SetLineColor(2);
  hGainErrFract->SetFillStyle(3015); 
  hGainErrFract->SetFillColor(2); 
  hGainErrFract->SetLineWidth(2);
  //hGainErrFract->SetBit(TH1::kCanRebin);

  TH1F *hSPEWidth=new TH1F("hSPEWidth","PMT SPEWidths",
          300,0,gainCeiling/2+5);
  hSPEWidth->GetXaxis()->SetTitle("PMT SPEWidth");
  hSPEWidth->GetXaxis()->CenterTitle();
  hSPEWidth->GetYaxis()->SetTitle("");
  hSPEWidth->GetYaxis()->CenterTitle();
  hSPEWidth->SetLineColor(2);
  hSPEWidth->SetFillStyle(3015); 
  hSPEWidth->SetFillColor(2); 
  hSPEWidth->SetLineWidth(2);
  //hSPEWidth->SetBit(TH1::kCanRebin);

  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,det);

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;

  TH2F **hStripVsPlaneGain=0;
  hStripVsPlaneGain= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gains (Crate "+sPb+")";
    hStripVsPlaneGain[i]=new TH2F(fS.c_str(),fS.c_str(),
          planeMax[i]-planeMin[i],
          planeMin[i],planeMax[i],
          bins,firstStripBin,lastStripBin);
    hStripVsPlaneGain[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneGain[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneGain[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneGain[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneGain[i]->SetFillColor(0);
    //hStripVsPlaneGain[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneGainErr=0;
  hStripVsPlaneGainErr= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gain Errors (Crate "+sPb+")";
    hStripVsPlaneGainErr[i]=new TH2F(fS.c_str(),fS.c_str(),
             planeMax[i]-planeMin[i],
             planeMin[i],planeMax[i],
             bins,firstStripBin,lastStripBin);
    hStripVsPlaneGainErr[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneGainErr[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneGainErr[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneGainErr[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneGainErr[i]->SetFillColor(0);
    //hStripVsPlaneGainErr[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneSPEWidth=0;
  hStripVsPlaneSPEWidth= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Single PE Width (Crate "+sPb+")";
    hStripVsPlaneSPEWidth[i]=new TH2F(fS.c_str(),fS.c_str(),
             planeMax[i]-planeMin[i],
             planeMin[i],planeMax[i],
             bins,firstStripBin,lastStripBin);
    hStripVsPlaneSPEWidth[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneSPEWidth[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneSPEWidth[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneSPEWidth[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneSPEWidth[i]->SetFillColor(0);
    //hStripVsPlaneSPEWidth[i]->SetBit(TH1::kCanRebin);
  }

  vector<Float_t> vGains(NUMPLANES*NUMSTRIPS*NUMENDS,0);
  vector<Float_t> vGainErrs(NUMPLANES*NUMSTRIPS*NUMENDS,0);
  vector<Float_t> vSPEWidths(NUMPLANES*NUMSTRIPS*NUMENDS,0);
  vector<Float_t> vSPEWidthErrs(NUMPLANES*NUMSTRIPS*NUMENDS,0);
  map<UInt_t,LIPmt> pmts;
  LIPmt avDetPmt;
  avDetPmt.Initialise(NUMPIXELS,NUMPIXELSPOTS);

  //variables to hold the average for whole detector
  Double_t gainAvDet=0;
  Double_t gainErrAvDet=0;
  Int_t gainNum=0;

  Float_t gainErrUnknownPixelSpot=10;//reflect variation in a pixel
  Float_t gainErrUnknownPixel=40;//reflect variation between NN
  Float_t gainErrUnknownNN=50;//reflect variation between worst pixels
  Float_t gainErrUnknownPmt=100;//reflect variations between worst pmts
  Float_t gainErrTooHighGain=90;//if cut is 150, ie could be 60
  Float_t SPEWidthFraction=0.5;//corresponds to the 0.8 used in gain 

  //open the file  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Opening file "<<sGainsFileName<<"..."<<endl;
  ifstream gainsFile(sGainsFileName.c_str());

  //check if file exists
  if (gainsFile){

    //variables to hold input from file
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    Float_t gain=-1;
    Float_t gainErr=-1;
    Float_t SPEWidth=-1;

    //printing control
    Int_t lastPlane=-1;

    //read in from the text file and fill objects
    while(gainsFile>>plane>>strip>>end>>gain>>gainErr>>SPEWidth) {

      Int_t seIndex=plane*NUMSTRIPS*NUMENDS+strip*NUMENDS+end-1;

      if (plane<FIRSTPLANE || plane>LASTPLANE || strip<FIRSTSTRIP || 
          strip>LASTSTRIP || end<FIRSTEND || end>LASTEND) {
        MSG("LIPlexMaps",Msg::kWarning)
          <<"Plane, strip or stripend are out of range: plane="<<plane
          <<", strip="<<strip<<", end="<<end<<endl
          <<"Detector type is set to "<<Detector::AsString(det)
          <<endl
          <<"Program will exit here..."<<endl;
        exit(1);
      }

      //print stuff
      if (plane!=lastPlane && plane%20==0) {
        MSG("LIPlexMaps",Msg::kInfo)<<"New plane="<<plane<<endl;
      }
      else if (plane!=lastPlane){
        MSG("LIPlexMaps",Msg::kDebug)<<"New plane="<<plane<<endl;
      }
      lastPlane=plane;

      //put file gains into vectors
      vGains[seIndex]=gain;
      vGainErrs[seIndex]=gainErr;
      vSPEWidths[seIndex]=SPEWidth;
      vSPEWidthErrs[seIndex]=0.5;

      //sanity check
      if (gain>-1 && gain<2){
        MSG("LIPlexMaps",Msg::kWarning)
          <<"What sort of gain is this? gain="<<gain<<endl;
      }

      //get stripend id
      PlexStripEndId seid(det,plane,strip,
        static_cast<StripEnd::EStripEnd>(end));
      //get pixel spot id
      PlexPixelSpotId pixSpotId=plexHandle.GetPixelSpotId(seid);

      MSG("LIPlexMaps",Msg::kVerbose)
        <<"("<<plane<<":"<<strip<<":"<<end<<") "
        <<pixSpotId.AsString()<<endl;

      UInt_t pmtKey=pixSpotId.GetUniquePmtEncodedValue();
      //initialise pmt object (only done if first time)
      pmts[pmtKey].Initialise(NUMPIXELS,NUMPIXELSPOTS);

      //only add value if there is one
      if (gain>-1){
        gainErrAvDet+=gainErr;
        gainAvDet+=gain;
        gainNum++;

        if (pixSpotId.GetSpot()<1){
          seid.Print();
          pixSpotId.Print();
        }

        pmts[pmtKey].SetPoint(pixSpotId.GetPixel(),pixSpotId.GetSpot(),
                gain);
        //add point to average detector PMT
        avDetPmt.AddMultiPoint(pixSpotId.GetPixel(),pixSpotId.GetSpot(),
                gain);
      } // gain >- 1
    } // reading in lines
  } // if gains file exists
  else{
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Can't open file "<<sGainsFileName<<endl
      <<"Exiting here..."<<endl;
    exit(1);
  }

  //calculate the average gain
  MSG("LIPlexMaps",Msg::kInfo) << "All detector gain="<<gainAvDet<<", gainErr="<<gainErrAvDet<<endl;
  if (gainNum!=0) gainAvDet/=gainNum;
  if (gainNum!=0) gainErrAvDet/=gainNum;
  MSG("LIPlexMaps",Msg::kInfo)
    <<"AverageDetector: gain= "<<gainAvDet<<" gainErr= "<<gainErrAvDet
    <<" gainNum= "<<gainNum
    <<" Npmts= "<<pmts.size()<<endl;
  //fill the histogram with all the gains
  avDetPmt.FillGainsHisto(hGainAvDet);

  //Section to write to database

  Int_t pixCounter=0;
  Int_t nnCounter=0;
  Int_t pmtCounter=0;
  Int_t detCounter=0;
  Int_t gainHighCounter=0;
  Int_t gainCappedCounter=0;
  Int_t totalCounter=0;
  Int_t goodCounter=0;

  Int_t pixgainHighCounter=0;
  Int_t pixgainCappedCounter=0;
  Int_t nngainHighCounter=0;
  Int_t nngainCappedCounter=0;
  Int_t pmtgainHighCounter=0;
  Int_t pmtgainCappedCounter=0;
  Int_t detgainHighCounter=0;
  Int_t detgainCappedCounter=0;

  // Work out if we are supposed to be dumping to an external file
  char *gaindump_filename = getenv("GAIN_DUMP_FILE");
  // string gaindump_filename = getenv("GAIN_DUMP_FILE");
  // Just try opening - if it is blank, all calls should passively fail
  ofstream gaindump(gaindump_filename);
  if (gaindump.is_open()) {
    MSG("LIPlexMaps",Msg::kInfo) << "Dumping gain values to " << gaindump_filename << endl;
    // Write a header to the gaindump
    gaindump  << "#"
              << setw(3) << "Pl" << " "
              << setw(3) << "Str" << " "
              << setw(3) << "End" << " "
              << setw(4) << "Agg" << " "
              << setw(6) << "SEID" << " "
              << setw(9) << "Gain" << " "
              << setw(9) << "Error"
              << "\n";
    
  } else {
    MSG("LIPlexMaps",Msg::kInfo) << "Not writing to gain dump." << endl;
  }
  
  //make validity range
  VldRange vr(det,simFlag,vldStart,vldEnd,
        "LISummary/LIPlexMaps::MakeCalAdcToPe");

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Using Validity Range: "<<vr.AsString()<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<"Log comment="<<sLogComment<<endl<<endl;

  // Create the unaggregated writer
  DbiWriter<CalADCtoPE> writer(vr,aggNo,task,creationDate,dbName,
                               sLogComment);

  // work out the number of aggregates
  Int_t NUMAGG = NUMCRATES; if(task==1) { NUMAGG = 484; if(det==1) NUMAGG = 194; }

  // Begin a loop over all aggregates
  for(Int_t agg=0;agg<NUMAGG;agg++){
    if(aggStat[agg]<0) continue;

    // Create the aggregated writer
    if(aggNo==-1) agg = NUMAGG-1;
    DbiWriter<CalADCtoPEs> writers(vr,agg,task,creationDate,dbName,sLogComment);

    Int_t pixCounter2=0;
    Int_t nnCounter2=0;
    Int_t pmtCounter2=0;
    Int_t detCounter2=0;
    Int_t gainHighCounter2=0;
    Int_t gainCappedCounter2=0;
    Int_t totalCounter2=0;
    Int_t goodCounter2=0;

    //loop over all strip ends
    for(Int_t pl=FIRSTSCINTPLANE;pl<=LASTSCINTPLANE;pl++) {
      for(Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++) {
        for(Int_t end=FIRSTEND;end<=SECONDEND;end++) {

          //ignore the bookends
          if ((pl==SM1BOOKEND || pl==SM2BOOKEND) && 
              det==Detector::kFar) continue;

          //if (pl>70) continue;
          //if (pl==70) exit(1);

          //calculate the index
          Int_t seIndex=pl*NUMSTRIPS*NUMENDS+st*NUMENDS+end-1; //same to seidkey in db

          //get the stripend id
          PlexStripEndId seid(det,pl,st,
                  static_cast<StripEnd::EStripEnd>(end));

          // check whether stripend actually exists
          if (!seid.IsValid() ) continue;

          // in the near detector, a further check is needed:
          // partial U planes have strips 0-63
          // partial V planes have strips 4-67
          if (det==Detector::kNear) {
            if (((pl-1)%5) && (pl%2)    && st>63) continue;
            if (((pl-1)%5) && (pl%2)==0 && st<4 ) continue;
          }

          //if the crate is the same as the pbcrate, then write to DB
          Int_t crate=plexHandle.GetRawChannelId(seid).GetCrate();
                PlexPixelSpotId pixSpotId=plexHandle.GetPixelSpotId(seid);
                if (aggNo!=-1 && ((task==0 && crate!=agg) || (task==1 && static_cast<Int_t>(pixSpotId.GetNumericMuxBox())!=LILookup::GetNumericMuxBox(agg)))) continue;

          // If we don't have any gains for this point, work out how we can recover
          if(vGains[seIndex]==-1){

            Int_t pmtKey=pixSpotId.GetUniquePmtEncodedValue();

            //get pmt gains etc
            Double_t pmtGain=pmts[pmtKey].GetAvPmtGain();
            Int_t pmtNum=pmts[pmtKey].GetPmtNum();
            Double_t pixelGain=pmts[pmtKey].GetPixelGain(pixSpotId.GetPixel());
            Int_t pixelNum=pmts[pmtKey].GetPixelNum(pixSpotId.GetPixel());
            Double_t nnGain=pmts[pmtKey].GetNearestNeighboursAvGain(pixSpotId.GetPixel());
            Int_t nnNum=pmts[pmtKey].GetNearestNeighboursNum(pixSpotId.GetPixel());

            Bool_t pixGood=false;
            Bool_t nnGood=false;
            Bool_t pmtGood=false;

            // Work out how to recover a value for this seid
            if (pixelNum>0 && pixelGain>0) pixGood=true;
            if (nnNum>0 && nnGain>0) nnGood=true;
            if (pmtNum>0 && pmtGain>0) pmtGood=true;

            // Do the actual recovery
            if (pixGood){
              pixCounter++; pixCounter2++;
              vGains[seIndex]=pixelGain;
              vGainErrs[seIndex]=gainErrUnknownPixelSpot;
              vSPEWidths[seIndex]=SPEWidthFraction*vGains[seIndex];
              if (MsgService::Instance()->IsActive("LIPlexMaps",Msg::kDebug)) {
                MSG("LIPlexMaps",Msg::kInfo)
                  <<"("<<pl<<":"<<st<<":"<<end<<")"
                  <<" No Data: Setting gain to be average of pixel ("
                  <<vGains[seIndex]<<")"<<endl
                  <<" pixGain="<<pixelGain<<" (N="<<pixelNum
                  <<"), nnGain="<<nnGain<<" (N="<<nnNum
                  <<"), pmtGain="<<pmtGain<<", (N="<<pmtNum<<")"<<endl;
              }
            } else if (nnGood) {
              nnCounter++; nnCounter2++;
              vGains[seIndex]=nnGain;
              vGainErrs[seIndex]=gainErrUnknownPixel;
              vSPEWidths[seIndex]=SPEWidthFraction*vGains[seIndex];
              MSG("LIPlexMaps",Msg::kInfo)
                <<"("<<pl<<":"<<st<<":"<<end<<")"
                <<" No Data: Setting gain to be average of NN ("
                <<vGains[seIndex]<<")"<<endl
                <<" pixGain="<<pixelGain<<" (N="<<pixelNum
                <<"), nnGain="<<nnGain<<" (N="<<nnNum
                <<"), pmtGain="<<pmtGain<<", (N="<<pmtNum<<")"<<endl;
            } else if (pmtGood) {
              pmtCounter++; pmtCounter2++;
              vGains[seIndex]=pmtGain;
              vGainErrs[seIndex]=gainErrUnknownNN;
              vSPEWidths[seIndex]=SPEWidthFraction*vGains[seIndex];
              MSG("LIPlexMaps",Msg::kInfo)
                <<"("<<pl<<":"<<st<<":"<<end<<")"
                <<" No Data: Setting gain to be average of pmt ("
                <<vGains[seIndex]<<")"<<endl
                <<" pixGain="<<pixelGain<<" (N="<<pixelNum
                <<"), nnGain="<<nnGain<<" (N="<<nnNum
                <<"), pmtGain="<<pmtGain<<", (N="<<pmtNum<<")"<<endl;
            } else {
              detCounter++; detCounter2++;

              Double_t avDetPmtGain=avDetPmt.GetAvPmtGain();
              Int_t avDetPmtNum=avDetPmt.GetPmtNum();
              Double_t avDetPmtPixelGain=avDetPmt.
                      GetPixelGain(pixSpotId.GetPixel());
              Int_t avDetPmtPixelNum=avDetPmt.
                      GetPixelNum(pixSpotId.GetPixel());

              Double_t avDetPmtSpotGain=avDetPmt.
                      GetGain(pixSpotId.GetPixel(),pixSpotId.GetSpot());

              vGains[seIndex]=avDetPmtSpotGain;
              vGainErrs[seIndex]=gainErrUnknownPmt;
              vSPEWidths[seIndex]=SPEWidthFraction*vGains[seIndex];
              MSG("LIPlexMaps",Msg::kInfo)
                <<"("<<pl<<":"<<st<<":"<<end<<")"
                <<" No Data: Setting gain to same spot on average pmt ("
                <<vGains[seIndex]<<")"<<endl
                <<" pixGain="<<avDetPmtPixelGain
                <<", pixNum="<<avDetPmtPixelNum
                <<", pmtGain="<<avDetPmtGain
                <<", pmtNum="<<avDetPmtNum<<endl;
            }
          } else {
            goodCounter++; goodCounter2++;
          } // gain good or bad

          //check that the gains aren't too high
          if(vGains[seIndex]>gainTooHigh){

            if(vGainErrs[seIndex]!=gainErrUnknownPixelSpot && vGainErrs[seIndex]!=gainErrUnknownPixel &&
               vGainErrs[seIndex]!=gainErrUnknownNN && vGainErrs[seIndex]!=gainErrUnknownPmt ) {

              //have to decrement the goodCounter if gain is too high
              goodCounter--; goodCounter2--;
              //count the high gains
              gainHighCounter++; gainHighCounter2++;

            }
            if(vGainErrs[seIndex]==gainErrUnknownPixelSpot) {
              pixgainHighCounter++; if (vGains[seIndex]>gainCeiling) pixgainCappedCounter++;
            }
            if(vGainErrs[seIndex]==gainErrUnknownPixel) {
              nngainHighCounter++; if (vGains[seIndex]>gainCeiling) nngainCappedCounter++;
            }
            if(vGainErrs[seIndex]==gainErrUnknownNN) {
              pmtgainHighCounter++; if (vGains[seIndex]>gainCeiling) pmtgainCappedCounter++;
            }
            if(vGainErrs[seIndex]==gainErrUnknownPmt) {
              detgainHighCounter++; if (vGains[seIndex]>gainCeiling) detgainCappedCounter++;
            }

            Int_t pmtKey=pixSpotId.GetUniquePmtEncodedValue();

            //get pmt gains etc
            Double_t pmtGain=pmts[pmtKey].GetAvPmtGain();
            Int_t pmtNum=pmts[pmtKey].GetPmtNum();
            Double_t pixelGain=pmts[pmtKey].GetPixelGain(pixSpotId.
                     GetPixel());
            Int_t pixelNum=pmts[pmtKey].GetPixelNum(pixSpotId.GetPixel());

            // What if the gain is crazy high?
            if (vGains[seIndex]>gainCeiling){
              hGainCrazyHighPmt->Fill(vGains[seIndex]);

              if(vGainErrs[seIndex]!=gainErrUnknownPixelSpot && vGainErrs[seIndex]!=gainErrUnknownPixel &&
                 vGainErrs[seIndex]!=gainErrUnknownNN && vGainErrs[seIndex]!=gainErrUnknownPmt )
              {
                gainCappedCounter++; gainCappedCounter2++;
              }

              Float_t oldGain=vGains[seIndex];
              vGains[seIndex]=gainCeiling;
              vSPEWidths[seIndex]=SPEWidthFraction*vGains[seIndex];

              MSG("LIPlexMaps",Msg::kInfo)
                <<"("<<pl<<":"<<st<<":"<<end<<")"
                <<" ** Capping very high gain ("<<oldGain
                <<") to be gainCeiling ("<<vGains[seIndex]<<")"<<endl
                <<" pixGain="<<pixelGain<<", pixNum="<<pixelNum
                <<", pmtGain="<<pmtGain<<", pmtNum="<<pmtNum<<endl;
            }

            //the gain error is the same whether it was capped or not
            vGainErrs[seIndex]=gainErrTooHighGain;

            //fill the histo for high gain pmts
            hGainHighPmt->Fill(vGains[seIndex]);
          } // high gains

          //create CALADCTOPE table row
          CalADCtoPE calAdcToPe(seid.BuildPlnStripEndKey(),
              seid.GetEncoded(),vGains[seIndex],
              vGainErrs[seIndex],vSPEWidths[seIndex]);
          CalADCtoPEs calAdcToPes(agg,
                seid.BuildPlnStripEndKey(),vGains[seIndex],
                vGainErrs[seIndex],vSPEWidths[seIndex],vSPEWidthErrs[seIndex]);

          //fill the histos
          hGain->Fill(vGains[seIndex]);
          hGainErr->Fill(vGainErrs[seIndex]);
          hGainErrZoom->Fill(vGainErrs[seIndex]);
          hGainErrFract->Fill(vGainErrs[seIndex]/vGains[seIndex]);
          hSPEWidth->Fill(vSPEWidths[seIndex]);

          if (crate>=FIRSTCRATE && crate<=LASTCRATE){
            hStripVsPlaneGain[crate]->Fill(pl,st,vGains[seIndex]);
            hStripVsPlaneGainErr[crate]->Fill(pl,st,vGainErrs[seIndex]);
            hStripVsPlaneSPEWidth[crate]->Fill(pl,st,vSPEWidths[seIndex]);
          }

          //write the row to the dbiwriter
          if(aggNo==-1) writer << calAdcToPe; else writers << calAdcToPes;

          // Write the data to the gain dump
          gaindump  << setw(4) << pl << " "
                    << setw(3) << st << " "
                    << setw(3) << end << " "
                    << setw(4) << agg << " "
                    << setw(6) << seid.BuildPlnStripEndKey() << " "
                    << setw(9) << vGains[seIndex] << " "
                    << setw(9) << vGainErrs[seIndex]
                    << endl;
          
          //count the number of strips written out
          totalCounter++; totalCounter2++;

          if (MsgService::Instance()->
              IsActive("LIPlexMaps",Msg::kVerbose)){
            MSG("LIPlexMaps",Msg::kInfo)
              <<"("<<pl<<":"<<st<<":"<<end<<")"
              <<" "<<vGains[seIndex]<<"  "
              <<vGainErrs[seIndex]<<" "<<vSPEWidths[seIndex]<<endl;
          }
        } //end of stripend loop
      } //end of strip loop
    } //end of plane loop

    // Flush the gaindump
    gaindump.flush();
    // gaindump.close();

    // If we are aggregating
    if(aggNo!=-1) {
      Int_t totalCounted2 = goodCounter2+pixCounter2+nnCounter2+pmtCounter2+
                            detCounter2+gainHighCounter2;
      Int_t numBadStripends2 = totalCounted2-goodCounter2;

      MSG("LIPlexMaps",Msg::kInfo)
        <<" AggNo= "<<setw(4)<<agg<<" Ntot= "<<setw(3)<<totalCounted2
        <<" Ngood= "<<setw(3)<<goodCounter2<<" Nbad= "<<setw(3)<<numBadStripends2
        <<" Npix= "<<setw(3)<<pixCounter2<<" Nnn= "<<setw(3)<<nnCounter2<<" Npmt= "<<setw(3)<<pmtCounter2<<" Ndet= "<<setw(3)<<detCounter2
        <<" Nhot= "<<setw(3)<<gainHighCounter2<<" Ncrazy= "<<setw(3)<<gainCappedCounter2<<endl;

      MSG("LIPlexMaps",Msg::kInfo)
        <<"DbiWriters.IsOpen="<<writers.IsOpen()<<endl
        <<"DbiWriters.CanOuptpu="<<writers.CanOutput()<<endl;

      // Make sure that enouch channels in this aggregate are 'good'
      Bool_t badagg = false;
      Double_t badfrac = (Double_t)numBadStripends2 / (Double_t)totalCounted2;
      // Aggregate is 'bad' if more than 50% is bad
      if (badfrac > 0.3125) badagg = true;

      // New! Get rid of large amounts of crazies
      if (gainCappedCounter2 > 2) {
        MSG("LIPlexMaps", Msg::kInfo) << "Aggregate has too many crazies" << endl;
        badagg = true;
      }

      if (writeToDb){
        if (badagg) {
          MSG("LIPlexMaps",Msg::kInfo) << "Aggregate is bad: Not Writing to database" << endl;
        } else {
          if (this->IsPermitted()) {
            MSG("LIPlexMaps",Msg::kInfo)
                <<"Writing to database..."<<endl;
            //this is the line that actually writes to the database
            writers.Close();
            MSG("LIPlexMaps",Msg::kInfo)
              <<"Finished writing to database"<<endl<<endl;
          }
        } // bad agg
      }
      else {
        MSG("LIPlexMaps",Msg::kInfo)
          <<"Mode is set to NOT write to database"<<endl<<endl;
      }
    } // aggNo != -1
  } //end of aggregation loop

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl
    <<"Corrected_Info(mean+-rms): GainAvDet(overall)= "<<hGainAvDet->GetMean()<<" +- "<<hGainAvDet->GetRMS()
    <<" Gain(<"<<gainTooHigh<<")= "<<hGain->GetMean()<<" +- "<<hGain->GetRMS()
    <<" GainErrZoom= "<<hGainErrZoom->GetMean()<<" +- "<<hGainErrZoom->GetRMS()
    <<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl
    <<" ** Values used in method: **"<<endl
    <<" NUMPLANES="<<NUMPLANES<<endl
    <<" NUMSTRIPS="<<NUMSTRIPS<<endl
    <<" NUMENDS="<<NUMENDS<<endl
    <<" NUMBOOKENDS="<<NUMBOOKENDS<<endl;

  if (det==Detector::kNear) {
    MSG("LIPlexMaps",Msg::kInfo)
      << " Total number of strip ends=" << 11616 << endl;
  } 
  else {
    MSG("LIPlexMaps",Msg::kInfo)
      <<" Total number of strip ends="
      <<(NUMPLANES*NUMSTRIPS*NUMENDS)-(NUMBOOKENDS*NUMSTRIPS*NUMENDS)
      <<endl;
  }

  Int_t totalCounted = goodCounter+pixCounter+nnCounter+pmtCounter+
                       detCounter+gainHighCounter;
  Int_t numBadStripends=totalCounted-goodCounter;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl
    <<" ** Job Summary **"<<endl
    <<" Num good stripends= "<<goodCounter
    <<"  ( "<<100.*goodCounter/totalCounted<<" %)"<<endl
    <<" Num bad stripends= "<<numBadStripends
    <<"  ( "<<100.*numBadStripends/totalCounted<<" %)"<<endl
    <<"   with average pixel value= "<<pixCounter
    <<"  ( "<<100.*pixCounter/totalCounted<<" %)  gain too high= "<<pixgainHighCounter<<" (capped= "<<pixgainCappedCounter<<" )"<<endl
    <<"   with average NN value= "<<nnCounter
    <<"  ( "<<100.*nnCounter/totalCounted<<" %)  gain too high= "<<nngainHighCounter<<" (capped= "<<nngainCappedCounter<<" )"<<endl
    <<"   with average PMT value= "<<pmtCounter
    <<"  ( "<<100.*pmtCounter/totalCounted<<" %)  gain too high= "<<pmtgainHighCounter<<" (capped= "<<pmtgainCappedCounter<<" )"<<endl
    <<"   with average-detector-PMT value= "<<detCounter
    <<"  ( "<<100.*detCounter/totalCounted<<" %)  Equiv. num PMTs= "
    <<1.*detCounter/(NUMPIXELS*NUMPIXELSPOTS)<<"  gain too high= "<<detgainHighCounter<<" (capped= "<<detgainCappedCounter<<" )"<<endl
    <<"   with too high gain= "<<gainHighCounter
    <<"  ( "<<100.*gainHighCounter/totalCounted<<" %)  gain capped= "<<gainCappedCounter
    <<"  ( "<<100.*gainCappedCounter/totalCounted<<" %)"<<endl
    <<" Sum of above= "<<totalCounted<<endl
    <<" Total num written to DB= "<<totalCounter<<endl;

  // Do the database writing for the case where we are not aggregating
  if(aggNo==-1) {

    MSG("LIPlexMaps",Msg::kInfo)
      <<"DbiWriter.IsOpen=" << writer.IsOpen()<<endl
      <<"DbiWriter.CanOutput=" << writer.CanOutput()<<endl;

    if (writeToDb){
      if (this->IsPermitted()){
        MSG("LIPlexMaps",Msg::kInfo)
          <<"Writing to database..."<<endl;
        //this is the line that actually writes to the database
        writer.Close();
        MSG("LIPlexMaps",Msg::kInfo)
          <<"Finished writing to database"<<endl;
      }
    }
    else {
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Mode is set to NOT write to database"<<endl;
    }

  }

  // Now do the drawing

  //set stats info
  gStyle->SetOptStat(1111111);

  //draw gains
  TCanvas *cGain=new TCanvas("cGain","PMT Gain",0,0,1000,600);
  cGain->SetFillColor(0);
  cGain->cd();
  hGain->Draw();

  //draw gains
  TCanvas *cGainHighPmt=new TCanvas("cGainHighPmt","PMT Gain: HighPmts",
            0,0,1000,600);
  cGainHighPmt->SetFillColor(0);
  cGainHighPmt->cd();
  hGainHighPmt->Draw();
  //cGainHighPmt->SetLogy();

  //draw crazy gains
  TCanvas *cGainCrazyHighPmt=new TCanvas("cGainCrazyHighPmt",
           "PMT Gain: CrazyHighPmts",
           0,0,1000,600);
  cGainCrazyHighPmt->SetFillColor(0);
  cGainCrazyHighPmt->cd();
  hGainCrazyHighPmt->Draw();

  //draw gain errs  
  TCanvas *cGainErr=new TCanvas("cGainErr","PMT GainErr",0,0,1000,600);
  cGainErr->SetFillColor(0);
  cGainErr->cd();
  hGainErr->Draw();
  cGainErr->SetLogy();

  //draw gain errs zoom
  TCanvas *cGainErrZoom=new TCanvas("cGainErrZoom","PMT GainErrZoom",
            0,0,1000,600);
  cGainErrZoom->SetFillColor(0);
  cGainErrZoom->cd();
  hGainErrZoom->Draw();

  //draw gain errs fract
  TCanvas *cGainErrFract=new TCanvas("cGainErrFract","PMT GainErrFract",
             0,0,1000,600);
  cGainErrFract->SetFillColor(0);
  cGainErrFract->cd();
  hGainErrFract->Draw();

  //draw SPEWidths
  TCanvas *cSPEWidth=new TCanvas("cSPEWidth","PMT SPEWidth",
         0,0,1000,600);
  cSPEWidth->SetFillColor(0);
  cSPEWidth->cd();
  hSPEWidth->Draw();

  //draw gainAvDets
  TCanvas *cGainAvDet=new TCanvas("cGainAvDet",
          "Gains of Av. PMT in Detector",
          0,0,1000,600);
  cGainAvDet->SetFillColor(0);
  cGainAvDet->cd();
  hGainAvDet->Draw();

  //do the gains
  TCanvas *cStripVsPlaneGain=new TCanvas
    ("cStripVsPlaneGain","StripVsPlane: Gain",0,0,1000,800);
  cStripVsPlaneGain->SetFillColor(0);
  cStripVsPlaneGain->cd();
  string sDbGains="DbGainsNew";
  sDbGains+=Detector::AsString(static_cast<Detector::
           Detector_t>(det));
  sDbGains+=".ps";
  cStripVsPlaneGain->Print((sDbGains+"[").c_str());
  gErrorIgnoreLevel=1;
  //set stats info off
  gStyle->SetOptStat(0);
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneGain->Clear();
    hStripVsPlaneGain[i]->Draw("colz");
    cStripVsPlaneGain->Print(sDbGains.c_str());
  }
  //print 1D histos at the end
  //set stats on
  gStyle->SetOptStat(1111111);
  cGain->Print(sDbGains.c_str());
  cGainAvDet->Print(sDbGains.c_str());
  cGainHighPmt->Print(sDbGains.c_str());
  cGainCrazyHighPmt->Print(sDbGains.c_str());
  //close the file
  cStripVsPlaneGain->Print((sDbGains+"]").c_str());
  gErrorIgnoreLevel=0;

  //do the gain errors
  TCanvas *cStripVsPlaneGainErr=new TCanvas
    ("cStripVsPlaneGainErr","StripVsPlane: GainErr",0,0,1000,800);
  cStripVsPlaneGainErr->SetFillColor(0);
  cStripVsPlaneGainErr->cd();
  string sDbGainErrs="DbGainErrsNew";
  sDbGainErrs+=Detector::AsString(static_cast<Detector::
               Detector_t>(det));
  sDbGainErrs+=".ps";
  cStripVsPlaneGainErr->Print((sDbGainErrs+"[").c_str());
  gErrorIgnoreLevel=1;
  //set stats off
  gStyle->SetOptStat(0);
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneGainErr->Clear();
    hStripVsPlaneGainErr[i]->Draw("colz");
    hStripVsPlaneGainErr[i]->SetMaximum(2.0*gainErrAvDet);
    cStripVsPlaneGainErr->Print(sDbGainErrs.c_str());
  }
  //print 1D histo at the end
  //set stats on
  gStyle->SetOptStat(1111111);
  cGainErr->Print(sDbGainErrs.c_str());
  cGainErrZoom->Print(sDbGainErrs.c_str());
  cGainErrFract->Print(sDbGainErrs.c_str());
  //close the file
  cStripVsPlaneGainErr->Print((sDbGainErrs+"]").c_str());
  gErrorIgnoreLevel=0;

  //do SPEWidths
  TCanvas *cStripVsPlaneSPEWidth=new TCanvas
    ("cStripVsPlaneSPEWidth","StripVsPlane: SPEWidth",0,0,1000,800);
  cStripVsPlaneSPEWidth->SetFillColor(0);
  cStripVsPlaneSPEWidth->cd();
  string sDbSPEWidths="DbSPEWidthsNew";
  sDbSPEWidths+=Detector::AsString(static_cast<Detector::
               Detector_t>(det));
  sDbSPEWidths+=".ps";
  cStripVsPlaneSPEWidth->Print((sDbSPEWidths+"[").c_str());
  gErrorIgnoreLevel=1;
  //set stats off
  gStyle->SetOptStat(0);
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneSPEWidth->Clear();
    hStripVsPlaneSPEWidth[i]->Draw("colz");
    cStripVsPlaneSPEWidth->Print(sDbSPEWidths.c_str());
  }
  //print 1D histo at the end
  //set stats on
  gStyle->SetOptStat(1111111);
  cSPEWidth->Print(sDbSPEWidths.c_str());
  //close the file
  cStripVsPlaneSPEWidth->Print((sDbSPEWidths+"]").c_str());
  gErrorIgnoreLevel=0;

  //set stats info on
  gStyle->SetOptStat(1111111);

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakeCalAdcToPe method... ** "<<endl;
}



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

void LIPlexMaps::DumpCalStripToStrip(std::string sDataFileName,
                                     Detector::Detector_t det,
                                     SimFlag::ESimFlag simFlag,
                                     VldTimeStamp ts,Int_t task) const
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the DumpCalStripToStrip() method... **"<<endl;

  DbiResultPtr<CalStripToStrip> dbiCalStripToStrip;
  VldContext vldCtx(det,simFlag,ts);
  UInt_t numRows=dbiCalStripToStrip.NewQuery(vldCtx,task);
  
  //open the file  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Opening file "<<sDataFileName<<"..."<<endl;
  ofstream odataFile(sDataFileName.c_str());

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<task<<endl
    <<"Looping over rows..."<<endl;
  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripToStrip* calStripToStrip=dbiCalStripToStrip.GetRow(i);
    
    Int_t seid_enc=calStripToStrip->GetStripEndId().GetEncoded();    
    Float_t resp=calStripToStrip->GetResponse();
    Float_t respErr=calStripToStrip->GetResponseErr();
    
    odataFile<<seid_enc<<"\t"<<resp<<"\t"<<respErr<<endl;
  }
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Output file completed"<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the DumpCalStripToStrip method... ** "<<endl;
}

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

void LIPlexMaps::DumpCalStripAtten(std::string sDataFileName,
                                   Detector::Detector_t det,
                                   SimFlag::ESimFlag simFlag,
                                   VldTimeStamp ts,Int_t task)
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the DumpCalStripAtten() method... **"<<endl;

  //this must go first
  this->SetDetector(static_cast<Int_t>(det));

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;
  
  string s="Lambda1, East side";
  TH2F *hStripVsPlaneLambda1East=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneLambda1East->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneLambda1East->GetXaxis()->CenterTitle();
  hStripVsPlaneLambda1East->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneLambda1East->GetYaxis()->CenterTitle();
  
  s="Lambda1, West side";
  TH2F *hStripVsPlaneLambda1West=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneLambda1West->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneLambda1West->GetXaxis()->CenterTitle();
  hStripVsPlaneLambda1West->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneLambda1West->GetYaxis()->CenterTitle();

  s="Lambda2, East side";
  TH2F *hStripVsPlaneLambda2East=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneLambda2East->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneLambda2East->GetXaxis()->CenterTitle();
  hStripVsPlaneLambda2East->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneLambda2East->GetYaxis()->CenterTitle();
  
  s="Lambda2, West side";
  TH2F *hStripVsPlaneLambda2West=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneLambda2West->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneLambda2West->GetXaxis()->CenterTitle();
  hStripVsPlaneLambda2West->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneLambda2West->GetYaxis()->CenterTitle();

  s="Frac1, East side";
  TH2F *hStripVsPlaneFrac1East=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneFrac1East->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneFrac1East->GetXaxis()->CenterTitle();
  hStripVsPlaneFrac1East->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneFrac1East->GetYaxis()->CenterTitle();
  
  s="Frac1, West side";
  TH2F *hStripVsPlaneFrac1West=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneFrac1West->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneFrac1West->GetXaxis()->CenterTitle();
  hStripVsPlaneFrac1West->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneFrac1West->GetYaxis()->CenterTitle();

  s="Atten, East side";
  TH2F *hStripVsPlaneAttenEast=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneAttenEast->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneAttenEast->GetXaxis()->CenterTitle();
  hStripVsPlaneAttenEast->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneAttenEast->GetYaxis()->CenterTitle();
  
  s="Atten, West side";
  TH2F *hStripVsPlaneAttenWest=new TH2F(s.c_str(),s.c_str(),
                                      LASTSCINTPLANE-FIRSTSCINTPLANE+2,
                                      0,LASTSCINTPLANE+1,
                                      bins,firstStripBin,lastStripBin);
  hStripVsPlaneAttenWest->GetXaxis()->SetTitle("Plane");
  hStripVsPlaneAttenWest->GetXaxis()->CenterTitle();
  hStripVsPlaneAttenWest->GetYaxis()->SetTitle("Strip");
  hStripVsPlaneAttenWest->GetYaxis()->CenterTitle();
  
  DbiResultPtr<CalStripAtten> dbiCalStripAtten;
  VldContext vldCtx(det,simFlag,ts);
  UInt_t numRows=dbiCalStripAtten.NewQuery(vldCtx,task);
  
  //open the file  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Opening file "<<sDataFileName<<"..."<<endl;
  ofstream odataFile(sDataFileName.c_str());

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<task<<endl
    <<"Looping over rows..."<<endl;
  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripAtten* calStripAtten=dbiCalStripAtten.GetRow(i);
    
    /*
  CalStripAtten (const PlexStripEndId &seid, Float_t lambda1, Float_t lambda2, Float_t frac1, Float_t lambda1err, Float_t lambda2err, Float_t frac1err) 
  CalStripAtten (Int_t seid_enc, Float_t lambda1, Float_t lambda2, Float_t frac1, Float_t lambda1err, Float_t lambda2err, Float_t frac1err) 
virtual  ~CalStripAtten () 
Bool_t  CanL2Cache () const  
UInt_t  GetIndex (UInt_t) const  
PlexStripEndId  GetStripEndId () const  
UInt_t  GetSEIDkey () const  
Float_t  GetLambda1 () const  
Float_t  GetLambda2 () const  
Float_t  GetFrac1 () const  
Float_t  GetFrac2 () const  
Float_t  GetLambda1Err () const  
Float_t  GetLambda2Err () const  
Float_t  GetFrac1Err () const  
    */


    Int_t seid_enc=calStripAtten->GetStripEndId().GetEncoded();    
    Float_t lambda1=calStripAtten->GetLambda1();
    Float_t lambda2=calStripAtten->GetLambda2();
    Float_t frac1=calStripAtten->GetFrac1();
    Float_t lambda1Err=calStripAtten->GetLambda1Err();
    Float_t lambda2Err=calStripAtten->GetLambda2Err();
    Float_t frac1Err=calStripAtten->GetFrac1Err();
    
    MAXMSG("LIPlexMaps",Msg::kInfo,10)
      <<"seid_enc="<<seid_enc
      <<", GetSEIDkey="<<calStripAtten->GetSEIDkey()<<endl;

    PlexStripEndId seid=calStripAtten->GetStripEndId();
    Int_t plane=seid.GetPlane();
    Int_t strip=seid.GetStrip();
    Int_t se=seid.GetEnd();
    Float_t x=1.5;

    //try changing units of distance
    //x=0.15;

    //try flipping frac1 
    //frac1=1-frac1;

    Float_t atten=frac1*exp(-x/lambda1)+(1-frac1)*exp(-x/lambda2);

    if (se==StripEnd::kEast){
      hStripVsPlaneLambda1East->Fill(plane,strip,lambda1);
      hStripVsPlaneLambda2East->Fill(plane,strip,lambda2);
      hStripVsPlaneFrac1East->Fill(plane,strip,frac1);
      hStripVsPlaneAttenEast->Fill(plane,strip,atten);
    }
    else {
      hStripVsPlaneLambda1West->Fill(plane,strip,lambda1);
      hStripVsPlaneLambda2West->Fill(plane,strip,lambda2);
      hStripVsPlaneFrac1West->Fill(plane,strip,frac1);
      hStripVsPlaneAttenWest->Fill(plane,strip,atten);
    }

    odataFile<<seid_enc
             <<"\t"<<lambda1
             <<"\t"<<lambda2
             <<"\t"<<frac1
             <<"\t"<<lambda1Err
             <<"\t"<<lambda2Err
             <<"\t"<<frac1Err
             <<endl;
  }
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Output file completed"<<endl;

  TCanvas *cStripVsPlaneLambda1=new TCanvas
    ("cStripVsPlaneLambda1","StripVsPlane: Mean",0,0,1100,800);
  cStripVsPlaneLambda1->SetFillColor(0);
  cStripVsPlaneLambda1->Divide(1,2);
  cStripVsPlaneLambda1->cd(1);
  hStripVsPlaneLambda1East->Draw("colz");
  cStripVsPlaneLambda1->cd(2);
  hStripVsPlaneLambda1West->Draw("colz");

  TCanvas *cStripVsPlaneLambda2=new TCanvas
    ("cStripVsPlaneLambda2","StripVsPlane: Mean",0,0,1100,800);
  cStripVsPlaneLambda2->SetFillColor(0);
  cStripVsPlaneLambda2->Divide(1,2);
  cStripVsPlaneLambda2->cd(1);
  hStripVsPlaneLambda2East->Draw("colz");
  cStripVsPlaneLambda2->cd(2);
  hStripVsPlaneLambda2West->Draw("colz");

  TCanvas *cStripVsPlaneFrac1=new TCanvas
    ("cStripVsPlaneFrac1","StripVsPlane: Mean",0,0,1100,800);
  cStripVsPlaneFrac1->SetFillColor(0);
  cStripVsPlaneFrac1->Divide(1,2);
  cStripVsPlaneFrac1->cd(1);
  hStripVsPlaneFrac1East->Draw("colz");
  cStripVsPlaneFrac1->cd(2);
  hStripVsPlaneFrac1West->Draw("colz");

  TCanvas *cStripVsPlaneAtten=new TCanvas
    ("cStripVsPlaneAtten","StripVsPlane: Mean",0,0,1100,800);
  cStripVsPlaneAtten->SetFillColor(0);
  cStripVsPlaneAtten->Divide(1,2);
  cStripVsPlaneAtten->cd(1);
  hStripVsPlaneAttenEast->Draw("colz");
  cStripVsPlaneAtten->cd(2);
  hStripVsPlaneAttenWest->Draw("colz");

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the DumpCalStripAtten method... ** "<<endl;
}

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

void LIPlexMaps::MakeCalStripToStrip(std::string sDataFileName,
                                     Detector::Detector_t det,
                                     SimFlag::ESimFlag simFlag,
                                     VldTimeStamp vldStart,
                                     VldTimeStamp vldEnd,
                                     Int_t aggNo,
                                     Int_t task,
                                     VldTimeStamp creationDate,
                                     std::string dbName,
                                     std::string sLogComment,
                                     Bool_t writeToDb)
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakeCalStripToStrip() method... **"<<endl; 
  //this must go first
  this->SetDetector(static_cast<Int_t>(det));

  //open the file  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Opening file "<<sDataFileName<<"..."<<endl;
  ifstream dataFile(sDataFileName.c_str());

  if (!dataFile){
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Can't open file "<<sDataFileName<<endl
      <<"Exiting here..."<<endl;
    exit(1);
  }
 
  //make validity range
  VldRange vr(det,simFlag,vldStart,vldEnd,
              "LISummary/LIPlexMaps::MakeCalStripToStrip");
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Using Validity Range: "<<vr.AsString()<<endl;
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Log comment="<<sLogComment<<endl;

  //create the writer
  DbiWriter<CalStripToStrip> writer(vr,aggNo,task,creationDate,dbName,
                                    sLogComment);
   
  Int_t seid_enc=-1;
  Float_t resp=-1;
  Float_t respErr=-1;
  Float_t defaultResp=1;
  Float_t defaultRespErr=1;

  Int_t counter=0;

  //map to store all the calsts
  map<Int_t,myCalStripToStrip> inputCalSts;
  
  //initialise map according to the expected number of strips
  //this was written to fill gaps in tables
  for (Int_t pl=FIRSTSCINTPLANE;pl<=LASTSCINTPLANE;pl++){
    for (Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++){

      //continue if not FI - happens in pl!=6,11,16,...
      if (det==Detector::kNear && st>67 && (pl-1)%5!=0) continue; 
      
      //continue if in spectrometer and not pl=121,126,131,...
      if (det==Detector::kNear && pl>120 && (pl-1)%5!=0) continue; 
      
      //cut out the SM2 bookend
      if (det==Detector::kFar && pl==249) continue;

      MAXMSG("LIPlexMaps",Msg::kInfo,10)
        <<"pl="<<pl<<", st="<<st<<endl;

      PlexStripEndId seidE(det,pl,st,StripEnd::kEast);
      PlexStripEndId seidW(det,pl,st,StripEnd::kWest);
      
      //only write the east side if not ND
      if (det!=Detector::kNear){
        MAXMSG("LIPlexMaps",Msg::kInfo,1)
          <<endl<<"Detector is not ND thus creating East stripends..."
          <<endl;
        inputCalSts[seidE.GetEncoded()]=myCalStripToStrip
          (seidE.GetEncoded(),defaultResp,defaultRespErr);;
      }
      
      //always write the west side
      inputCalSts[seidW.GetEncoded()]=myCalStripToStrip
        (seidW.GetEncoded(),defaultResp,defaultRespErr);;
      //inputCalSts[seidW.GetEncoded()]=calStripToStripW;
    }
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Map initialised with size="<<inputCalSts.size()<<endl;

  //read in from the text file and fill objects
  while(dataFile>>seid_enc>>resp>>respErr) {
    
    MAXMSG("LIPlexMaps",Msg::kInfo,10)
      <<"Found line in file: seid_enc="<<seid_enc
      <<", resp="<<resp<<", respErr="<<respErr<<endl;

    //create CALSTRIPTOSTRIP table row
    //CalStripToStrip calStripToStrip(seid_enc,resp,respErr);

    //write the new calsts to the map (this overwrites initial object)    
    inputCalSts[seid_enc]=myCalStripToStrip(seid_enc,resp,respErr);;

    //write the row to the dbiwriter
    //writer<<calStripToStrip;//can write below if rows missing

    counter++;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Found "<<counter<<" rows in file: "<<sDataFileName
    <<", mapSize="<<inputCalSts.size()<<endl;

  //loop over map and write to database
  typedef map<Int_t,myCalStripToStrip>::const_iterator stsIt;
  for (stsIt it=inputCalSts.begin();it!=inputCalSts.end();it++){
    const myCalStripToStrip& c=it->second;
    CalStripToStrip calStripToStrip(c.seid_enc,c.response,c.responseErr);
    MAXMSG("LIPlexMaps",Msg::kInfo,10)
      <<"Writing to database: seidEnc="<<c.seid_enc
      <<", resp="<<c.response<<", respErr="<<c.responseErr<<endl;
    writer<<calStripToStrip;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<"DbiWriter.IsOpen="<<writer.IsOpen()<<endl
    <<"DbiWriter.CanOutput="<<writer.CanOutput()<<endl;
  
  if (writeToDb){
    if (this->IsPermitted()){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Writing to database..."<<endl;
      //this is the line that actually writes to the database
      writer.Close();
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Finished writing to database"<<endl;
    }
  }
  else {
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Mode is set to NOT write to database"<<endl;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakeCalStripToStrip method... ** "<<endl;
}

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

void LIPlexMaps::MakeCalStripAtten(std::string sDataFileName,
                                   Detector::Detector_t det,
                                   SimFlag::ESimFlag simFlag,
                                   VldTimeStamp vldStart,
                                   VldTimeStamp vldEnd,
                                   Int_t aggNo,
                                   Int_t task,
                                   VldTimeStamp creationDate,
                                   std::string dbName,
                                   std::string sLogComment,
                                   Int_t iFileFormat,
                                   Bool_t writeToDb) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakeCalStripAtten() method... **"<<endl;
  //this must go first
  this->SetDetector(static_cast<Int_t>(det));

  //open the file
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Opening file "<<sDataFileName<<"..."<<endl;
  ifstream dataFile(sDataFileName.c_str());
  
  if (!dataFile){
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Can't open file "<<sDataFileName<<endl
      <<"Exiting here..."<<endl;
    exit(1);
  }
  
  //make validity range
  VldRange vr(det,simFlag,vldStart,vldEnd,
              "LISummary/LIPlexMaps::MakeCalStripAtten");
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Using Validity Range: "<<vr.AsString()<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Log comment="<<sLogComment<<endl;

  //create the writer
  DbiWriter<CalStripAtten> writer(vr,aggNo,task,creationDate,dbName,
                                  sLogComment);
  Int_t counter=0;

  if (iFileFormat==0) {//this is leon/jiajie's file format
    MAXMSG("LIPlexMaps",Msg::kInfo,100)
      <<"Assuming fileFormat=0 (=Leon/Jiajie's format)"<<endl;
    Int_t TotalLines=12000;
    Char_t buffer[248], moduleid[11];
    Int_t plane,strip,module_strip,ndf;
    Double_t chi2,shortAmp,shortAmp_err,shortAtt,shortAtt_err;
    Double_t longAmp,longAmp_err,longAtt,longAtt_err;
    
    dataFile.getline(buffer,248);
    
    for(Int_t i=0; i<TotalLines; i++) {
      if(!dataFile.good()) break;
      dataFile >> moduleid >> module_strip >> plane >> strip >> shortAmp
               >> shortAmp_err >> shortAtt >> shortAtt_err >> longAmp
               >> longAmp_err >> longAtt >> longAtt_err >> chi2 >> ndf;
      
      Double_t frac1 = shortAmp/(shortAmp+longAmp);
      Double_t frac1_err = 0;
      Double_t SAerr_2 = pow(shortAmp_err,2);
      Double_t LAerr_2 = pow(longAmp_err,2);
      Double_t SLA = shortAmp + longAmp;
      
      if(shortAmp>0) 
        frac1_err = frac1 * sqrt(SAerr_2/(2*shortAmp)+
                                 (SAerr_2+LAerr_2)/pow(SLA,2));
      PlexStripEndId seid(Detector::kNear,plane,strip,StripEnd::kWest);
      
      MAXMSG("LIPlexMaps",Msg::kInfo,100)
        <<"Found line in file: seid_enc="<<seid.AsString()
        <<", shortAtt="<<shortAtt/100.<< ", longAtt=" <<longAtt/100.
        <<", frac1="<<frac1 << endl;
      
      CalStripAtten calStripAtten(seid,shortAtt/100.,longAtt/100.,
                                  frac1,shortAtt_err/100,longAtt_err/100.,
                                  frac1_err);
      writer << calStripAtten;
      counter++;
    }
    dataFile.getline(buffer,248);
  }
  else if (iFileFormat==1) { //this is the format from DumpCalStripAtten
    MAXMSG("LIPlexMaps",Msg::kInfo,100)
      <<"Assuming fileFormat=1 (=DumpCalStripAtten)"<<endl;

    Int_t seid_enc=-1;
    Float_t lambda1=-1;
    Float_t lambda2=-1;
    Float_t frac1=-1;
    Float_t lambda1Err=-1;
    Float_t lambda2Err=-1;
    Float_t frac1Err=-1;

    //read in from the text file and fill objects
    while(dataFile
          >>seid_enc
          >>lambda1
          >>lambda2
          >>frac1
          >>lambda1Err
          >>lambda2Err
          >>frac1Err) {
    
      MAXMSG("LIPlexMaps",Msg::kInfo,10)
        <<"Found line in file: seid_enc="<<seid_enc
        <<", lambda1="<<lambda1
        <<", lambda2="<<lambda2
        <<", frac1="<<frac1
        <<endl;
   
      //create CALSTRIPATTEN table row
      CalStripAtten calStripAtten(seid_enc,lambda1,lambda2,frac1,
                                  lambda1Err,lambda2Err,frac1Err);   
      
      //write the row to the dbiwriter
      writer<<calStripAtten;
      
      counter++;
    }
  }
  else {
    MSG("LIPlexMaps",Msg::kError)
      <<"Input file format not recognised = "<<iFileFormat
      <<", will exit here..."<<endl;
    exit(1);
  }
  dataFile.close();
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Found "<<counter<<" rows in file: "<<sDataFileName<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"DbiWriter.IsOpen="<<writer.IsOpen()<<endl
    <<"DbiWriter.CanOutput="<<writer.CanOutput()<<endl;

  if (writeToDb){
    if (this->IsPermitted()){
      MSG("LIPlexMaps",Msg::kInfo)
    <<"Writing to database..."<<endl;
      //this is the line that actually writes to the database
      writer.Close();
      MSG("LIPlexMaps",Msg::kInfo)
    <<"Finished writing to database"<<endl;
    }
  }
  else {
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Mode is set to NOT write to database"<<endl;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakeCalStripAtten method... ** "<<endl;
}

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

void LIPlexMaps::MakeCalMIPCalibration(Float_t scale,
                                       Detector::Detector_t det,
                                       SimFlag::ESimFlag simFlag,
                                       VldTimeStamp vldStart,
                                       VldTimeStamp vldEnd,
                                       Int_t aggNo,
                                       Int_t task,
                                       VldTimeStamp creationDate,
                                       std::string dbName,
                                       std::string sLogComment,
                                       Bool_t writeToDb)
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakeCalMIPCalibration() method... **"<<endl; 
  //this->SetDetector(det);

  //make validity range
  VldRange vr(det,simFlag,vldStart,vldEnd,
              "LISummary/LIPlexMaps::MakeCalMIPCalibration");
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Using Validity Range: "<<vr.AsString()<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Other settings used:"<<endl
    <<"aggNo="<<aggNo<<endl
    <<"task="<<task<<endl
    <<"creationDate="<<creationDate<<endl
    <<"dbName="<<dbName<<endl
    <<"sLogComment="<<sLogComment<<endl
    <<"writeToDb="<<writeToDb<<endl;

  //create the writer
  DbiWriter<CalMIPCalibration> writer(vr,aggNo,task,creationDate,dbName,
                                      sLogComment);

  //set these to zero since you only need one entry and the calibrator
  //wont check the values
  Int_t seidkey=0;
  Int_t stripendid=0;

  //create CALADCTOPE table row
  CalMIPCalibration calMIPCalibration(seidkey,stripendid,scale);
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Writing point with:"<<endl
    <<"  seidkey="<<seidkey<<endl
    <<"  stripendid="<<stripendid<<endl
    <<"  scale="<<scale<<endl;

  //write the row to the dbiwriter
  writer<<calMIPCalibration;
        
  MSG("LIPlexMaps",Msg::kInfo)
    <<"DbiWriter.IsOpen="<<writer.IsOpen()<<endl
    <<"DbiWriter.CanOutput="<<writer.CanOutput()<<endl;
  
  if (writeToDb){
    if (this->IsPermitted()){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Writing to database..."<<endl;
      //this is the line that actually writes to the database
      writer.Close();
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Finished writing to database"<<endl;
    }
  }
  else {
    MSG("LIPlexMaps",Msg::kInfo)
      <<"Mode is set to NOT write to database"<<endl;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakeCalMIPCalibration method... ** "<<endl;
}

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

void LIPlexMaps::MakePlexStripEndToLed(Bool_t writeToDb) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the MakePlexStripEndToLed method... ** "
    <<endl;   
  //Thanks to Ryan for the DB code of this method  

  Detector::Detector_t det=Detector::kCalDet;
  
  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,det);
  
  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;

  string sConstantBit="";

  MSG("LIAnalysis",Msg::kInfo)
    <<"sConstantBit="<<sConstantBit<<endl;

  TH2F **hStripVsPlaneLed=0;
  hStripVsPlaneLed= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Led (Crate "+sPb+")";
    hStripVsPlaneLed[i]=new TH2F(fS.c_str(),fS.c_str(),
                                      planeMax[i]-planeMin[i],
                                      planeMin[i],planeMax[i],
                                      bins,firstStripBin,lastStripBin);
    hStripVsPlaneLed[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneLed[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneLed[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneLed[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneLed[i]->SetFillColor(0);
    //hStripVsPlaneLed[i]->SetBit(TH1::kCanRebin);
  }

  //First fill the pin diode table
  VldTimeStamp tsStart=VldTimeStamp(2003,3,1,12,0,0);
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Vld start time: ";
  tsStart.Print();
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl;
  VldTimeStamp tsEnd=VldTimeStamp(2010,1,1,12,0,0);
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Vld end time: ";
  tsEnd.Print();
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl;

  //set validity range
  VldRange vldRng(det,SimFlag::kData,tsStart,tsEnd,
                  "MakePlexStripEndToLed");
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Validity range: ";
  vldRng.Print();
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl;

  VldTimeStamp tsNow; // now!
  VldContext vldNow(det,SimFlag::kData,tsNow);
  PlexHandle plexHandle(vldNow);
  
  //This is the encoding of the ledId.
  //15 bits of 32 are used, only the first 11 are needed to
  //tell you the pulser box and led
  //This was copied from the plex
  //    MSB                          LSB
  //     3         2         1         0
  //    10987654321098765432109876543210
  //                     ddddpppppiiiiii
  //
  //const UInt_t defaultPlexLedId    =  0;
  
  //const UInt_t bitsPlexLedIdLedInBox    =  6; // iiiiii    0:63
  //const UInt_t bitsPlexLedIdPulserBox   =  5; // ppppp     1:31
  //const UInt_t bitsPlexLedIdDetector    =  4; // dddd   near,far,caldet,teststand           

  //Note: The aggregate number in the database is the first eleven
  //bits of the ledId encoding, i.e. just the pulser box and 
  //led information without the detector info  

  //Now try and fill the PlexStripEndToLed
  for(Int_t pb=0;pb<NUMPULSERBOXES;pb++){
    for(Int_t led=4;led<=6;led++){
      //for(Int_t led=FIRSTLED;led<=LASTLED;led++){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Pulser box="<<pb<<", led="<<led<<endl;

      //create the plex led id
      PlexLedId ledId(det,pb,led);

      //0x7ff=2047=eleven 1s which is the led + pulser box bits
      int aggNo=0x7ff & ledId.GetEncoded(); 
      MSG("LIPlexMaps",Msg::kInfo)
        <<"aggNo="<<aggNo<<", encoded="<<ledId.GetEncoded()
        <<", det="<<(ledId.GetEncoded()>>11)<<endl;

      //set log comment
      string logComment="Updated to reflect the state of the detector";
      //set database number
      UInt_t dbNo=1;//1 is the second database in the cascade (string)

      //create the dbi writer
      DbiWriter<PlexStripEndToLed> writer(vldRng,aggNo,0,tsNow,dbNo,
                                          logComment);
      
      MSG("LIPlexMaps",Msg::kInfo)
        <<"DbiWriter.IsOpen="<<writer.IsOpen()<<endl;
      //<<"DbiWriter.CanOutput="<<writer.CanOutput()<<endl;

      //DbiWriter (const VldRange &vr, Int_t aggNo, Dbi::Task task=0, VldTimeStamp creationDate=VldTimeStamp(0, 0), UInt_t dbNo=0,const std::string &LogComment="")

      //loop over all the strips and planes
      for(Int_t plane=FIRSTPLANE;plane<=LASTPLANE;plane++){
        for(Int_t strip=FIRSTSTRIP;strip<=LASTSTRIP;strip++){
          for(Int_t end=FIRSTEND;end<=SECONDEND;end++){

            StripEnd::StripEnd_t stripEndType = StripEnd::kUnknown;         
            if (end==StripEnd::kEast) stripEndType=StripEnd::kEast;
            else if (end==StripEnd::kWest) stripEndType=StripEnd::kWest;

            PlexStripEndId stripEndId(det,plane,strip,stripEndType);
 
            //get the crate associated with the strip and plane
            Int_t crate=plexHandle.GetRawChannelId(stripEndId).
              GetCrate();

            //are readout by the ND
            if (plane==0 && end==1 && (crate==1 || crate==2) &&
                det==Detector::kCalDet){
              crate=0;
              MSG("LIPlexMaps",Msg::kInfo)
                <<"Doing plane 0 caldet hack"<<endl;
            }
            
            //create a plex strip end to led for 
            //current strip and plane
            PlexStripEndToLed stripEndToLed
              (det,plane,strip,stripEndType,pb,
               fLookup.Strip2Led(strip,plane,det,crate));
              //(Detector::kCalDet,1,1,StripEnd::kWest,0,1);


            MSG("LIPlexMaps",Msg::kDebug)
              <<"("<<plane<<";"<<strip<<";"<<stripEndType<<")"
              <<" ("<<pb<<":"<<led<<")"
              <<", strip2led="
              <<fLookup.Strip2Led(strip,plane,det,crate)<<")"
              <<", crate="<<crate
              <<", aggNo="<<stripEndToLed.GetAggregateNo()
              <<endl;

            ReadoutType::Readout_t rt=plexHandle.GetReadoutType
              (plexHandle.GetRawChannelId(stripEndToLed.
                                          GetPlexStripEndId()));
            
            if (rt!=ReadoutType::kScintStrip){
              MSG("LIPlexMaps",Msg::kInfo)
                <<"rt="<<ReadoutType::AsString(rt)<<endl;
              continue;
            }
            
            //check that stripend to led isn't bad
            if(stripEndToLed.GetPlexStripEndId().GetPlane()!=plane ||
               stripEndToLed.GetPlexStripEndId().IsSteel() ||
               stripEndToLed.GetPlexStripEndId().IsVetoShield() ||
               !stripEndToLed.GetPlexStripEndId().IsValid()) {

              MSG("LIPlexMaps",Msg::kInfo)
                <<"Stripend to led was bad: IsSteel="
                <<stripEndToLed.GetPlexStripEndId().IsSteel()
                <<", IsVetoShield="
                <<stripEndToLed.GetPlexStripEndId().IsVetoShield()
                <<", IsValid="
                <<stripEndToLed.GetPlexStripEndId().IsValid()
                <<", GetPlane="
                <<stripEndToLed.GetPlexStripEndId().GetPlane()
                <<", plane="<<plane
                <<endl;
              continue;
            }

            //check that the led and pulser box encoded in the
            //strip end to led are the same as the ledid
            if(stripEndToLed.GetPlexLedId().GetEncoded()==
               ledId.GetEncoded()) {
               
              //if the crate is the same as the pulser box
              //then write to DB
              //this only applies to the far detector since 
              //there are multiple pulser boxes
              if(crate!=pb && det==Detector::kFar) continue;

              MSG("LIPlexMaps",Msg::kInfo)
                <<stripEndToLed.GetAggregateNo()<<" "
                <<stripEndToLed.GetPlexStripEndId().GetPlane()<<" "
                <<stripEndToLed.GetPlexStripEndId().GetStrip()<<" "
                <<stripEndToLed.GetPlexStripEndId().GetEnd()<<" "
                <<stripEndToLed.GetPlexLedId().GetPulserBox()<<" "
                <<stripEndToLed.GetPlexLedId().GetLedInBox()<<endl;
              
              //fill the histo for easy visualisation
              hStripVsPlaneLed[end-1]->Fill
                (stripEndToLed.GetPlexStripEndId().GetPlane(),
                 stripEndToLed.GetPlexStripEndId().GetStrip(),
                 stripEndToLed.GetPlexLedId().GetLedInBox());

              writer<<stripEndToLed;
              
            }//end of if
            else{
              MSG("LIPlexMaps",Msg::kDebug)
                <<"("<<plane<<";"<<strip<<";"<<stripEndType<<")"
                <<" ("<<pb<<":"<<led<<")"
                <<" These don't match: stripend to led encoded="
                <<stripEndToLed.GetPlexLedId().GetEncoded()
                <<", ledid encoded="<<ledId.GetEncoded()
                <<endl;
            }
          }//end of strip end loop
        }//end of strip loop
      }//end of plane loop

      MSG("LIPlexMaps",Msg::kInfo)
        <<"DbiWriter.IsOpen="<<writer.IsOpen()<<endl
        <<"DbiWriter.CanOutput="<<writer.CanOutput()<<endl;

      if (writeToDb){
        if (this->IsPermitted()){
          MSG("LIPlexMaps",Msg::kInfo)
            <<"Writing to database..."<<endl;
          //this is the line that actually writes to the database
          writer.Close();
          MSG("LIPlexMaps",Msg::kInfo)
            <<"Finished writing to database"<<endl;
        }
      }
      else {
        MSG("LIPlexMaps",Msg::kInfo)
          <<"Mode is set to NOT write to database"<<endl;
      }
      
    }//end of led loop
  }//end of pb loop

  //set stats info off
  gStyle->SetOptStat(0);

  TCanvas *cStripVsPlaneLed=new TCanvas  
    ("cStripVsPlaneLed","StripVsPlane: Led",0,0,1000,800);  
  cStripVsPlaneLed->SetFillColor(0);  
  cStripVsPlaneLed->Divide(1,2);  
  cStripVsPlaneLed->cd(1);  
  hStripVsPlaneLed[0]->Draw("textcolz");  
  cStripVsPlaneLed->cd(2);  
  hStripVsPlaneLed[1]->Draw("textcolz");  

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the MakePlexStripEndToLed method... ** "
    <<endl; 
}

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

void LIPlexMaps::ReadDbCalStripToStrip(Int_t det,VldTimeStamp ts,
                                       Int_t task) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbCalStripToStrip() method... ** "<<endl; 
  //this must go first
  this->SetDetector(det);

  const Int_t firstStripBin=FIRSTSTRIP-2;//-8;
  const Int_t lastStripBin=LASTSTRIP+2;//+9, 200;
  const Int_t stripBins=lastStripBin-firstStripBin;

  const Int_t firstPlaneBin=FIRSTPLANE-2;;
  const Int_t lastPlaneBin=LASTPLANE+2;
  const Int_t planeBins=lastPlaneBin-firstPlaneBin;

  TH2F* hStVsPlResp1=new TH2F("hStVsPlResp1","hStVsPlResp1",
                             planeBins,firstPlaneBin,lastPlaneBin,
                             stripBins,firstStripBin,lastStripBin);
  hStVsPlResp1->SetTitle("Detector Response (East side)");
  hStVsPlResp1->GetXaxis()->SetTitle("Plane");
  hStVsPlResp1->GetXaxis()->CenterTitle();
  hStVsPlResp1->GetYaxis()->SetTitle("Strip");
  hStVsPlResp1->GetYaxis()->CenterTitle();
  hStVsPlResp1->SetFillColor(0);

  TH2F* hStVsPlRespErr1=new TH2F("hStVsPlRespErr1","hStVsPlRespErr1",
                             planeBins,firstPlaneBin,lastPlaneBin,
                             stripBins,firstStripBin,lastStripBin);
  hStVsPlRespErr1->SetTitle("Detector Response Error (East side)");
  hStVsPlRespErr1->GetXaxis()->SetTitle("Plane");
  hStVsPlRespErr1->GetXaxis()->CenterTitle();
  hStVsPlRespErr1->GetYaxis()->SetTitle("Strip");
  hStVsPlRespErr1->GetYaxis()->CenterTitle();
  hStVsPlRespErr1->SetFillColor(0);

  TH2F* hStVsPlResp2=new TH2F("hStVsPlResp2","hStVsPlResp2",
                             planeBins,firstPlaneBin,lastPlaneBin,
                             stripBins,firstStripBin,lastStripBin);
  hStVsPlResp2->SetTitle("Detector Response (West side)");
  hStVsPlResp2->GetXaxis()->SetTitle("Plane");
  hStVsPlResp2->GetXaxis()->CenterTitle();
  hStVsPlResp2->GetYaxis()->SetTitle("Strip");
  hStVsPlResp2->GetYaxis()->CenterTitle();
  hStVsPlResp2->SetFillColor(0);

  TH2F* hStVsPlRespErr2=new TH2F("hStVsPlRespErr2","hStVsPlRespErr2",
                             planeBins,firstPlaneBin,lastPlaneBin,
                             stripBins,firstStripBin,lastStripBin);
  hStVsPlRespErr2->SetTitle("Detector Response Error (West side)");
  hStVsPlRespErr2->GetXaxis()->SetTitle("Plane");
  hStVsPlRespErr2->GetXaxis()->CenterTitle();
  hStVsPlRespErr2->GetYaxis()->SetTitle("Strip");
  hStVsPlRespErr2->GetYaxis()->CenterTitle();
  hStVsPlRespErr2->SetFillColor(0);

  TH1F *hResponse=new TH1F("hResponse","hResponse",300,-1,10);
  hResponse->GetXaxis()->SetTitle("Response of Stripends");
  hResponse->GetXaxis()->CenterTitle();
  hResponse->GetYaxis()->SetTitle("");
  hResponse->GetYaxis()->CenterTitle();
  hResponse->SetLineColor(2);
  hResponse->SetFillStyle(3015);
  hResponse->SetFillColor(2);
  hResponse->SetLineWidth(3);
  //hResponse->SetBit(TH1::kCanRebin);

  TH1F *hRespE=new TH1F("hRespE","hRespE",500,-1,10);
  hRespE->GetXaxis()->SetTitle("Response of East Stripends");
  hRespE->GetXaxis()->CenterTitle();
  hRespE->GetYaxis()->SetTitle("");
  hRespE->GetYaxis()->CenterTitle();
  hRespE->SetLineColor(4);
  hRespE->SetFillStyle(3015);
  hRespE->SetFillColor(4);
  hRespE->SetLineWidth(3);
  //hRespE->SetBit(TH1::kCanRebin);

  TH1F *hRespW=new TH1F("hRespW","hRespW",500,-1,10);
  hRespW->GetXaxis()->SetTitle("Response of West Stripends");
  hRespW->GetXaxis()->CenterTitle();
  hRespW->GetYaxis()->SetTitle("");
  hRespW->GetYaxis()->CenterTitle();
  hRespW->SetLineColor(2);
  hRespW->SetFillStyle(3015);
  hRespW->SetFillColor(2);
  hRespW->SetLineWidth(3);
  //hRespW->SetBit(TH1::kCanRebin);

  TH1F *hResponseErr=new TH1F("hResponseErr","hResponseErr",
                              200,-0.02,0.2);
  hResponseErr->GetXaxis()->SetTitle("ResponseErr of Stripends");
  hResponseErr->GetXaxis()->CenterTitle();
  hResponseErr->GetYaxis()->SetTitle("");
  hResponseErr->GetYaxis()->CenterTitle();
  hResponseErr->SetLineColor(3);
  hResponseErr->SetFillStyle(3015);
  hResponseErr->SetFillColor(3);
  hResponseErr->SetLineWidth(3);
  //hResponseErr->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsPlane=new TProfile
    ("pSigCorVsPlane","pSigCorVsPlane",
     planeBins,firstPlaneBin,lastPlaneBin);
  pSigCorVsPlane->GetXaxis()->SetTitle("Plane");
  pSigCorVsPlane->GetXaxis()->CenterTitle();
  pSigCorVsPlane->GetYaxis()->SetTitle("SigCor");
  pSigCorVsPlane->GetYaxis()->CenterTitle();
  pSigCorVsPlane->SetLineColor(2);
  pSigCorVsPlane->SetLineWidth(3);
  //pSigCorVsPlane->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsPlaneCoarse=new TProfile
    ("pSigCorVsPlaneCoarse","pSigCorVsPlaneCoarse",6,0,60);
  pSigCorVsPlaneCoarse->GetXaxis()->SetTitle("Plane");
  pSigCorVsPlaneCoarse->GetXaxis()->CenterTitle();
  pSigCorVsPlaneCoarse->GetYaxis()->SetTitle("SigCor");
  pSigCorVsPlaneCoarse->GetYaxis()->CenterTitle();
  pSigCorVsPlaneCoarse->SetLineColor(2);
  pSigCorVsPlaneCoarse->SetLineWidth(3);
  //pSigCorVsPlaneCoarse->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsPlane1=new TProfile
    ("pSigCorVsPlane1","pSigCorVsPlane1",
     planeBins,firstPlaneBin,lastPlaneBin);
  pSigCorVsPlane1->GetXaxis()->SetTitle("Plane");
  pSigCorVsPlane1->GetXaxis()->CenterTitle();
  pSigCorVsPlane1->GetYaxis()->SetTitle("SigCor");
  pSigCorVsPlane1->GetYaxis()->CenterTitle();
  pSigCorVsPlane1->SetLineColor(2);
  pSigCorVsPlane1->SetLineWidth(3);
  //pSigCorVsPlane1->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsPlane2=new TProfile
    ("pSigCorVsPlane2","pSigCorVsPlane2",
     planeBins,firstPlaneBin,lastPlaneBin);
  pSigCorVsPlane2->GetXaxis()->SetTitle("Plane");
  pSigCorVsPlane2->GetXaxis()->CenterTitle();
  pSigCorVsPlane2->GetYaxis()->SetTitle("SigCor");
  pSigCorVsPlane2->GetYaxis()->CenterTitle();
  pSigCorVsPlane2->SetLineColor(2);
  pSigCorVsPlane2->SetLineWidth(3);
  //pSigCorVsPlane2->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsStrip=new TProfile
    ("pSigCorVsStrip","pSigCorVsStrip",
     stripBins,firstStripBin,lastStripBin);
  pSigCorVsStrip->GetXaxis()->SetTitle("Strip");
  pSigCorVsStrip->GetXaxis()->CenterTitle();
  pSigCorVsStrip->GetYaxis()->SetTitle("SigCor");
  pSigCorVsStrip->GetYaxis()->CenterTitle();
  pSigCorVsStrip->SetLineColor(4);
  pSigCorVsStrip->SetLineWidth(3);
  //pSigCorVsStrip->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsStripCoarse=new TProfile
    ("pSigCorVsStripCoarse","pSigCorVsStripCoarse",12,0,24);
  pSigCorVsStripCoarse->GetXaxis()->SetTitle("Strip");
  pSigCorVsStripCoarse->GetXaxis()->CenterTitle();
  pSigCorVsStripCoarse->GetYaxis()->SetTitle("SigCor");
  pSigCorVsStripCoarse->GetYaxis()->CenterTitle();
  pSigCorVsStripCoarse->SetLineColor(2);
  pSigCorVsStripCoarse->SetLineWidth(3);
  //pSigCorVsStripCoarse->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsStrip1=new TProfile
    ("pSigCorVsStrip1","pSigCorVsStrip1",
     stripBins,firstStripBin,lastStripBin);
  pSigCorVsStrip1->GetXaxis()->SetTitle("Strip");
  pSigCorVsStrip1->GetXaxis()->CenterTitle();
  pSigCorVsStrip1->GetYaxis()->SetTitle("SigCor");
  pSigCorVsStrip1->GetYaxis()->CenterTitle();
  pSigCorVsStrip1->SetLineColor(4);
  pSigCorVsStrip1->SetLineWidth(3);
  //pSigCorVsStrip1->SetBit(TH1::kCanRebin);

  TProfile* pSigCorVsStrip2=new TProfile
    ("pSigCorVsStrip2","pSigCorVsStrip2",
     stripBins,firstStripBin,lastStripBin);
  pSigCorVsStrip2->GetXaxis()->SetTitle("Strip");
  pSigCorVsStrip2->GetXaxis()->CenterTitle();
  pSigCorVsStrip2->GetYaxis()->SetTitle("SigCor");
  pSigCorVsStrip2->GetYaxis()->CenterTitle();
  pSigCorVsStrip2->SetLineColor(4);
  pSigCorVsStrip2->SetLineWidth(3);
  //pSigCorVsStrip2->SetBit(TH1::kCanRebin);

  Float_t avRespSpect=0;
  Float_t avCorSpect=0;
  Float_t avRespSpectCounter=0;
  Float_t avRespCalor=0;
  Float_t avCorCalor=0;
  Float_t avRespCalorCounter=0;
  
  map<Int_t,Float_t> mStripResp1;
  map<Int_t,Float_t> mStripResp2;

  VldContext vldCtx(static_cast<Detector::Detector_t>(det),
                    SimFlag::kData,ts);
  vldCtx.Print();

  DbiResultPtr<CalStripToStrip> dbiCalStripToStrip;  
  UInt_t numRows=dbiCalStripToStrip.NewQuery(vldCtx,task);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<task<<endl
    <<"Looping over rows..."<<endl;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripToStrip* calStripToStrip=dbiCalStripToStrip.GetRow(i);

    Float_t response=calStripToStrip->GetResponse();
    Float_t responseErr=calStripToStrip->GetResponseErr();
    PlexStripEndId seid=calStripToStrip->GetStripEndId();
    Int_t plane=seid.GetPlane();
    Int_t strip=seid.GetStrip();
    Int_t se=seid.GetEnd();

    if (plane==2){
      if (se==1){
        mStripResp1[strip]=response;
      }
      else if (se==2){
        mStripResp2[strip]=response;
      }
    }
    
    pSigCorVsStrip->Fill(strip,response);
    pSigCorVsPlane->Fill(plane,response);

    if (se==StripEnd::kEast){
      hRespE->Fill(response);
      pSigCorVsStrip1->Fill(strip,response);
      pSigCorVsPlane1->Fill(plane,response);
      hStVsPlResp1->Fill(plane,strip,response);
      hStVsPlRespErr1->Fill(plane,strip,responseErr);
    }
    else if (se==StripEnd::kWest){
      hRespW->Fill(response);
      pSigCorVsStrip2->Fill(strip,response);
      pSigCorVsPlane2->Fill(plane,response);
      hStVsPlResp2->Fill(plane,strip,response);
      hStVsPlRespErr2->Fill(plane,strip,responseErr);

      if (plane>120) {
        avRespSpect+=response;
        avCorSpect+=1./response;
        avRespSpectCounter++;
      }
      else {
        avRespCalor+=response;
        avCorCalor+=1./response;
        avRespCalorCounter++;
      }
    }
    else cout<<"Ahhhhh"<<endl;

    hResponse->Fill(response);
    hResponseErr->Fill(responseErr);
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Av response="<<hResponse->GetMean()
    <<" (N="<<hResponse->GetEntries()<<")"<<endl
    <<"  East av response="<<hRespE->GetMean()
    <<" (N="<<hRespE->GetEntries()<<")"<<endl
    <<"  West av response="<<hRespW->GetMean()
    <<" (N="<<hRespW->GetEntries()<<")"<<endl;

  //calc av
  avRespSpect/=avRespSpectCounter;
  avCorSpect/=avRespSpectCounter;
  avRespCalor/=avRespCalorCounter;
  avCorCalor/=avRespCalorCounter;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl
    <<"Calorimeter av response   ="<<avRespCalor
    <<"(N="<<avRespCalorCounter<<")"
    <<endl
    <<"Calorimeter av correction ="<<avCorCalor
    <<endl
    <<"Spectrometer av response  ="<<avRespSpect
    <<"(N="<<avRespSpectCounter<<")"
    <<endl
    <<"Spectrometer av correction="<<avCorSpect
    <<endl;

  for (UInt_t i=0;i<mStripResp2.size();i++){
    cout<<"Strip="<<i<<", response 1="<<mStripResp1[i]
        <<" response 2="<<mStripResp2[i]<<endl;
  }

  TCanvas *cResponse=new TCanvas
    ("cResponse","cResponse",0,0,1000,1000);
  cResponse->SetFillColor(0);
  cResponse->Divide(2,1);
  cResponse->cd(1);
  hResponse->Draw();
  cResponse->cd(2);
  hResponseErr->Draw();

  TCanvas *cPlSt=new TCanvas
    ("cPlSt","cPlSt",0,0,1000,1000);
  cPlSt->SetFillColor(0);
  cPlSt->Divide(1,2);
  cPlSt->cd(1);
  pSigCorVsPlane->Draw();
  cPlSt->cd(2);
  pSigCorVsStrip->Draw();

  TCanvas *cPlSt1_2=new TCanvas
    ("cPlSt1_2","cPlSt1_2",0,0,1000,1000);
  cPlSt1_2->SetFillColor(0);
  cPlSt1_2->Divide(2,2);
  cPlSt1_2->cd(1);
  pSigCorVsPlane1->Draw();
  cPlSt1_2->cd(2);
  pSigCorVsPlane2->Draw();
  cPlSt1_2->cd(3);
  pSigCorVsStrip1->Draw();
  cPlSt1_2->cd(4);
  pSigCorVsStrip2->Draw();

  TCanvas *cStVsPlResp=new TCanvas
    ("cStVsPlResp","cStVsPlResp",0,0,1000,1000);
  cStVsPlResp->SetFillColor(0);
  cStVsPlResp->Divide(1,2);
  cStVsPlResp->cd(1);
  hStVsPlResp1->Draw("colz");
  cStVsPlResp->cd(2);
  hStVsPlResp2->Draw("colz");

  TCanvas *cStVsPlRespErr=new TCanvas
    ("cStVsPlRespErr","cStVsPlRespErr",0,0,1000,1000);
  cStVsPlRespErr->SetFillColor(0);
  cStVsPlRespErr->Divide(1,2);
  cStVsPlRespErr->cd(1);  
  hStVsPlRespErr1->SetMaximum(0.12);
  hStVsPlRespErr2->SetMaximum(0.12);
  hStVsPlRespErr1->Draw("colz");
  cStVsPlRespErr->cd(2);
  hStVsPlRespErr2->Draw("colz");

  cout<<"Printing histos..."<<endl;
  cResponse->Print("stripToStrip.ps[");
  cResponse->Print("stripToStrip.ps");
  cStVsPlResp->Print("stripToStrip.ps");
  cStVsPlRespErr->Print("stripToStrip.ps");
  cPlSt->Print("stripToStrip.ps");
  cPlSt1_2->Print("stripToStrip.ps");
  cResponse->Print("stripToStrip.ps]");
  cout<<"Finished printing histos"<<endl;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the ReadDbCalStripToStrip() method... **"<<endl; 
}

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

void LIPlexMaps::ReadDbCalStripAtten(Int_t det,VldTimeStamp ts, Int_t task) {
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbCalStripToStrip() method... ** "<<endl;
  //this must go first
  this->SetDetector(det);

  TH1F *hShortAmp = new TH1F("hShortAmp","Short Attenuation fraction",200,0,1);
  hShortAmp->GetXaxis()->SetTitle("Short Attenuation fraction");
  hShortAmp->GetXaxis()->CenterTitle();
  hShortAmp->GetYaxis()->SetTitle("");
  hShortAmp->GetYaxis()->CenterTitle();
  hShortAmp->SetLineColor(2);
  hShortAmp->SetFillStyle(3015);
  hShortAmp->SetFillColor(2);
  hShortAmp->SetLineWidth(3);
  //hShortAmp->SetBit(TH1::kCanRebin);

  TH2F *hShortAmpDet = new TH2F("hShortAmpDet","Short Attenuation fraction",282,0,282,96,0,96);
  hShortAmpDet->GetXaxis()->SetTitle("Plane NO.");
  hShortAmpDet->GetXaxis()->CenterTitle();
  hShortAmpDet->GetYaxis()->SetTitle("Strip NO.");
  hShortAmpDet->GetYaxis()->CenterTitle();
  
  TH1F *hLongAmp = new TH1F("hLongAmp","Long Attenuation fraction",200,0,1);
  hLongAmp->GetXaxis()->SetTitle("Long Attenuation fraction");
  hLongAmp->GetXaxis()->CenterTitle();
  hLongAmp->GetYaxis()->SetTitle("");
  hLongAmp->GetYaxis()->CenterTitle();
  hLongAmp->SetLineColor(4);
  hLongAmp->SetFillStyle(3015);
  hLongAmp->SetFillColor(4);
  hLongAmp->SetLineWidth(3);
  // hLongAmp->SetBit(TH1::kCanRebin);

  TH2F *hLongAmpDet = new TH2F("hLongAmpDet","Long Attenuation fraction",282,0,282,96,0,96);
  hLongAmpDet->GetXaxis()->SetTitle("Plane NO.");
  hLongAmpDet->GetXaxis()->CenterTitle();
  hLongAmpDet->GetYaxis()->SetTitle("Strip NO.");
  hLongAmpDet->GetYaxis()->CenterTitle();

  TH1F *hShortLength = new TH1F("hShortLength","Short Attenuation Length",200,0,5.);
  hShortLength->GetXaxis()->SetTitle("Short Attenuation Length (m)");
  hShortLength->GetXaxis()->CenterTitle();
  hShortLength->GetYaxis()->SetTitle("");
  hShortLength->GetYaxis()->CenterTitle();
  hShortLength->SetLineColor(2);
  hShortLength->SetFillStyle(3015);
  hShortLength->SetFillColor(2);
  hShortLength->SetLineWidth(3);
  //hShortLength->SetBit(TH1::kCanRebin);
  
  TH2F *hShortLenDet = new TH2F("hShortLenDet","Short Attenuation Length",282,0,282,96,0,96);
  hShortLenDet->GetXaxis()->SetTitle("Plane NO.");
  hShortLenDet->GetXaxis()->CenterTitle();
  hShortLenDet->GetYaxis()->SetTitle("Strip NO.");
  hShortLenDet->GetYaxis()->CenterTitle();

  TH1F *hLongLength = new TH1F("hLongLength","Long Attenuation Length",200,0,50);
  hLongLength->GetXaxis()->SetTitle("Long Attenuation Length (m)");
  hLongLength->GetXaxis()->CenterTitle();
  hLongLength->GetYaxis()->SetTitle("");
  hLongLength->GetYaxis()->CenterTitle();
  hLongLength->SetLineColor(4);
  hLongLength->SetFillStyle(3015);
  hLongLength->SetFillColor(4);
  hLongLength->SetLineWidth(3);
  //hLongLength->SetBit(TH1::kCanRebin);

  TH2F *hLongLenDet = new TH2F("hLongLenDet","Long Attenuation Length",282,0,282,96,0,96);
  hLongLenDet->GetXaxis()->SetTitle("Plane NO.");
  hLongLenDet->GetXaxis()->CenterTitle();
  hLongLenDet->GetYaxis()->SetTitle("Strip NO.");
  hLongLenDet->GetYaxis()->CenterTitle();

  VldContext vldCtx(static_cast<Detector::Detector_t>(det),SimFlag::kData,ts);
  vldCtx.Print();

  DbiResultPtr<CalStripAtten> dbiCalStripAtten;
  UInt_t numRows = dbiCalStripAtten.NewQuery(vldCtx,task);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<task<<endl
    <<"Looping over rows..."<<endl;

  //plane 0 is the first plane in the ND and is a bookend
  //plane 281 is the last plane in the ND
  //plane 1,11,21,31 is FI ?-view
  //plane 6,16,26,36 is FI ?-view
  //plane 3,5,7,9,  13,15,17,19,  23,25,27,29,  33,35,...PI ?-view
  //plane 2,4,  8,10,12,14,  18,20,22,24,  28,30,... PI ?-view

  //plane 116 is the last FI in the calorimeter
  //plane 120 is the last plane (PI) in the calorimeter
  //plane 121 is the first FI in the spectrometer  
  //plane 281 is the last ND plane
  
  //expect 
  //strips are 0-95(96), pl 8,10: 4-67(64), pl 7,9: 0-63(64)
  //plane 6 has low strips in PI part (I think 0-67)
  //plane 11 has high strips in PI part (I think -95)

  //strips TPos:
  //plane 6 goes -2.64 -> 1.32 m
  //plane 11 goes -1.32 -> 2.64 m
  
  //plane 4,8,10 goes -2.40 -> 0.24 m
  //plane 5,7,9 goes -0.24 -> 2.40 m
  
  //2.64 - 2.40 = 24 cm = 5.85 strips
  //the FI planes "stick out" by ~6 strips

  //Jaijie has 12000 rows
  //I believe that there are 68 scintillator strips in each PI plane 
  //but only 64 are read out
  //96 PI planes in the ND (thus 96*68=6528 strips in PI planes)
  //24 FI planes in ND calorimeter + 33 FI in spect. (24+33=57 total)
  //        =57*96=5472 strips in FI planes

  //total strips in ND (includes strips not read out) is
  //        5472+6528=12000 strips, which agrees with Jiajie's number

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripAtten* calStripAtten=dbiCalStripAtten.GetRow(i);
    Float_t Lambda1 = calStripAtten->GetLambda1();
    Float_t Lambda2 = calStripAtten->GetLambda2();
    Float_t frac1   = calStripAtten->GetFrac1();
    //Float_t frac1err = calStripAtten->GetFrac1Err();    
    //Float_t Lambda1err  = calStripAtten->GetLambda1Err();
    //Float_t Lambda2err  = calStripAtten->GetLambda2Err();
    PlexStripEndId seid = calStripAtten->GetStripEndId();
    Int_t plane = seid.GetPlane();
    Int_t strip = seid.GetStrip();
    //Int_t se = seid.GetEnd();
    
    hShortAmp->Fill(frac1);
    hLongAmp->Fill(1-frac1);
    hShortLength->Fill(Lambda1);
    hLongLength->Fill(Lambda2);
    hShortAmpDet->Fill(plane,strip,frac1);
    hLongAmpDet->Fill(plane,strip,1-frac1);
    hShortLenDet->Fill(plane,strip,Lambda1);
    hLongLenDet->Fill(plane,strip,Lambda2);
  }  
  
  TCanvas *cAtten = new TCanvas("cAtten","Attenuation Parameters",0,0,800,1000);
  cAtten->SetFillColor(0);
  cAtten->Divide(2,2);
  cAtten->cd(1);
  hShortAmp->Draw();
  cAtten->cd(2);
  hLongAmp->Draw();
  cAtten->cd(3);
  hShortLength->Draw();
  cAtten->cd(4);
  hLongLength->Draw();
  
  TCanvas *cDet = new TCanvas("cDet","Attenuation Parameters for All the Strips",0,0,800,1000);
  cDet->SetFillColor(0);
  cDet->Divide(2,2);
  cDet->cd(1);
  hShortAmpDet->Draw("colz");
  cDet->cd(2);
  hLongAmpDet->Draw("colz");
  cDet->cd(3);
  hShortLenDet->Draw("colz");
  cDet->cd(4);
  hLongLenDet->Draw("colz");

  cDet->Print("stripAtten.ps[");
  cDet->Print("stripAtten.ps");
  cAtten->Print("stripAtten.ps");
  cDet->Print("stripAtten.ps]");

  MSG("LIPlexMaps",Msg::kInfo)
      <<endl<<" ** Finished the ReadDbCalStripAtten() method... ** "<<endl;
}

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

void LIPlexMaps::CompareStripToStrip(Int_t det,VldTimeStamp ts,
                                     Int_t taskA,Int_t taskB) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the CompareStripToStrip() method... ** "<<endl;
  //this must go first
  this->SetDetector(det);

  const Int_t firstStripBin=FIRSTSTRIP-2;//-8;
  const Int_t lastStripBin=LASTSTRIP+2;//+9, 200;
  const Int_t stripBins=lastStripBin-firstStripBin;

  const Int_t firstPlaneBin=FIRSTPLANE-2;;
  const Int_t lastPlaneBin=LASTPLANE+2;
  const Int_t planeBins=lastPlaneBin-firstPlaneBin;


  TH1F *hResponse=new TH1F("hResponse","hResponse",300,-1,10);
  hResponse->GetXaxis()->SetTitle("Response of Stripends");
  hResponse->GetXaxis()->CenterTitle();
  hResponse->GetYaxis()->SetTitle("");
  hResponse->GetYaxis()->CenterTitle();
  hResponse->SetLineColor(2);
  hResponse->SetFillStyle(3015);
  hResponse->SetFillColor(2);
  hResponse->SetLineWidth(3);
  //hResponse->SetBit(TH1::kCanRebin);

  TH1F *hResponseErr=new TH1F("hResponseErr","hResponseErr",
                              200,-0.02,0.2);
  hResponseErr->GetXaxis()->SetTitle("ResponseErr of Stripends");
  hResponseErr->GetXaxis()->CenterTitle();
  hResponseErr->GetYaxis()->SetTitle("");
  hResponseErr->GetYaxis()->CenterTitle();
  hResponseErr->SetLineColor(3);
  hResponseErr->SetFillStyle(3015);
  hResponseErr->SetFillColor(3);
  hResponseErr->SetLineWidth(3);
  //hResponseErr->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsPlane=new TProfile
    ("pRatioVsPlane","pRatioVsPlane",
     planeBins,firstPlaneBin,lastPlaneBin);
  pRatioVsPlane->GetXaxis()->SetTitle("Plane");
  pRatioVsPlane->GetXaxis()->CenterTitle();
  pRatioVsPlane->GetYaxis()->SetTitle("Ratio");
  pRatioVsPlane->GetYaxis()->CenterTitle();
  pRatioVsPlane->SetLineColor(2);
  pRatioVsPlane->SetLineWidth(3);
  //pRatioVsPlane->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsPlaneCoarse=new TProfile
    ("pRatioVsPlaneCoarse","pRatioVsPlaneCoarse",6,0,60);
  pRatioVsPlaneCoarse->SetTitle("Ratio of S2S Cal. Const. (Cosmic/PS)");
  pRatioVsPlaneCoarse->GetXaxis()->SetTitle("Plane");
  pRatioVsPlaneCoarse->GetXaxis()->CenterTitle();
  pRatioVsPlaneCoarse->GetYaxis()->SetTitle("Ratio");
  pRatioVsPlaneCoarse->GetYaxis()->CenterTitle();
  pRatioVsPlaneCoarse->SetLineColor(2);
  pRatioVsPlaneCoarse->SetLineWidth(3);
  //pRatioVsPlaneCoarse->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsPlane1=new TProfile
    ("pRatioVsPlane1","pRatioVsPlane1",
     planeBins,firstPlaneBin,lastPlaneBin);
  pRatioVsPlane1->GetXaxis()->SetTitle("Plane");
  pRatioVsPlane1->GetXaxis()->CenterTitle();
  pRatioVsPlane1->GetYaxis()->SetTitle("Ratio");
  pRatioVsPlane1->GetYaxis()->CenterTitle();
  pRatioVsPlane1->SetLineColor(2);
  pRatioVsPlane1->SetLineWidth(3);
  //pRatioVsPlane1->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsPlane2=new TProfile
    ("pRatioVsPlane2","pRatioVsPlane2",
     planeBins,firstPlaneBin,lastPlaneBin);
  pRatioVsPlane2->GetXaxis()->SetTitle("Plane");
  pRatioVsPlane2->GetXaxis()->CenterTitle();
  pRatioVsPlane2->GetYaxis()->SetTitle("Ratio");
  pRatioVsPlane2->GetYaxis()->CenterTitle();
  pRatioVsPlane2->SetLineColor(2);
  pRatioVsPlane2->SetLineWidth(3);
  //pRatioVsPlane2->SetBit(TH1::kCanRebin);

  Int_t coarseStBins=(lastStripBin-firstStripBin)/2;
  TProfile* pRatioVsStripO1=new TProfile
    ("pRatioVsStripO1","pRatioVsStripO1",
     coarseStBins,firstStripBin,lastStripBin);
  pRatioVsStripO1->GetXaxis()->SetTitle("Strip");
  pRatioVsStripO1->GetXaxis()->CenterTitle();
  pRatioVsStripO1->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripO1->GetYaxis()->CenterTitle();
  pRatioVsStripO1->SetLineColor(2);
  pRatioVsStripO1->SetLineWidth(3);
  //pRatioVsStripO1->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripO2=new TProfile
    ("pRatioVsStripO2","pRatioVsStripO2",
     coarseStBins,firstStripBin,lastStripBin);
  pRatioVsStripO2->GetXaxis()->SetTitle("Strip");
  pRatioVsStripO2->GetXaxis()->CenterTitle();
  pRatioVsStripO2->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripO2->GetYaxis()->CenterTitle();
  pRatioVsStripO2->SetLineColor(2);
  pRatioVsStripO2->SetLineWidth(3);
  //pRatioVsStripO2->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripE1=new TProfile
    ("pRatioVsStripE1","pRatioVsStripE1",
     coarseStBins,firstStripBin,lastStripBin);
  pRatioVsStripE1->GetXaxis()->SetTitle("Strip");
  pRatioVsStripE1->GetXaxis()->CenterTitle();
  pRatioVsStripE1->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripE1->GetYaxis()->CenterTitle();
  pRatioVsStripE1->SetLineColor(2);
  pRatioVsStripE1->SetLineWidth(3);
  //pRatioVsStripE1->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripE2=new TProfile
    ("pRatioVsStripE2","pRatioVsStripE2",
     coarseStBins,firstStripBin,lastStripBin);
  pRatioVsStripE2->GetXaxis()->SetTitle("Strip");
  pRatioVsStripE2->GetXaxis()->CenterTitle();
  pRatioVsStripE2->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripE2->GetYaxis()->CenterTitle();
  pRatioVsStripE2->SetLineColor(2);
  pRatioVsStripE2->SetLineWidth(3);
  //pRatioVsStripE2->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStrip=new TProfile
    ("pRatioVsStrip","pRatioVsStrip",
     stripBins,firstStripBin,lastStripBin);
  pRatioVsStrip->GetXaxis()->SetTitle("Strip");
  pRatioVsStrip->GetXaxis()->CenterTitle();
  pRatioVsStrip->GetYaxis()->SetTitle("Ratio");
  pRatioVsStrip->GetYaxis()->CenterTitle();
  pRatioVsStrip->SetLineColor(4);
  pRatioVsStrip->SetLineWidth(3);
  //pRatioVsStrip->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripCoarse=new TProfile
    ("pRatioVsStripCoarse","pRatioVsStripCoarse",12,0,24);
  pRatioVsStripCoarse->SetTitle("Ratio of S2S Cal. Const. (Cosmic/PS)");
  pRatioVsStripCoarse->GetXaxis()->SetTitle("Strip");
  pRatioVsStripCoarse->GetXaxis()->CenterTitle();
  pRatioVsStripCoarse->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripCoarse->GetYaxis()->CenterTitle();
  pRatioVsStripCoarse->SetLineColor(2);
  pRatioVsStripCoarse->SetLineWidth(3);
  //pRatioVsStripCoarse->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripCoarseFront=new TProfile
    ("pRatioVsStripCoarseFront","pRatioVsStripCoarseFront",12,0,24);
  pRatioVsStripCoarseFront->
    SetTitle("Ratio of S2S Cal. Const. Det. Front (Cosmic/PS)");
  pRatioVsStripCoarseFront->GetXaxis()->SetTitle("Strip");
  pRatioVsStripCoarseFront->GetXaxis()->CenterTitle();
  pRatioVsStripCoarseFront->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripCoarseFront->GetYaxis()->CenterTitle();
  pRatioVsStripCoarseFront->SetLineColor(2);
  pRatioVsStripCoarseFront->SetLineWidth(3);
  //pRatioVsStripCoarseFront->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStripCoarseBack=new TProfile
    ("pRatioVsStripCoarseBack","pRatioVsStripCoarseBack",12,0,24);
  pRatioVsStripCoarseBack->
    SetTitle("Ratio of S2S Cal. Const. Det. Back (Cosmic/PS)");
  pRatioVsStripCoarseBack->GetXaxis()->SetTitle("Strip");
  pRatioVsStripCoarseBack->GetXaxis()->CenterTitle();
  pRatioVsStripCoarseBack->GetYaxis()->SetTitle("Ratio");
  pRatioVsStripCoarseBack->GetYaxis()->CenterTitle();
  pRatioVsStripCoarseBack->SetLineColor(2);
  pRatioVsStripCoarseBack->SetLineWidth(3);
  //pRatioVsStripCoarseBack->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStrip1=new TProfile
    ("pRatioVsStrip1","pRatioVsStrip1",
     stripBins,firstStripBin,lastStripBin);
  pRatioVsStrip1->GetXaxis()->SetTitle("Strip");
  pRatioVsStrip1->GetXaxis()->CenterTitle();
  pRatioVsStrip1->GetYaxis()->SetTitle("Ratio");
  pRatioVsStrip1->GetYaxis()->CenterTitle();
  pRatioVsStrip1->SetLineColor(4);
  pRatioVsStrip1->SetLineWidth(3);
  //pRatioVsStrip1->SetBit(TH1::kCanRebin);

  TProfile* pRatioVsStrip2=new TProfile
    ("pRatioVsStrip2","pRatioVsStrip2",
     stripBins,firstStripBin,lastStripBin);
  pRatioVsStrip2->GetXaxis()->SetTitle("Strip");
  pRatioVsStrip2->GetXaxis()->CenterTitle();
  pRatioVsStrip2->GetYaxis()->SetTitle("Ratio");
  pRatioVsStrip2->GetYaxis()->CenterTitle();
  pRatioVsStrip2->SetLineColor(4);
  pRatioVsStrip2->SetLineWidth(3);
  //pRatioVsStrip2->SetBit(TH1::kCanRebin);

  TProfile2D* pStVsPlRatio1=new TProfile2D
    ("pStVsPlRatio1","pStVsPlRatio1",
     planeBins,firstPlaneBin,lastPlaneBin,
     stripBins,firstStripBin,lastStripBin);
  pStVsPlRatio1->GetXaxis()->SetTitle("Plane");
  pStVsPlRatio1->GetXaxis()->CenterTitle();
  pStVsPlRatio1->GetYaxis()->SetTitle("Strip");
  pStVsPlRatio1->GetYaxis()->CenterTitle();
  //pStVsPlRatio1->SetBit(TH1::kCanRebin);

  TProfile2D* pStVsPlRatio2=new TProfile2D
    ("pStVsPlRatio2","pStVsPlRatio2",
     planeBins,firstPlaneBin,lastPlaneBin,
     stripBins,firstStripBin,lastStripBin);
  pStVsPlRatio2->GetXaxis()->SetTitle("Plane");
  pStVsPlRatio2->GetXaxis()->CenterTitle();
  pStVsPlRatio2->GetYaxis()->SetTitle("Strip");
  pStVsPlRatio2->GetYaxis()->CenterTitle();
  //pStVsPlRatio2->SetBit(TH1::kCanRebin);

  map<PlexStripEndId,Float_t> sigCorA;
  map<PlexStripEndId,Float_t> sigCorB;

  VldContext vldCtx(static_cast<Detector::Detector_t>(det),
                    SimFlag::kData,ts);
  vldCtx.Print();
  UInt_t year=0;
  ts.GetDate(true,0,&year);

  DbiResultPtr<CalStripToStrip> dbiCalStripToStrip;

  //get taskA
  UInt_t numRows=dbiCalStripToStrip.NewQuery(vldCtx,taskA);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<taskA<<endl
    <<"Looping over rows..."<<endl;
  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripToStrip* calStripToStrip=dbiCalStripToStrip.GetRow(i);

    Float_t response=calStripToStrip->GetResponse();
    PlexStripEndId seid=calStripToStrip->GetStripEndId();
    sigCorA[seid]=response;
  }

  //now get taskB
  numRows=dbiCalStripToStrip.NewQuery(vldCtx,taskB);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"
    <<", using task="<<taskB<<endl
    <<"Looping over rows..."<<endl;
  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const CalStripToStrip* calStripToStrip=dbiCalStripToStrip.GetRow(i);

    Float_t response=calStripToStrip->GetResponse();
    PlexStripEndId seid=calStripToStrip->GetStripEndId();
    sigCorB[seid]=response;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Found maps, sigCorA size="<<sigCorA.size()
    <<", sigCorB size="<<sigCorB.size()<<endl;
  
  for (map<PlexStripEndId,Float_t>::iterator iterA=sigCorA.begin();
       iterA!=sigCorA.end();++iterA){

    map<PlexStripEndId,Float_t>::iterator iterB=
      sigCorB.find(iterA->first);

    if (iterB==sigCorB.end()){
      MSG("LIPlexMaps",Msg::kWarning)
        <<"Ahhhhhh, missing iterB"<<endl;
      continue;
    }

    Int_t planeA=iterA->first.GetPlane();
    Int_t stripA=iterA->first.GetStrip();
    Int_t seA=iterA->first.GetEnd();
    Int_t planeB=iterB->first.GetPlane();
    Int_t stripB=iterB->first.GetStrip();
    Int_t seB=iterB->first.GetEnd();

    MSG("LIPlexMaps",Msg::kDebug)
      <<"A: st="<<stripA<<", pl="<<planeA<<", se="<<seA<<endl;
    MSG("LIPlexMaps",Msg::kDebug)
      <<"B: st="<<stripB<<", pl="<<planeB<<", se="<<seB<<endl;

    Float_t sigCorDiff=1;
    if (iterB->second!=0){
      //iterA->second-iterB->second;
      sigCorDiff=iterA->second/iterB->second;
    }
    else{
      MSG("LIPlexMaps",Msg::kWarning)<<"Ahh, zero calib constant"<<endl;
    }

    //make bad channel cuts...
    //cut out plane zero, since it is known to be badly calibrated
    if (planeA==0){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Cutting out plane 0. It's known to be bad!"<<endl;
      continue;
    }
    else if (planeA==25 && stripA==5){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Cutting out plane 25, strip 5. It's used to be bad"<<endl;
      continue;
    }
    else if (planeA==35 && year==2002){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Cutting out plane 35. It's bad in 2002"<<endl;
      continue;
    }
    else if ((planeA==56 || planeA==58) && seA==StripEnd::kWest && 
             year==2003){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Cutting out plane 56 & 58. It's bad in 2003"<<endl;
      continue;
    }
    else if ((planeA==33 || planeA==35) && year==2003){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Cutting out plane 33 & 35. It's bad in 2003"<<endl;
      continue;
    }

    //fill strip vs plane maps
    if (seA==StripEnd::kEast){
      pStVsPlRatio1->Fill(planeA,stripA,sigCorDiff);
    }
    else if (seA==StripEnd::kWest){
      pStVsPlRatio2->Fill(planeA,stripA,sigCorDiff);
    }

    //make fiducial volume cut
    if (stripA>=22 || stripA<=1){
      MAXMSG("LIPlexMaps",Msg::kWarning,1)
        <<"Making fiducial volume cut on strip"<<endl;
      continue;
    }

    hResponse->Fill(sigCorDiff);
    pRatioVsStrip->Fill(stripA,sigCorDiff);
    pRatioVsPlane->Fill(planeA,sigCorDiff);
    pRatioVsStripCoarse->Fill(stripA,sigCorDiff);
    if (planeA<=30) pRatioVsStripCoarseFront->Fill(stripA,sigCorDiff);
    if (planeA>30) pRatioVsStripCoarseBack->Fill(stripA,sigCorDiff);
    pRatioVsPlaneCoarse->Fill(planeA,sigCorDiff);

    if (seA==StripEnd::kEast){
      pRatioVsStrip1->Fill(stripA,sigCorDiff);
      pRatioVsPlane1->Fill(planeA,sigCorDiff);
      if (planeA%2==0) pRatioVsStripE1->Fill(stripA,sigCorDiff);
      else if (planeA%2==1) pRatioVsStripO1->Fill(stripA,sigCorDiff);
    }
    else if (seA==StripEnd::kWest){
      pRatioVsStrip2->Fill(stripA,sigCorDiff);
      pRatioVsPlane2->Fill(planeA,sigCorDiff);
      if (planeA%2==0) pRatioVsStripE2->Fill(stripA,sigCorDiff);
      else if (planeA%2==1) pRatioVsStripO2->Fill(stripA,sigCorDiff);
    }
  }
  
  TCanvas *cResponse=new TCanvas
    ("cResponse","cResponse",0,0,1000,800);
  cResponse->SetFillColor(0);
  cResponse->Divide(2,1);
  cResponse->cd(1);
  hResponse->Draw();
  cResponse->cd(2);
  hResponseErr->Draw();

  TCanvas *cPlSt=new TCanvas
    ("cPlSt","cPlSt",0,0,800,1000);
  cPlSt->SetFillColor(0);
  cPlSt->Divide(1,2);
  cPlSt->cd(1);
  pRatioVsPlane->Draw();
  cPlSt->cd(2);
  pRatioVsStrip->Draw();

  TCanvas *cPlStCoarse=new TCanvas
    ("cPlStCoarse","cPlStCoarse",0,0,800,1000);
  cPlStCoarse->SetFillColor(0);
  cPlStCoarse->Divide(1,2);
  cPlStCoarse->cd(1);
  pRatioVsPlaneCoarse->Draw();
  cPlStCoarse->cd(2);
  pRatioVsStripCoarse->Draw();

  TCanvas *cStCoarse=new TCanvas
    ("cStCoarse","cStCoarse",0,0,800,1000);
  cStCoarse->SetFillColor(0);
  cStCoarse->Divide(1,2);
  cStCoarse->cd(1);
  pRatioVsStripCoarseFront->Draw();
  cStCoarse->cd(2);
  pRatioVsStripCoarseBack->Draw();

  TCanvas *cPlSt1_2=new TCanvas
    ("cPlSt1_2","cPlSt1_2",0,0,1000,1000);
  cPlSt1_2->SetFillColor(0);
  cPlSt1_2->Divide(2,2);
  cPlSt1_2->cd(1);
  pRatioVsPlane1->Draw();
  cPlSt1_2->cd(2);
  pRatioVsPlane2->Draw();
  cPlSt1_2->cd(3);
  pRatioVsStrip1->Draw();
  cPlSt1_2->cd(4);
  pRatioVsStrip2->Draw();

  TCanvas *cPlSt1_2OE=new TCanvas
    ("cPlSt1_2OE","cPlSt1_2OE",0,0,1000,1000);
  cPlSt1_2OE->SetFillColor(0);
  cPlSt1_2OE->Divide(2,2);
  cPlSt1_2OE->cd(1);
  pRatioVsStripO1->Draw();
  cPlSt1_2OE->cd(2);
  pRatioVsStripE1->Draw();
  cPlSt1_2OE->cd(3);
  pRatioVsStripO2->Draw();
  cPlSt1_2OE->cd(4);
  pRatioVsStripE2->Draw();

  TCanvas *cStVsPl=new TCanvas
    ("cStVsPl","cStVsPl",0,0,800,800);
  cStVsPl->SetFillColor(0);
  cStVsPl->Divide(1,2);
  cStVsPl->cd(1);
  pStVsPlRatio1->Draw("colz");
  cStVsPl->cd(2);
  pStVsPlRatio2->Draw("colz");

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the CompareStripToStrip() method... **"<<endl;
}

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

void LIPlexMaps::ReadDbGains(Int_t det,SimFlag::ESimFlag simFlag,
                             VldTimeStamp ts,std::string runNumber,std::string sAgg,Int_t task)
{

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbGains() method... ** "<<endl; 

  //set up useful string
  string fileName=runNumber+"GainsDB.dat";
  //open the file
  ofstream TextFile(fileName.c_str());

  //this must go first
  this->SetDetector(det);

  //create pmts to calc detector average
  LIPmt avM64SE1;
  LIPmt avM64SE2;
  LIPmt avM16VA0SE1;
  LIPmt avM16VA0SE2;
  LIPmt avM16VA1SE1;
  LIPmt avM16VA1SE2;
  LIPmt avM16VA2SE1;
  LIPmt avM16VA2SE2;

  //initialise pmts
  avM64SE1.Initialise(64,1);
  avM64SE2.Initialise(64,1);
  avM16VA0SE1.Initialise(16,8);
  avM16VA0SE2.Initialise(16,8);
  avM16VA1SE1.Initialise(16,8);
  avM16VA1SE2.Initialise(16,8);
  avM16VA2SE1.Initialise(16,8);
  avM16VA2SE2.Initialise(16,8);

  //store pointers to all the pmts in a vector
  vector<LIPmt*> vPmts;
  vPmts.push_back(&avM64SE1);
  vPmts.push_back(&avM64SE2);
  vPmts.push_back(&avM16VA0SE1);
  vPmts.push_back(&avM16VA0SE2);
  vPmts.push_back(&avM16VA1SE1);
  vPmts.push_back(&avM16VA1SE2);
  vPmts.push_back(&avM16VA2SE1);
  vPmts.push_back(&avM16VA2SE2);

  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,det);

  //const Int_t firstStripBin=FIRSTSTRIP-2;//-8;
  //const Int_t lastStripBin=LASTSTRIP+2;//+9, 200;
  const Int_t firstStripBin=FIRSTSTRIP-8; //down to -8
  const Int_t lastStripBin=LASTSTRIP+9; //up to 200
  const Int_t bins=lastStripBin-firstStripBin;

  string sConstantBit="";

  MSG("LIAnalysis",Msg::kInfo)
    <<"sConstantBit="<<sConstantBit<<endl;

  TH2F **hStripVsPlaneGain=0;
  hStripVsPlaneGain= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    string sTs=ts.AsString("s");
    //fS="Gains (Crate "+sPb+", "+sTs+")";
    fS="Gains (Crate "+sPb+")";
    hStripVsPlaneGain[i]=new TH2F(fS.c_str(),fS.c_str(),
                                  planeMax[i]-planeMin[i],
                                  planeMin[i],planeMax[i],
                                  bins,firstStripBin,lastStripBin);
    hStripVsPlaneGain[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneGain[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneGain[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneGain[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneGain[i]->SetFillColor(0);
    //hStripVsPlaneGain[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hAvDetGains=0;
  hAvDetGains= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    string sTs=ts.AsString("s");
    //fS="Av Detector Gains (Crate "+sPb+", "+sTs+")";
    fS="Av Detector Gains (Crate "+sPb+")";
    hAvDetGains[i]=new TH2F(fS.c_str(),fS.c_str(),
                                  planeMax[i]-planeMin[i],
                                  planeMin[i],planeMax[i],
                                  bins,firstStripBin,lastStripBin);
    hAvDetGains[i]->GetXaxis()->SetTitle("Plane");
    hAvDetGains[i]->GetXaxis()->CenterTitle();
    hAvDetGains[i]->GetYaxis()->SetTitle("Strip");
    hAvDetGains[i]->GetYaxis()->CenterTitle();
    hAvDetGains[i]->SetFillColor(0);
    //hAvDetGains[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneGainErr=0;
  hStripVsPlaneGainErr= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gain Errors (Crate "+sPb+")";
    hStripVsPlaneGainErr[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneGainErr[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneGainErr[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneGainErr[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneGainErr[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneGainErr[i]->SetFillColor(0);
    //hStripVsPlaneGainErr[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneSPEWidth=0;
  hStripVsPlaneSPEWidth= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Single PE Width (Crate "+sPb+")";
    hStripVsPlaneSPEWidth[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneSPEWidth[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneSPEWidth[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneSPEWidth[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneSPEWidth[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneSPEWidth[i]->SetFillColor(0);
    //hStripVsPlaneSPEWidth[i]->SetBit(TH1::kCanRebin);
  }

  TH1F *hGains=new TH1F("hGains","hGains",200,-1,200);
  hGains->GetXaxis()->SetTitle("Response of Stripends");
  hGains->GetXaxis()->CenterTitle();
  hGains->GetYaxis()->SetTitle("");
  hGains->GetYaxis()->CenterTitle();
  hGains->SetLineColor(2);
  hGains->SetFillStyle(3015);
  hGains->SetFillColor(2);
  hGains->SetLineWidth(3);
  //hGains->SetBit(TH1::kCanRebin);

  TH1F *hGainsAll=new TH1F("hGainsAll","hGainsAll",400,-1,300);
  hGainsAll->GetXaxis()->SetTitle("Response of Stripends");
  hGainsAll->GetXaxis()->CenterTitle();
  hGainsAll->GetYaxis()->SetTitle("");
  hGainsAll->GetYaxis()->CenterTitle();
  hGainsAll->SetLineColor(2);
  hGainsAll->SetFillStyle(3015);
  hGainsAll->SetFillColor(2);
  hGainsAll->SetLineWidth(3);
  hGainsAll->SetBit(TH1::kCanRebin);

  VldContext vldCtx(static_cast<Detector::Detector_t>(det),
                    simFlag,ts);
  vldCtx.Print();

  //create a plex handle
  PlexHandle plexHandle(vldCtx);

  DbiResultPtr<CalADCtoPE> dbiCalADCtoPE;
  DbiResultPtr<CalADCtoPEs> dbiCalADCtoPEs;

  UInt_t numRows=dbiCalADCtoPE.NewQuery(vldCtx,task);
  if(sAgg!="-1") numRows=dbiCalADCtoPEs.NewQuery(vldCtx,task);

  MSG("LIPlexMaps",Msg::kInfo)<<endl
    <<"New DB query produced "<<numRows<<" rows"<<endl
    <<"Looping over rows..."<<endl;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {

    Float_t gain, gainErr, SPEWidth, SPEWidthErr;
    Int_t seId;
    UInt_t seidkey;
    
    if(sAgg=="-1") {
      const CalADCtoPE* calAdcToPe = dbiCalADCtoPE.GetRow(i);
      gain=calAdcToPe->GetGain();
      gainErr=calAdcToPe->GetGainErr();
      SPEWidth=calAdcToPe->GetSPEWidth();
      seId=calAdcToPe->GetStripEndId();
      seidkey=calAdcToPe->GetSEIDkey();
    } else {
      const CalADCtoPEs* calAdcToPe = dbiCalADCtoPEs.GetRow(i);
      gain=calAdcToPe->GetGain();
      gainErr=calAdcToPe->GetGainErr();
      SPEWidth=calAdcToPe->GetSPEWidth();
      SPEWidthErr=calAdcToPe->GetSPEWidthErr();
      seidkey=calAdcToPe->GetSEIDkey();
    }

    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seidkey,static_cast<Detector::
                                   Detector_t>(det),plane,strip,end);

    //fill the gains histos
    hGains->Fill(gain);
    hGainsAll->Fill(gain);

    //get stripend id
    PlexStripEndId seid(static_cast<Detector::Detector_t>(det),
                        plane,strip,
                        static_cast<StripEnd::EStripEnd>(end));
    //get pixel spot id
    PlexPixelSpotId pixSpotId=plexHandle.GetPixelSpotId(seid);

    MSG("LIPlexMaps",Msg::kDebug)
      <<"pl="<<plane<<", st="<<strip<<", end="<<end
      <<", pix="<<pixSpotId.GetPixel()
      <<", pixSpot="<<pixSpotId.GetSpot()
      <<endl;

    ElecType::Elec_t elecType=plexHandle.GetRawChannelId(seid).
      GetElecType();
    Int_t vaChip=plexHandle.GetRawChannelId(seid).GetVaChip();

    //add point to average detector PMT
    //depending on electype and va chip
    if (elecType==ElecType::kQIE){
      if (plane%2==1) avM64SE1.AddMultiPoint(pixSpotId.GetPixel(),
                                             pixSpotId.GetSpot(),gain);
      else if (plane%2==0) avM64SE2.AddMultiPoint(pixSpotId.GetPixel(),
                                                  pixSpotId.GetSpot(),gain);
    }
    else if (elecType==ElecType::kVA){
      if (vaChip==0){
        if (end==1) avM16VA0SE1.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
        if (end==2) avM16VA0SE2.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
      }
      else if (vaChip==1){
        if (end==1) avM16VA1SE1.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
        if (end==2) avM16VA1SE2.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
      }
      else if (vaChip==2){
        if (end==1) avM16VA2SE1.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
        if (end==2) avM16VA2SE2.AddMultiPoint(pixSpotId.GetPixel(),
                                              pixSpotId.GetSpot(),gain);
      }
    }

    PlexPixelSpotId pixelId=plexHandle.GetPixelSpotId(seid);
    //Some values to be written out
    Int_t crate=plexHandle.GetRawChannelId(seid).GetCrate();
    Int_t Varc=plexHandle.GetRawChannelId(seid).GetVarcId();
    Int_t Vmm=plexHandle.GetRawChannelId(seid).GetVmm();
    //Int_t vaChip=plexhandle->GetRawChannelId(seid).GetVaChip();
    Int_t Vaadc=plexHandle.GetRawChannelId(seid).GetVaAdcSel();
    Int_t channel=plexHandle.GetRawChannelId(seid).GetVaChannel();
    Int_t pixel=static_cast<Int_t>(pixelId.GetPixel());
    //Int_t channel=static_cast<Int_t>(pixelId.GetChannel());
    Int_t inRack=static_cast<Int_t>(pixelId.GetInRack());
    Int_t numericMuxBox=static_cast<Int_t>(pixelId.GetNumericMuxBox());
    Int_t rackBay=static_cast<Int_t>(pixelId.GetRackBay());
    Char_t rackLevel=static_cast<Char_t>(pixelId.GetRackLevel());
    Int_t tube=static_cast<Int_t>(pixelId.GetTube());

    //write to file
    TextFile<<plane<<"\t"<<strip<< "\t"<<end
            <<"\t" <<gain<<"\t" <<gainErr<<"\t" <<SPEWidth<<"\t"<<crate<<"\t"<<Varc<<"\t"<<Vmm<<"\t"<<Vaadc<<"\t"<<channel<<"\t"<<pixel
            <<"\t"<<vaChip<<"\t"<<inRack<<"\t"<<numericMuxBox
            <<"\t"<<rackBay<<"\t"<<rackLevel<<"\t"<<tube<<endl;

    if (crate>=FIRSTCRATE && crate<=LASTCRATE){
      hStripVsPlaneGainErr[crate]->Fill(plane,strip,gainErr);
      hStripVsPlaneGain[crate]->Fill(plane,strip,gain);
      hStripVsPlaneSPEWidth[crate]->Fill(plane,strip,SPEWidth);
    }

    Bool_t print=false;
    if (det==Detector::kCalDet) print=true;
    else if (det==Detector::kFar && 
             MsgService::Instance()->
             IsActive("LIPlexMaps",Msg::kDebug)) print=true;
    else if (det==Detector::kNear && 
             MsgService::Instance()->
             IsActive("LIPlexMaps",Msg::kDebug)) print=true;
    
    if (print){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"("<<plane<<";"<<strip<<";"<<end<<")"
        <<" Gain="<<gain<<", gainErr="<<gainErr<<", SPEW="<<SPEWidth<<endl;
        //<<", seId="<<seId<<endl;
        //<<", SPEWErr="<<SPEWidthErr<<endl;
    }
  }

  for (vector<LIPmt*>::iterator it=vPmts.begin(); 
       it!=vPmts.end();it++) {

    if ((*it)->IsEmpty()) cout<<"empty"<<endl;
    else{
      cout<<"not emp"<<endl;
      (*it)->Print();
    }
  }



  for (Int_t pl=*planeMin;pl<*planeMax;pl++){
    for (Int_t st=-1;st<NUMSTRIPS+2;st++){
      for (Int_t se=0;se<NUMSIDES;se++){

        //get stripend id
        PlexStripEndId seid(static_cast<Detector::Detector_t>
                            (det),pl,st,
                            static_cast<StripEnd::EStripEnd>(se+1));
        
        //get pixel ids from strip end
        PlexPixelSpotId psid=plexHandle.GetPixelSpotId(seid);
        ElecType::Elec_t elecType=plexHandle.GetRawChannelId(seid).
          GetElecType();

        if (se+1==StripEnd::kWest && elecType==ElecType::kQIE){
          
          Double_t gain=avM64SE2.GetPixelGain(psid.GetPixel());
          
          hAvDetGains[1]->Fill(pl,st,gain);
        }
      }
    }
  }

  gStyle->SetOptStat(1111111);

  //draw the m64s
  if (!avM64SE1.IsEmpty() || !avM64SE2.IsEmpty()){
    TCanvas *cPmtFaceM64=new TCanvas
      ("cPmtFaceM64","cPmtFaceM64",0,0,1000,550);
    cPmtFaceM64->SetFillColor(0);
    cPmtFaceM64->Divide(2,1);
    cPmtFaceM64->cd(1);
    fS="M64 Gains (U view)"; 
    if (!avM64SE1.IsEmpty()) avM64SE1.GetPmtFaceMap(fS.c_str())->
                                Draw("colztext");
    cPmtFaceM64->cd(2);
    fS="M64 Gains (V view)"; 
    if (!avM64SE2.IsEmpty()) avM64SE2.GetPmtFaceMap(fS.c_str())->
                                Draw("colztext");

    string sDbPmts="DbPmts";
    sDbPmts+=Detector::AsString(static_cast<Detector::
                                     Detector_t>(det));
    sDbPmts+=".ps";
    cPmtFaceM64->Print(sDbPmts.c_str());

  }

  //draw the m16s
  if (!avM16VA0SE1.IsEmpty() || !avM16VA0SE1.IsEmpty() ||
      !avM16VA1SE1.IsEmpty() || !avM16VA1SE1.IsEmpty() ||
      !avM16VA2SE1.IsEmpty() || !avM16VA2SE1.IsEmpty()){

    TCanvas *cPmtFaceM16=new TCanvas
      ("cPmtFaceM16","cPmtFaceM16",0,0,1000,700);
    cPmtFaceM16->SetFillColor(0);
    cPmtFaceM16->Divide(3,2);
    cPmtFaceM16->cd(1);
    fS="M16 Gains (VA0, stripend1)"; 
    if (!avM16VA0SE1.IsEmpty()) avM16VA0SE1.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");
    cPmtFaceM16->cd(2);
    fS="M16 Gains (VA1, stripend1)"; 
    if (!avM16VA1SE1.IsEmpty()) avM16VA1SE1.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");
    cPmtFaceM16->cd(3);
    fS="M16 Gains (VA2, stripend1)"; 
    if (!avM16VA2SE1.IsEmpty()) avM16VA2SE1.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");
    cPmtFaceM16->cd(4);
    fS="M16 Gains (VA0, stripend2)"; 
    if (!avM16VA0SE2.IsEmpty()) avM16VA0SE2.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");
    cPmtFaceM16->cd(5);
    fS="M16 Gains (VA1, stripend2)"; 
    if (!avM16VA1SE2.IsEmpty()) avM16VA1SE2.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");
    cPmtFaceM16->cd(6);
    fS="M16 Gains (VA2, stripend2)"; 
    if (!avM16VA2SE2.IsEmpty()) avM16VA2SE2.GetPmtFaceMap(fS.c_str())->
                                   Draw("colztext");

    string sDbPmts="DbPmts";
    sDbPmts+=Detector::AsString(static_cast<Detector::
                                     Detector_t>(det));
    sDbPmts+=".ps";
    cPmtFaceM16->Print(sDbPmts.c_str());

  }

  //do gains
  TCanvas *cAvDetGain=new TCanvas
    ("cAvDetGain","cAvDetGain",0,0,1000,800);
  cAvDetGain->SetFillColor(0);
  cAvDetGain->cd();
  hAvDetGains[1]->Draw("colz");

  //set stats info off
  gStyle->SetOptStat(0);

  //do gains
  TCanvas *cStripVsPlaneGain=new TCanvas
    ("cStripVsPlaneGain","StripVsPlane: Gain",0,0,1000,800);
  cStripVsPlaneGain->SetFillColor(0);
  cStripVsPlaneGain->cd();
  string sDbGains="DbGains";
  sDbGains+=Detector::AsString(static_cast<Detector::
                                   Detector_t>(det));
  sDbGains+=".ps";
  cStripVsPlaneGain->Print((sDbGains+"[").c_str());
  gErrorIgnoreLevel=1;
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneGain->Clear();
    hStripVsPlaneGain[i]->Draw("colz");
    cStripVsPlaneGain->Print(sDbGains.c_str());
  }
  cStripVsPlaneGain->Print((sDbGains+"]").c_str());
  gErrorIgnoreLevel=0;

  //do gain errs
  TCanvas *cStripVsPlaneGainErr=new TCanvas
    ("cStripVsPlaneGainErr","StripVsPlane: GainErr",0,0,1000,800);
  cStripVsPlaneGainErr->SetFillColor(0);
  cStripVsPlaneGainErr->cd();
  string sDbGainErrs="DbGainErrs";
  sDbGainErrs+=Detector::AsString(static_cast<Detector::
                                       Detector_t>(det));
  sDbGainErrs+=".ps";
  cStripVsPlaneGainErr->Print((sDbGainErrs+"[").c_str());
  gErrorIgnoreLevel=1;
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneGainErr->Clear();
    hStripVsPlaneGainErr[i]->Draw("colz");
    cStripVsPlaneGainErr->Print(sDbGainErrs.c_str());
  }
  cStripVsPlaneGainErr->Print((sDbGainErrs+"]").c_str());
  gErrorIgnoreLevel=0;

  //do SPEWidths
  TCanvas *cStripVsPlaneSPEWidth=new TCanvas
    ("cStripVsPlaneSPEWidth","StripVsPlane: SPEWidth",0,0,1000,800);
  cStripVsPlaneSPEWidth->SetFillColor(0);
  cStripVsPlaneSPEWidth->cd();
  string sDbSPEWidths="DbSPEWidths";
  sDbSPEWidths+=Detector::AsString(static_cast<Detector::
                                       Detector_t>(det));
  sDbSPEWidths+=".ps";
  cStripVsPlaneSPEWidth->Print((sDbSPEWidths+"[").c_str());
  gErrorIgnoreLevel=1;
  for (Int_t i=0;i<NUMCRATES;i++){  
    cStripVsPlaneSPEWidth->Clear();
    hStripVsPlaneSPEWidth[i]->Draw("colz");
    cStripVsPlaneSPEWidth->Print(sDbSPEWidths.c_str());
  }
  cStripVsPlaneSPEWidth->Print((sDbSPEWidths+"]").c_str());
  gErrorIgnoreLevel=0;

  if (det==Detector::kCalDet){
    TCanvas *cGain=new TCanvas("cGain","cGain",0,0,1000,800);
    cGain->SetFillColor(0);
    cGain->Divide(1,2);
    cGain->cd(1);
    hStripVsPlaneGain[0]->Draw("colz");
    cGain->cd(2);
    hStripVsPlaneGain[1]->Draw("colz");
  }
  
  gStyle->SetOptStat(1111);
  TCanvas *cGain=new TCanvas("cGain","cGain",0,0,1000,800);
  cGain->SetFillColor(0);
  cGain->Divide(2,1);
  cGain->cd(1);
  hGains->Draw();
  cGain->cd(2);
  hGainsAll->Draw();

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the ReadDbGains() method... ** "<<endl; 
}

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

Double_t LIPlexMaps::ReadDbGainAverage(Detector::Detector_t det, VldTimeStamp ts, VldTimeStamp *end, VldTimeStamp *start)
{
  // Set up the validity context
  // Would you ever wnat to get gains out of MC?
  VldContext vldCtx(det, SimFlag::kData, ts);
//  vldCtx.Print();
  
  // and the database
  DbiResultPtr<CalADCtoPEs> dbiCalADCtoPEs;
  
  // Work out the task....
  Int_t task = 0;
  if (det == Detector::kNear) task = 1;
  
  // Run the query
  UInt_t numRows = dbiCalADCtoPEs.NewQuery(vldCtx,task);

  // Now run over each row in the query, keeping a running average  
  Double_t gainaverage = 0.0;
  for (UInt_t i = 0; i < numRows; ++i)
  {
    // Grab the query row and extract information
    const CalADCtoPEs* calAdcToPe = dbiCalADCtoPEs.GetRow(i);
    Float_t gain = calAdcToPe->GetGain();

    gainaverage += (gain - gainaverage) / (i+1);    
  }
  
  // If we were passed an 'end' pointer, we want it to be filled with the end of the validity
  VldTimeStamp endtime = dbiCalADCtoPEs.GetValidityRec()->GetVldRange().GetTimeEnd();
  VldTimeStamp starttime = dbiCalADCtoPEs.GetValidityRec()->GetVldRange().GetTimeStart();
  // cout << "End of validity record: " << endtime.AsString() << endl;
  if (end) *end = endtime;
  if (start) *start = starttime;
  return gainaverage;
}

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

TH1D *LIPlexMaps::ReadDbGains(Detector::Detector_t det, VldTimeStamp ts)
{
  // Set up the validity context
  VldContext vldCtx(det, SimFlag::kData, ts);
  // and the database
  DbiResultPtr<CalADCtoPEs> dbiCalADCtoPEs;

  // Work out the task....
  Int_t task = 0;
  if (det == Detector::kNear) task = 1;

  // Run the query
  UInt_t numRows = dbiCalADCtoPEs.NewQuery(vldCtx,task);

  TH1D *detgains = new TH1D("detgains", "detgains", 200, 0, 200);
  if (det == Detector::kNear) {
    detgains->SetNameTitle("neargains", "Near Detector Gains");
  } else {
    detgains->SetNameTitle("fargains", "Far Detector Gains");    
  }
  // Now run over each row in the query, keeping a running average  
  for (UInt_t i = 0; i < numRows; ++i)
  {
    const CalADCtoPEs* calAdcToPe = dbiCalADCtoPEs.GetRow(i);
    Float_t gain = calAdcToPe->GetGain();
    detgains->Fill(gain);
  }

  return detgains;
}

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

void LIPlexMaps::ReadDbPulserDrift(Int_t det,VldTimeStamp ts) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbPulserDrift() method... ** "<<endl; 

  //Thanks to Ryan for the DB code of this method  
  
  this->SetDetector(det);

  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,det);

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;

  string sConstantBit="";

  MSG("LIAnalysis",Msg::kInfo)
    <<"sConstantBit="<<sConstantBit<<endl;

  TH2F **hStripVsPlaneMean=0;
  hStripVsPlaneMean= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Mean (Crate "+sPb+")";
    hStripVsPlaneMean[i]=new TH2F(fS.c_str(),fS.c_str(),
                                  planeMax[i]-planeMin[i],
                                  planeMin[i],planeMax[i],
                                  bins,firstStripBin,lastStripBin);
    hStripVsPlaneMean[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneMean[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneMean[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneMean[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneMean[i]->SetFillColor(0);
    //hStripVsPlaneMean[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneError=0;
  hStripVsPlaneError= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gain Error (Crate "+sPb+")";
    hStripVsPlaneError[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneError[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneError[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneError[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneError[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneError[i]->SetFillColor(0);
    //hStripVsPlaneError[i]->SetBit(TH1::kCanRebin);
  }
  
  TH2F **hStripVsPlaneNumEntries=0;
  hStripVsPlaneNumEntries= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="NumEntries_Crate"+sPb;
    hStripVsPlaneNumEntries[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneNumEntries[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneNumEntries[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneNumEntries[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneNumEntries[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneNumEntries[i]->SetFillColor(0);
    //hStripVsPlaneNumEntries[i]->SetBit(TH1::kCanRebin);
  }

  VldContext vldCtx(static_cast<Detector::Detector_t>(det),
                    SimFlag::kData,ts);
  vldCtx.Print();

  //DbiResultPtr<PulserRawDrift> dbiPulserDrift;
  //DbiResultPtr<PulserRawDriftF> dbiPulserDrift;
  DbiResultPtr<PulserRefDrift> dbiPulserDrift;
  //DbiResultPtr<PulserRefDriftF> dbiPulserDrift;

  UInt_t numRows=dbiPulserDrift.NewQuery(vldCtx,0);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"<<endl
    <<"Looping over rows..."<<endl;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    //const PulserRawDrift* pulserDrift = dbiPulserDrift.GetRow(i);
    //const PulserRawDriftF* pulserDrift = dbiPulserDrift.GetRow(i);
    const PulserRefDrift* pulserDrift = dbiPulserDrift.GetRow(i);
    //const PulserRefDriftF* pulserDrift = dbiPulserDrift.GetRow(i);

    Float_t mean=pulserDrift->GetMean();
    Float_t error=pulserDrift->GetError();
    Float_t numEntries=pulserDrift->GetNumEntries();

    UInt_t seidkey=pulserDrift->GetStripEnd();
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seidkey,static_cast<Detector::
                                   Detector_t>(det),plane,strip,end);

    Int_t crate=Plane2Crate(plane,end,det);
    if (crate>=FIRSTCRATE && crate<=LASTCRATE){
      hStripVsPlaneMean[crate]->Fill(plane,strip,mean);
      hStripVsPlaneError[crate]->Fill(plane,strip,error);
      hStripVsPlaneNumEntries[crate]->Fill(plane,strip,numEntries);
    }

    Bool_t print=false;

    if (det==Detector::kCalDet) print=true;
    else if (det==Detector::kFar && 
             MsgService::Instance()->
             IsActive("LIPlexMaps",Msg::kDebug)) print=true;
    else if (det==Detector::kNear && 
             MsgService::Instance()->
             IsActive("LIPlexMaps",Msg::kDebug)) print=true;
    
    if (print){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"("<<plane<<";"<<strip<<";"<<end<<")"
        <<" Mean="<<mean<<", error="<<error<<", numEnt="<<numEntries
        <<", seidkey="<<seidkey<<endl;
    }
  }
  //finished loop over the rows

  //set stats info off
  gStyle->SetOptStat(0);

  //do the means
  TCanvas *cStripVsPlaneMean=new TCanvas
    ("cStripVsPlaneMean","StripVsPlane: Mean",0,0,1000,800);
  cStripVsPlaneMean->SetFillColor(0);
  cStripVsPlaneMean->cd();
  string sDbMeans="DbDrift";
  sDbMeans+=Detector::AsString(static_cast<Detector::
                                   Detector_t>(det));
  sDbMeans+=".ps";
  cStripVsPlaneMean->Print((sDbMeans+"[").c_str());
  gErrorIgnoreLevel=1;
  //set stats info off
  gStyle->SetOptStat(0);
  for (Int_t i=0;i<NUMCRATES;i++){
    cStripVsPlaneMean->Clear();
    hStripVsPlaneMean[i]->Draw("colz");
    cStripVsPlaneMean->Print(sDbMeans.c_str());
  }
  //close the file
  cStripVsPlaneMean->Print((sDbMeans+"]").c_str());
  gErrorIgnoreLevel=0;

  TCanvas *cStripVsPlaneError=new TCanvas  
    ("cStripVsPlaneError","StripVsPlane: Error",0,0,1000,800);  
  cStripVsPlaneError->SetFillColor(0);  
  cStripVsPlaneError->Divide(1,2);  
  cStripVsPlaneError->cd(1);  
  hStripVsPlaneError[0]->Draw("colz");  
  cStripVsPlaneError->cd(2);  
  hStripVsPlaneError[1]->Draw("colz");  

  TCanvas *cStripVsPlaneNumEntries=new TCanvas  
    ("cStripVsPlaneNumEntries","StripVsPlane: NumEntries",
     0,0,1000,800);  
  cStripVsPlaneNumEntries->SetFillColor(0);  
  cStripVsPlaneNumEntries->Divide(1,2);  
  cStripVsPlaneNumEntries->cd(1);  
  hStripVsPlaneNumEntries[0]->Draw("colz");  
  cStripVsPlaneNumEntries->cd(2);  
  hStripVsPlaneNumEntries[1]->Draw("colz");  

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the ReadDbPulserDrift() method... ** "<<endl; 
}

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

void LIPlexMaps::DriftWithTime(VldRange vldRng,
                               Float_t pointSpacingMinutes) 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the DriftWithTime method... ** "<<endl; 

  //get all the info from the validity range
  VldTimeStamp startTime=vldRng.GetTimeStart();
  VldTimeStamp endTime=vldRng.GetTimeEnd();
  const Detector::Detector_t det=static_cast
    <Detector::Detector_t>(vldRng.GetDetectorMask());
  const SimFlag::ESimFlag simFlag=static_cast
    <SimFlag::ESimFlag>(vldRng.GetSimMask());

  //make a vld context for the start time
  VldContext startVldCtx(det,simFlag,startTime);

  //only set detector once at the highest/first point
  if (det==Detector::kCalDet){
    fLookup.SetDetector(static_cast<Int_t>(det));
  }
  else if (det==Detector::kFar){
    fLookup.SetDetector(static_cast<Int_t>(det));
  }
  else if (det==Detector::kNear){
    fLookup.SetDetector(static_cast<Int_t>(det));
  }
  else{
    MSG("LIPlexMaps",Msg::kWarning)
      <<"Detector not supported="
      <<Detector::AsString(det)<<endl
      <<"Program will exit here..."<<endl;
    exit(1);
  }

  DbiResultPtr<PulserRawDrift> dbiPulserDrift;
  DbiResultPtr<PulserRawDriftF> dbiPulserDriftF;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Creating maps..."<<endl;
  //a map to hold the reference pin info
  map<Int_t,LIPulserPin> refAdcPinRatio=this->
    GetRefAdcPinRatio(startVldCtx);//get it once to start with
  //maps to hold drift point info
  map<UInt_t,LIRun> stripEnds;
  map<PlexLedId,LIRun> pins;

  VldContext* vldCtx=0;
  const PulserRawDrift *pulserDrift;
  const PulserRawDriftF *pulserDriftF;
  string sLastVldRange="Not set!";

  //declare stripendtype
  StripEnd::EStripEnd stripEndType=StripEnd::kUnknown;
  StripEnd::EStripEnd stripEndTypeF=StripEnd::kUnknown;

  //create a plex handle
  PlexHandle* plexHandle=0;

  Int_t pointSpacingSecs=static_cast<Int_t>(pointSpacingMinutes*60);
  Int_t startTimeSecs=startTime.GetSec();
  Int_t endTimeSecs=endTime.GetSec();
  Int_t secCounter=startTimeSecs;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Starting main loop over vld range..."<<endl;
  while(secCounter<endTimeSecs){
    VldTimeStamp currentLoopTime(secCounter,0);

    //print out the current loop time
    if (MsgService::Instance()->IsActive("LIPlexMaps",Msg::kInfo)){
      MSG("LIPlexMaps",Msg::kInfo)<<"New Loop ";
      currentLoopTime.Print();
    }
    vldCtx=new VldContext(Detector::kCalDet,SimFlag::kData,
                          currentLoopTime);

    //check for a new pin reference point
    map<Int_t,LIPulserPin> tempRefAdcPinRatio=
      this->GetRefAdcPinRatio(*vldCtx);
    if (tempRefAdcPinRatio.size()>0){
      refAdcPinRatio=tempRefAdcPinRatio;
      MSG("LIPlexMaps",Msg::kInfo)
        <<"New pin reference point, regenerated map"<<endl;
    }
    else{
      MSG("LIPlexMaps",Msg::kDebug)
        <<"Checked for new pin reference point, doing nothing"
        <<" because same as before"<<endl;
    }

    //create a plex handle
    plexHandle=new PlexHandle(*vldCtx);

    UInt_t numRows=dbiPulserDrift.NewQuery(*vldCtx,0);
    
    if (numRows!=static_cast<UInt_t>(NUMPLANES*NUMSTRIPS*NUMENDS)){
      MSG("LIPlexMaps",Msg::kWarning)
        <<"PulserRawDrift only contains "<<numRows<<" rows"
        <<", it should have "<<NUMPLANES*NUMSTRIPS*NUMENDS<<endl;
    }

    string sVldRange=dbiPulserDrift.GetValidityRec()->GetVldRange().
      AsString();

    MSG("LIPlexMaps",Msg::kVerbose)
      <<"Vld range = "<<sVldRange<<endl;

    if (sVldRange==sLastVldRange){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Skipping this point because validity range is the same"
        <<" as the previous point"<<endl;
      MSG("LIPlexMaps",Msg::kDebug)
        <<endl
        <<"VldRange="<<sVldRange<<endl
        <<"Previous VldRange="<<sLastVldRange<<endl;
      //set the last range now it has been used in this loop
      sLastVldRange=sVldRange;

      //increment the time
      secCounter+=pointSpacingSecs;
        
      //delete currentLoopTime;
      delete vldCtx;
      delete plexHandle;
      continue;
    }

    //set the last range now it has been used in this loop
    sLastVldRange=sVldRange;

    map<Int_t,Float_t> rawPin=this->GetRawPinMap(*vldCtx);
    map<PlexLedId,LIPulserPin> rawPinLedMap=this->
      GetRawPinLedMap(*vldCtx);
    UInt_t numRowsF=dbiPulserDriftF.NewQuery(*vldCtx,0);

    if (numRows!=numRowsF){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Near and far end tables are different sizes! Near="
        <<numRows<<", far="<<numRowsF<<endl;
    }

    //loop over the pin values for all the leds
    for(Int_t pb=FIRSTPULSERBOX;pb<=LASTPULSERBOX;pb++){
      for(Int_t led=FIRSTLED;led<=LASTLED;led++){
        //create an ledid to then use the encoded value
        PlexLedId ledId(det,pb,led);

        //add the point
        pins[ledId].AddPoint
          (secCounter,rawPinLedMap[ledId].mean,
           rawPinLedMap[ledId].error,rawPinLedMap[ledId].numEnt);

        MSG("LIPlexMaps",Msg::kDebug)
          <<"Adding point to lirun "<<rawPinLedMap[ledId].mean<<endl;
      }
    }
    
    for(Int_t pl=FIRSTPLANE;pl<=LASTPLANE;pl++){
        
      //quick hack
      if (pl>5) continue;

      for(Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++){
        for(Int_t end=FIRSTEND;end<=SECONDEND;end++){

          if (end==StripEnd::kEast) stripEndType=StripEnd::kEast;
          else if (end==StripEnd::kWest) stripEndType=StripEnd::kWest;

          if (end==StripEnd::kEast) stripEndTypeF=StripEnd::kWest;
          else if(end==StripEnd::kWest) stripEndTypeF=StripEnd::kEast;

          PlexStripEndId stripEndId(det,pl,st,stripEndType);
          PlexStripEndId stripEndIdF(det,pl,st,stripEndTypeF);

          //skip the stripends that aren't attached to readout
          if (!this->IsScintStrip(stripEndId,plexHandle)) continue;

          pulserDrift=0;//initialise
          pulserDrift=dbiPulserDrift.GetRowByIndex
            (stripEndId.BuildPlnStripEndKey());
          //get the opposite strip end for the to do ND/FD
          pulserDriftF=0;//initialise
          pulserDriftF=dbiPulserDriftF.GetRowByIndex
            (stripEndIdF.BuildPlnStripEndKey());

          if (pulserDrift){
            Float_t mean=pulserDrift->GetMean();
            Float_t error=pulserDrift->GetError();
            Float_t numEntries=pulserDrift->GetNumEntries();
            UInt_t seidkey=pulserDrift->GetStripEnd();

            Float_t meanF=-1;
            Float_t errorF=-1;
            Float_t numEntriesF=-1;

            if (pulserDriftF){
              meanF=pulserDriftF->GetMean();
              errorF=pulserDriftF->GetError();
              numEntriesF=pulserDriftF->GetNumEntries();
            }

            Float_t nearOverFar=-1;
            if (meanF>0){
              if (stripEndType==StripEnd::kWest){
                nearOverFar=mean/meanF;
              }
              else if (stripEndType==StripEnd::kEast){
                nearOverFar=meanF/mean;
              }
            }

            Float_t adcPinRatio=-1;
            if (rawPin[seidkey]>0){
              adcPinRatio=mean/rawPin[seidkey];
            }
            else {
              MSG("LIPlexMaps",Msg::kDebug)
                <<"Raw pin has zero mean!"<<endl;
            }

            Float_t gainDrift=-1;
            if (refAdcPinRatio[seidkey].mean>0){//protect fpe
              if (adcPinRatio>0){//only bother if this is good
                gainDrift=adcPinRatio/refAdcPinRatio[seidkey].mean;
              }
            }
            else {
              MSG("LIPlexMaps",Msg::kWarning)
                <<"Ref ADC/PIN ratio has zero mean!"<<endl;
            }

            MSG("LIPlexMaps",Msg::kDebug)
              <<"Gain drift="<<gainDrift<<endl;
              
            if (numEntries>500 && gainDrift>0){
              stripEnds[seidkey].AddPoint(secCounter,mean,error,
                                          numEntries,gainDrift,
                                          nearOverFar);
            }
              
            Int_t plane=-1;
            Int_t strip=-1;
            Int_t end=-1;
            fLookup.UnencodePlnStripEndKey(seidkey,det,plane,strip,
                                           end);
              
            string sMean=Form("%.1f",mean);
            string sError=Form("%.2f",error);
            string sNumEntries=Form("%.0f",numEntries);
            string sSeId=Form("%d",seidkey);

            MSG("LIPlexMaps",Msg::kDebug)
              <<"("<<plane<<";"<<strip<<";"<<end<<")"
              <<" Mean="<<sMean<<", error="<<sError
              <<", numEnt="<<sNumEntries
              <<", seidkey="<<sSeId<<endl;
          }
        }
      }
    }

    //increment the time
    secCounter+=pointSpacingSecs;

    //delete currentLoopTime;
    delete vldCtx;
    delete plexHandle;
  }
  //}
  
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Finished main loop over vld range"<<endl;

  //declare the canvas sizes
  Int_t canvasXmax=1200;
  Int_t canvasYmax=600;

  //create the canvases
  TCanvas *cMeanVsTime=new TCanvas("cMeanVsTime","MeanVsTime",
                                   0,0,canvasXmax,canvasYmax);
  cMeanVsTime->SetFillColor(0);
  TCanvas *cErrorVsTime=new TCanvas("cErrorVsTime","ErrorVsTime",
                                    0,0,canvasXmax,canvasYmax);
  cErrorVsTime->SetFillColor(0);
  TCanvas *cNumEntVsTime=new TCanvas("cNumEntVsTime","NumEntVsTime",
                                     0,0,canvasXmax,canvasYmax);
  cNumEntVsTime->SetFillColor(0);
  TCanvas *cGainDriftVsTime=new TCanvas("cGainDriftVsTime",
                                        "GainDriftVsTime",
                                        0,0,canvasXmax,canvasYmax);
  cGainDriftVsTime->SetFillColor(0);
  TCanvas *cGainDriftVsTimeZoom=new TCanvas("cGainDriftVsTimeZoom",
                                        "GainDriftVsTimeZoom",
                                        0,0,canvasXmax,canvasYmax);
  cGainDriftVsTimeZoom->SetFillColor(0);
  TCanvas *cPinVsTime=new TCanvas("cPinVsTime","PinVsTime",
                                   0,0,canvasXmax,canvasYmax);
  cPinVsTime->SetFillColor(0);
  TCanvas *cNormPinVsTime=new TCanvas("cNormPinVsTime","NormPinVsTime",
                                      0,0,canvasXmax,canvasYmax);
  cNormPinVsTime->SetFillColor(0);
  TCanvas *cNormPinVsTimeZoom=new TCanvas("cNormPinVsTimeZoom",
                                          "NormPinVsTimeZoom",
                                          0,0,canvasXmax,canvasYmax);
  cNormPinVsTimeZoom->SetFillColor(0);
  TCanvas *cPinErrorVsTime=new TCanvas("cPinErrorVsTime",
                                       "PinErrorVsTime",
                                       0,0,canvasXmax,canvasYmax);
  cPinErrorVsTime->SetFillColor(0);
  TCanvas *cPinNumEntVsTime=new TCanvas("cPinNumEntVsTime",
                                        "PinNumEntVsTime",
                                        0,0,canvasXmax,canvasYmax);
  cPinNumEntVsTime->SetFillColor(0);
  TCanvas *cNearOverFarVsTime=new TCanvas("cNearOverFarVsTime",
                                    "NearOverFarVsTime",
                                    0,0,canvasXmax,canvasYmax);
  cNearOverFarVsTime->SetFillColor(0);
  TCanvas *cNormNearOverFarVsTime=new TCanvas("cNormNearOverFarVsTime",
                                    "NormNearOverFarVsTime",
                                    0,0,canvasXmax,canvasYmax);
  cNormNearOverFarVsTime->SetFillColor(0);

  string sMeanVsTime="MeanVsTime.ps";
  string sErrorVsTime="ErrorVsTime.ps";
  string sNumEntVsTime="NumEntVsTime.ps";
  string sGainDriftVsTime="GainDriftVsTime.ps";
  string sGainDriftVsTimeZoom="GainDriftVsTimeZoom.ps";
  string sPinVsTime="PinVsTime.ps";
  string sNormPinVsTime="NormPinVsTime.ps";
  string sNormPinVsTimeZoom="NormPinVsTimeZoom.ps";
  string sPinErrorVsTime="PinErrorVsTime.ps";
  string sPinNumEntVsTime="PinNumEntVsTime.ps";
  string sNearOverFarVsTime="NearOverFarVsTime.ps";
  string sNormNearOverFarVsTime="NormNearOverFarVsTime.ps";

  //open the files
  cMeanVsTime->Print((sMeanVsTime+"[").c_str());
  cErrorVsTime->Print((sErrorVsTime+"[").c_str());
  cNumEntVsTime->Print((sNumEntVsTime+"[").c_str());
  cGainDriftVsTime->Print((sGainDriftVsTime+"[").c_str());
  cGainDriftVsTimeZoom->Print((sGainDriftVsTimeZoom+"[").c_str());
  cPinVsTime->Print((sPinVsTime+"[").c_str());
  cNormPinVsTime->Print((sNormPinVsTime+"[").c_str());
  cNormPinVsTimeZoom->Print((sNormPinVsTimeZoom+"[").c_str());
  cPinErrorVsTime->Print((sPinErrorVsTime+"[").c_str());
  cPinNumEntVsTime->Print((sPinNumEntVsTime+"[").c_str());
  cNearOverFarVsTime->Print((sNearOverFarVsTime+"[").c_str());
  cNormNearOverFarVsTime->Print((sNormNearOverFarVsTime+"[").c_str());

  gErrorIgnoreLevel=1;//suppress printing each page messages

  //Loop over the pins
  map<PlexLedId,LIRun>::iterator pinIt=pins.begin();

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Iterating over the pins..."<<endl;
  while(pinIt!=pins.end()){

    //get the vectors, the names are all wrong but 
    //the correct values were stored above
    vector<Double_t> vTime=pinIt->second.GetPh();
    vector<Double_t> vMean=pinIt->second.GetAdc();
    vector<Double_t> vError=pinIt->second.GetPin(1);
    vector<Double_t> vNumEnt=pinIt->second.GetPin(2);

    TGraph* gPinVsTime=0;
    TGraph* gNormPinVsTime=0;
    TGraph* gNormPinVsTimeZoom=0;
    TGraph* gPinErrorVsTime=0;
    TGraph* gPinNumEntVsTime=0;
    
    gPinVsTime=TGraphVect(vTime,vMean);
    gPinErrorVsTime=TGraphVect(vTime,vError);
    gPinNumEntVsTime=TGraphVect(vTime,vNumEnt);

    string sPb=Form("%d",pinIt->first.GetPulserBox());
    string sLed=Form("%d",pinIt->first.GetLedInBox());

    MSG("LIPlexMaps",Msg::kInfo)
      <<"Printing ("<<sPb<<":"<<sLed<<")"
      <<" to postscript"<<endl;

    cPinVsTime->cd();
    cPinVsTime->Clear();
    fS="Light level drifts (PIN ADC) with time (PB,LED)=("+
      sPb+","+sLed+")";
    gPinVsTime->Draw("AP");
    gPinVsTime->SetTitle(fS.c_str());
    gPinVsTime->GetYaxis()->SetTitle("Pin ADC");
    gPinVsTime->GetYaxis()->CenterTitle();
    this->SetGraphAxisEtc(gPinVsTime,startTimeSecs,endTimeSecs);

    //normalise the vector then get the graph
    this->NormaliseVector(vMean,2);
    gNormPinVsTime=TGraphVect(vTime,vMean);
    gNormPinVsTimeZoom=TGraphVect(vTime,vMean);

    cNormPinVsTime->cd();
    cNormPinVsTime->Clear();
    fS="Fractional Drifts in PIN ADC with time (PB,LED)=("+
      sPb+","+sLed+")";
    gNormPinVsTime->Draw("AP");
    gNormPinVsTime->SetTitle(fS.c_str());
    gNormPinVsTime->GetYaxis()->SetTitle("Normalised Pin ADC");
    gNormPinVsTime->GetYaxis()->CenterTitle();
    this->SetGraphAxisEtc(gNormPinVsTime,startTimeSecs,endTimeSecs); 

    cNormPinVsTimeZoom->cd();
    cNormPinVsTimeZoom->Clear();
    fS="Fractional Drifts in PIN ADC with time, zoomed (PB,LED)=("+
      sPb+","+sLed+")";
    gNormPinVsTimeZoom->Draw("AP");
    gNormPinVsTimeZoom->SetTitle(fS.c_str());
    gNormPinVsTimeZoom->GetYaxis()->SetTitle("Normalised Pin ADC");
    gNormPinVsTimeZoom->GetYaxis()->CenterTitle();
    this->SetGraphAxisEtc(gNormPinVsTimeZoom,startTimeSecs,endTimeSecs);
    gNormPinVsTimeZoom->SetMinimum(0.97);
    gNormPinVsTimeZoom->SetMaximum(1.03);
    //gNormPinVsTimeZoom->SetMinimum(1.13);
    //gNormPinVsTimeZoom->SetMaximum(1.23);

    cPinErrorVsTime->cd();
    cPinErrorVsTime->Clear();
    fS="Error on the PIN vs time (PB,LED)=("+
      sPb+","+sLed+")";
    gPinErrorVsTime->Draw("AP");
    gPinErrorVsTime->SetTitle(fS.c_str());
    gPinErrorVsTime->GetYaxis()->SetTitle("PinError in ADCs");
    gPinErrorVsTime->GetYaxis()->CenterTitle();
    this->SetGraphAxisEtc(gPinErrorVsTime,startTimeSecs,endTimeSecs); 

    cPinNumEntVsTime->cd();
    cPinNumEntVsTime->Clear();
    fS="PIN Number of Entries vs Time (PB,LED)=("+
      sPb+","+sLed+")";
    gPinNumEntVsTime->Draw("AP");
    gPinNumEntVsTime->SetTitle(fS.c_str());
    gPinNumEntVsTime->GetYaxis()->SetTitle("Pin's Number of Entries");
    gPinNumEntVsTime->GetYaxis()->CenterTitle();
    this->SetGraphAxisEtc(gPinNumEntVsTime,startTimeSecs,endTimeSecs); 

    //print to postscript
    cPinVsTime->Print(sPinVsTime.c_str());
    cNormPinVsTime->Print(sNormPinVsTime.c_str());
    cNormPinVsTimeZoom->Print(sNormPinVsTimeZoom.c_str());
    cPinErrorVsTime->Print(sPinErrorVsTime.c_str());
    cPinNumEntVsTime->Print(sPinNumEntVsTime.c_str());

    //avoid program getting too big
    delete gPinVsTime;
    delete gNormPinVsTime;
    delete gNormPinVsTimeZoom;
    delete gPinErrorVsTime;
    delete gPinNumEntVsTime;
    
    //go to next pin
    pinIt++;
  }
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Finished iterating over the pins"<<endl;

  //Now look at the stripends
  map<UInt_t,LIRun>::iterator seIt=stripEnds.begin();
  Int_t pageCounter=0;

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<"Iterating over the stripends..."
    <<endl<<"Map size="<<stripEnds.size()<<endl;
  while(seIt!=stripEnds.end()){

    Int_t seidkey=seIt->first;
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seidkey,det,plane,strip,end);

    string sPlane=Form("%d",plane);
    string sStrip=Form("%d",strip);
    string sEnd=Form("%d",end);

    //get the vectors, the names are all wrong but 
    //the correct values were stored above
    vector<Double_t> vTime=seIt->second.GetPh();
    vector<Double_t> vMean=seIt->second.GetAdc();
    vector<Double_t> vError=seIt->second.GetPin(1);
    vector<Double_t> vNumEnt=seIt->second.GetPin(2);
    vector<Double_t> vGainDrift=seIt->second.GetAdcF();
    vector<Double_t> vGainDriftZoom=seIt->second.GetAdcF();
    vector<Double_t> vNearOverFar=seIt->second.GetAdcLow();

    TGraph* gMeanVsTime=0;
    TGraph* gErrorVsTime=0;
    TGraph* gNumEntVsTime=0;
    TGraph* gGainDriftVsTime=0;
    TGraph* gGainDriftVsTimeZoom=0;
    TGraph* gNearOverFarVsTime=0;
    TGraph* gNormNearOverFarVsTime=0;
    
    gMeanVsTime=TGraphVect(vTime,vMean);
    gErrorVsTime=TGraphVect(vTime,vError);
    gNumEntVsTime=TGraphVect(vTime,vNumEnt);
    gGainDriftVsTime=TGraphVect(vTime,vGainDrift);
    gGainDriftVsTimeZoom=TGraphVect(vTime,vGainDriftZoom);

    gNearOverFarVsTime=0;
    if (vNearOverFar.size()>0){
      gNearOverFarVsTime=TGraphVect(vTime,vNearOverFar);
    }

    if (gMeanVsTime){
      cMeanVsTime->cd();
      cMeanVsTime->Clear();
      fS="Mean drifting with time (Pl,St,End)=("+sPlane+","+sStrip+","+
        sEnd+")";
      gMeanVsTime->Draw("AP");
      gMeanVsTime->SetTitle(fS.c_str());
      gMeanVsTime->GetYaxis()->SetTitle("Mean ADC");
      gMeanVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gMeanVsTime,startTimeSecs,endTimeSecs); 
    }
    else{
      //go to next se
      seIt++;
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Skipping: ("<<plane<<";"<<strip<<";"<<end<<")"<<endl;
      continue;
    }

    if (gErrorVsTime){
      cErrorVsTime->cd();
      cErrorVsTime->Clear();
      fS="Error on mean over time (Pl,St,End)=("+sPlane+","+sStrip+","+
        sEnd+")";
      gErrorVsTime->Draw("AP");
      gErrorVsTime->SetTitle(fS.c_str());
      gErrorVsTime->GetYaxis()->SetTitle("Error (ADCs)");
      gErrorVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gErrorVsTime,startTimeSecs,endTimeSecs); 
    }

    if (gNumEntVsTime){
      cNumEntVsTime->cd();
      cNumEntVsTime->Clear();
      fS="NumEnt over time (Pl,St,End)=("+sPlane+","+sStrip+","+
        sEnd+")";
      gNumEntVsTime->Draw("AP");
      gNumEntVsTime->SetTitle(fS.c_str());
      gNumEntVsTime->GetYaxis()->SetTitle("NumEnt");
      gNumEntVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gNumEntVsTime,startTimeSecs,endTimeSecs);
    }

    if (gGainDriftVsTime){
      cGainDriftVsTime->cd();
      cGainDriftVsTime->Clear();
      fS="Gain drift over time (Pl,St,End)=("+sPlane+","+sStrip+","+
        sEnd+")";
      gGainDriftVsTime->Draw("AP");
      gGainDriftVsTime->SetTitle(fS.c_str());
      gGainDriftVsTime->GetYaxis()->SetTitle("Gain Drift");
      gGainDriftVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gGainDriftVsTime,startTimeSecs,
                            endTimeSecs); 
    }
      
    if (gGainDriftVsTimeZoom){
      cGainDriftVsTimeZoom->cd();
      cGainDriftVsTimeZoom->Clear();
      fS="Gain drift over time - zoomed (Pl,St,End)=("+
        sPlane+","+sStrip+","+sEnd+")";
      gGainDriftVsTimeZoom->Draw("AP");
      gGainDriftVsTimeZoom->SetTitle(fS.c_str());
      gGainDriftVsTimeZoom->GetYaxis()->SetTitle("Gain Drift");
      gGainDriftVsTimeZoom->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gGainDriftVsTimeZoom,startTimeSecs,
                            endTimeSecs);  
      gGainDriftVsTimeZoom->SetMaximum(1.11);
      gGainDriftVsTimeZoom->SetMinimum(0.89);
    }

    if (gNearOverFarVsTime){
      cNearOverFarVsTime->cd();
      cNearOverFarVsTime->Clear();
      fS="Ratio of ND/FD vs Time (Pl,St,End)=("+
        sPlane+","+sStrip+","+sEnd+")";
      gNearOverFarVsTime->Draw("AP");
      gNearOverFarVsTime->SetTitle(fS.c_str());
      gNearOverFarVsTime->GetYaxis()->SetTitle("Ratio ND/FD");
      gNearOverFarVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gNearOverFarVsTime,startTimeSecs,
                            endTimeSecs);
    }
    
    gNormNearOverFarVsTime=0;
    if (vNearOverFar.size()>0){
      this->NormaliseVector(vNearOverFar);
      gNormNearOverFarVsTime=TGraphVect(vTime,vNearOverFar);
    }

    if (gNormNearOverFarVsTime){
      cNormNearOverFarVsTime->cd();
      cNormNearOverFarVsTime->Clear();
      fS="Ratio of Normalised ND/FD vs Time (Pl,St,End)=("+
        sPlane+","+sStrip+","+sEnd+")";
      gNormNearOverFarVsTime->Draw("AP");
      gNormNearOverFarVsTime->SetTitle(fS.c_str());
      gNormNearOverFarVsTime->GetYaxis()->SetTitle("Ratio ND/FD");
      gNormNearOverFarVsTime->GetYaxis()->CenterTitle();
      this->SetGraphAxisEtc(gNormNearOverFarVsTime,startTimeSecs,
                            endTimeSecs);
    }

    //print to postscript
    cMeanVsTime->Print(sMeanVsTime.c_str());
    cErrorVsTime->Print(sErrorVsTime.c_str());
    cNumEntVsTime->Print(sNumEntVsTime.c_str());
    cGainDriftVsTime->Print(sGainDriftVsTime.c_str());
    cGainDriftVsTimeZoom->Print(sGainDriftVsTimeZoom.c_str());
    cNearOverFarVsTime->Print(sNearOverFarVsTime.c_str());
    cNormNearOverFarVsTime->Print(sNormNearOverFarVsTime.c_str());

    //avoid program getting too big
    MSG("LIPlexMaps",Msg::kVerbose)
      <<"Deleting graphs..."<<endl;
    delete gMeanVsTime;
    delete gErrorVsTime;
    delete gNumEntVsTime;
    delete gGainDriftVsTime;
    delete gGainDriftVsTimeZoom;
    delete gNearOverFarVsTime;
    delete gNormNearOverFarVsTime;

    pageCounter++;
    if (pageCounter%50==0){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Number of pages = "<<pageCounter<<endl;
    }
    else {
      MSG("LIPlexMaps",Msg::kVerbose)
        <<"Number of pages = "<<pageCounter<<endl;
    }

    //go to next se
    seIt++;
  }
  
  //close the files
  gErrorIgnoreLevel=0;//turn on printing messages 
  cMeanVsTime->Print((sMeanVsTime+"]").c_str());
  cErrorVsTime->Print((sErrorVsTime+"]").c_str());
  cNumEntVsTime->Print((sNumEntVsTime+"]").c_str());
  cGainDriftVsTime->Print((sGainDriftVsTime+"]").c_str());
  cGainDriftVsTimeZoom->Print((sGainDriftVsTimeZoom+"]").c_str());
  cNearOverFarVsTime->Print((sNearOverFarVsTime+"]").c_str());
  cNormNearOverFarVsTime->Print((sNormNearOverFarVsTime+"]").c_str());

  cPinVsTime->Print((sPinVsTime+"]").c_str());
  cNormPinVsTime->Print((sNormPinVsTime+"]").c_str());
  cNormPinVsTimeZoom->Print((sNormPinVsTimeZoom+"]").c_str());
  cPinErrorVsTime->Print((sPinErrorVsTime+"]").c_str());
  cPinNumEntVsTime->Print((sPinNumEntVsTime+"]").c_str());

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the DriftWithTime method... ** "<<endl; 
}

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

void LIPlexMaps::SetGraphAxisEtc(TGraph* g,Int_t startTimeSecs,
                                 Int_t endTimeSecs) 
{
  MSG("LIPlexMaps",Msg::kVerbose)
    <<endl<<" ** Running the SetGraphAxisEtc method... ** "<<endl;

  TDatime startDatime;
  startDatime.Set(startTimeSecs);

  TDatime endDatime;
  endDatime.Set(endTimeSecs);

  //play around with the formatting a little
  string sStartHour=Form("%d",startDatime.GetHour());
  string sStartMinute=Form("%d",startDatime.GetMinute());
  string sStartSecond=Form("%d",startDatime.GetSecond());
  string sStartYear=Form("%d",startDatime.GetYear());
  string sStartMonth=Form("%d",startDatime.GetMonth());
  string sStartDay=Form("%d",startDatime.GetDay());
  if (startDatime.GetHour()<10) sStartHour="0"+sStartHour;
  if (startDatime.GetMinute()<10) sStartMinute="0"+sStartMinute;
  if (startDatime.GetSecond()<10) sStartSecond="0"+sStartSecond;
  if (startDatime.GetMonth()<10) sStartMonth="0"+sStartMonth;
  if (startDatime.GetDay()<10) sStartDay="0"+sStartDay;

  //play around with the formatting a little
  string sEndHour=Form("%d",endDatime.GetHour());
  string sEndMinute=Form("%d",endDatime.GetMinute());
  string sEndSecond=Form("%d",endDatime.GetSecond());
  string sEndYear=Form("%d",endDatime.GetYear());
  string sEndMonth=Form("%d",endDatime.GetMonth());
  string sEndDay=Form("%d",endDatime.GetDay());
  if (endDatime.GetHour()<10) sEndHour="0"+sEndHour;
  if (endDatime.GetMinute()<10) sEndMinute="0"+sEndMinute;
  if (endDatime.GetSecond()<10) sEndSecond="0"+sEndSecond;
  if (endDatime.GetMonth()<10) sEndMonth="0"+sEndMonth;
  if (endDatime.GetDay()<10) sEndDay="0"+sEndDay;

  static Bool_t firstTime=true;
  if (firstTime){
    MSG("LIAnalysis",Msg::kInfo) 
      <<"Setting graph axis info:"<<endl;
    MSG("LIAnalysis",Msg::kInfo) 
      <<"  Start time "<<sStartHour
      <<":"<<sStartMinute
      <<":"<<sStartSecond
      <<" on "<<startDatime.GetYear()
      <<"/"<<sStartMonth
      <<"/"<<sStartDay
      <<endl;
    
    MSG("LIAnalysis",Msg::kInfo) 
      <<"  End time "<<sEndHour
      <<":"<<sEndMinute
      <<":"<<sEndSecond
      <<" on "<<endDatime.GetYear()
      <<"/"<<sEndMonth
      <<"/"<<sEndDay
      <<endl;
  }
  firstTime=false;

  Int_t timeRange=endTimeSecs-startTimeSecs;

  //check graph pointer is not null
  if (g){
    if (sStartDay==sEndDay && timeRange<1*24*60*60){
      string title="Time ("+sStartYear+"/"+sStartMonth+"/"+sStartDay+")";
      g->GetXaxis()->SetTitle(title.c_str());
      g->GetXaxis()->SetTimeFormat("%H:%M");
    }
    else if (timeRange>1*24*60*60 && timeRange<2*24*60*60){//1-2 days
      string title="Time ("+sStartYear+"/"+sStartMonth+"/"+sStartDay
        +" - "+sEndYear+"/"+sEndMonth+"/"+sEndDay+")";
      g->GetXaxis()->SetTitle(title.c_str());
      g->GetXaxis()->SetTimeFormat("%H:%M");
    }
    else if (timeRange>2*24*60*60 && timeRange<5*24*60*60){//2-5 days
      string title="Time ("+sStartYear+"/"+sStartMonth+"/"+sStartDay
        +" - "+sEndYear+"/"+sEndMonth+"/"+sEndDay+")";
      g->GetXaxis()->SetTitle(title.c_str());
      g->GetXaxis()->SetTimeFormat("%H:%M-%d/%m");
    }
    else{
      string title="Time ("+sStartYear+"/"+sStartMonth+"/"+sStartDay
        +" - "+sEndYear+"/"+sEndMonth+"/"+sEndDay+")";
      g->GetXaxis()->SetTitle(title.c_str());
      g->GetXaxis()->SetTimeFormat("%H:%M-%d/%m");
      //stop it cramming loads of days on the axis!
      g->GetXaxis()->SetNdivisions(506);
      //n = N1 + 100*N2 + 10000*N3
      //N1=number of primary divisions.
      //N2=number of secondary divisions.
      //N3=number of 3rd divisions.
    }
    
    //other x-axis defaults
    g->GetXaxis()->SetTimeDisplay(1);
    g->GetXaxis()->CenterTitle();
    
    //other defaults
    g->SetMarkerStyle(3);
    g->SetMarkerColor(2);
    g->SetMarkerSize(0.35);
    g->SetLineColor(46);
  }
  else{
    MSG("LIPlexMaps",Msg::kError)
      <<"Input graph pointer is null!"
      <<" Will do nothing."<<endl;
  }

  MSG("LIPlexMaps",Msg::kVerbose)
    <<endl<<" ** Finished the SetGraphAxisEtc method... **"<<endl;
}

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

void LIPlexMaps::ReadDbPulserRawGain() 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbPulserRawGain() method... ** "<<endl;

  //Thanks to Ryan for the DB code of this method  
  
  Int_t detectorType=4;

  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,detectorType);

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;

  string sConstantBit="";

  MSG("LIAnalysis",Msg::kInfo)
    <<"sConstantBit="<<sConstantBit<<endl;

  Int_t mycrates=5;

  TH2F **hStripVsPlaneGain=0;
  hStripVsPlaneGain= new TH2F*[mycrates];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gain (Crate "+sPb+")";
    hStripVsPlaneGain[i]=new TH2F(fS.c_str(),fS.c_str(),
                                  planeMax[i]-planeMin[i],
                                  planeMin[i],planeMax[i],
                                  bins,firstStripBin,lastStripBin);
    hStripVsPlaneGain[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneGain[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneGain[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneGain[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneGain[i]->SetFillColor(0);
    //hStripVsPlaneGain[i]->SetBit(TH1::kCanRebin);
  }

  TH2F **hStripVsPlaneError=0;
  hStripVsPlaneError= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="Gain Error (Crate "+sPb+")";
    hStripVsPlaneError[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneError[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneError[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneError[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneError[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneError[i]->SetFillColor(0);
    //hStripVsPlaneError[i]->SetBit(TH1::kCanRebin);
  }
  
  TH2F **hStripVsPlaneNumEntries=0;
  hStripVsPlaneNumEntries= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="NumEntries_Crate"+sPb;
    hStripVsPlaneNumEntries[i]=new TH2F(fS.c_str(),fS.c_str(),
                                     planeMax[i]-planeMin[i],
                                     planeMin[i],planeMax[i],
                                     bins,firstStripBin,lastStripBin);
    hStripVsPlaneNumEntries[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneNumEntries[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneNumEntries[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneNumEntries[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneNumEntries[i]->SetFillColor(0);
    //hStripVsPlaneNumEntries[i]->SetBit(TH1::kCanRebin);
  }

  Detector::Detector_t det=Detector::kCalDet;

  VldTimeStamp tsNow;
  VldContext vldNow(det,SimFlag::kData,tsNow);

  DbiResultPtr<PulserRawGain> dbiPulserRawGain;

  UInt_t numRows=dbiPulserRawGain.NewQuery(vldNow,0);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"<<endl;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const PulserRawGain* pulserRawGain=dbiPulserRawGain.GetRow(i);

    Float_t gain=*pulserRawGain->GetMean();
    Float_t error=*pulserRawGain->GetError();
    Float_t numEntries=*pulserRawGain->GetNumEntries();

    UInt_t seidkey=pulserRawGain->GetStripEnd();
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seidkey,det,plane,strip,end);

    hStripVsPlaneGain[end-1]->Fill(plane,strip,gain);
    hStripVsPlaneError[end-1]->Fill(plane,strip,error);
    hStripVsPlaneNumEntries[end-1]->Fill(plane,strip,numEntries);

    MSG("LIPlexMaps",Msg::kInfo)
      <<"("<<plane<<";"<<strip<<";"<<end<<")"
      <<" gain="<<gain<<", error="<<error<<", numEnt="<<numEntries
      <<", seidkey="<<seidkey<<endl;
  }
  //finished loop over the rows

  //set stats info off
  gStyle->SetOptStat(0);

  TCanvas *cStripVsPlaneGain=new TCanvas  
    ("cStripVsPlaneGain","StripVsPlane: Gain",0,0,1000,800);  
  cStripVsPlaneGain->SetFillColor(0);  
  cStripVsPlaneGain->Divide(1,2);  
  cStripVsPlaneGain->cd(1);  
  hStripVsPlaneGain[0]->Draw("colz");  
  cStripVsPlaneGain->cd(2);  
  hStripVsPlaneGain[1]->Draw("colz");  

  TCanvas *cStripVsPlaneError=new TCanvas  
    ("cStripVsPlaneError","StripVsPlane: Error",0,0,1000,800);  
  cStripVsPlaneError->SetFillColor(0);  
  cStripVsPlaneError->Divide(1,2);  
  cStripVsPlaneError->cd(1);  
  hStripVsPlaneError[0]->Draw("colz");  
  cStripVsPlaneError->cd(2);  
  hStripVsPlaneError[1]->Draw("colz");  

  TCanvas *cStripVsPlaneNumEntries=new TCanvas  
    ("cStripVsPlaneNumEntries","StripVsPlane: NumEntries",
     0,0,1000,800);  
  cStripVsPlaneNumEntries->SetFillColor(0);  
  cStripVsPlaneNumEntries->Divide(1,2);  
  cStripVsPlaneNumEntries->cd(1);  
  hStripVsPlaneNumEntries[0]->Draw("colz");  
  cStripVsPlaneNumEntries->cd(2);  
  hStripVsPlaneNumEntries[1]->Draw("colz");  

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the ReadDbPulserRawGain() method... **"<<endl;
}

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

void LIPlexMaps::RatioRawToRefDrift()
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the RatioRawToRefDrift() method... ** "<<endl; 

  //Thanks to Ryan for the DB code of this method  
  
  Int_t detectorType=4;

  Int_t* planeMax=new Int_t[NUMCRATES];
  Int_t* planeMin=new Int_t[NUMCRATES];
  fLookup.SetPbPlanes(planeMin,planeMax,detectorType);

  const Int_t firstStripBin=FIRSTSTRIP-8;//-8;
  const Int_t lastStripBin=LASTSTRIP+9;//200;
  const Int_t bins=lastStripBin-firstStripBin;

  string sConstantBit="";

  MSG("LIAnalysis",Msg::kInfo)
    <<"sConstantBit="<<sConstantBit<<endl;

  TH2F **hStripVsPlaneRawToRef=0;
  hStripVsPlaneRawToRef= new TH2F*[NUMCRATES];
  for (Int_t i=0;i<NUMCRATES;i++){
    string sPb=Form("%d",i);
    fS="RawToRef (Crate "+sPb+")";
    hStripVsPlaneRawToRef[i]=new TH2F(fS.c_str(),fS.c_str(),
                                  planeMax[i]-planeMin[i],
                                  planeMin[i],planeMax[i],
                                  bins,firstStripBin,lastStripBin);
    hStripVsPlaneRawToRef[i]->GetXaxis()->SetTitle("Plane");
    hStripVsPlaneRawToRef[i]->GetXaxis()->CenterTitle();
    hStripVsPlaneRawToRef[i]->GetYaxis()->SetTitle("Strip");
    hStripVsPlaneRawToRef[i]->GetYaxis()->CenterTitle();
    hStripVsPlaneRawToRef[i]->SetFillColor(0);
    //hStripVsPlaneRawToRef[i]->SetBit(TH1::kCanRebin);
  }

  Detector::Detector_t det=Detector::kCalDet;
  VldTimeStamp tsNow;
  VldContext vldNow(det,SimFlag::kData,tsNow);

  DbiResultPtr<PulserRawDrift> dbiPulserRawDrift;
  DbiResultPtr<PulserRefDrift> dbiPulserRefDrift;

  UInt_t numRowsRaw=dbiPulserRawDrift.NewQuery(vldNow,0);
  UInt_t numRowsRef=dbiPulserRefDrift.NewQuery(vldNow,0);

  if (numRowsRef!=numRowsRaw) {
    MSG("LIPlexMaps",Msg::kError)
      <<"Raw and Ref PulserDrift tables are different sizes"<<endl;
      //<<"Program will exit here..."<<endl;
    //exit(0);
  }

  UInt_t numRows=numRowsRaw;
  if (numRowsRaw>numRowsRef) numRows=numRowsRef;

  MSG("LIPlexMaps",Msg::kInfo)
    <<"Using "<<numRows<<" rows"<<endl;

  map<Int_t,PulserRawDrift> rawDrift;
  map<Int_t,PulserRefDrift> refDrift;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
    const PulserRawDrift* pulserRawDrift=dbiPulserRawDrift.GetRow(i);
    const PulserRefDrift* pulserRefDrift=dbiPulserRefDrift.GetRow(i);

    //insert into map
    rawDrift[pulserRawDrift->GetStripEnd()]=*pulserRawDrift;
    refDrift[pulserRefDrift->GetStripEnd()]=*pulserRefDrift;
  }
  //finished loop over the rows

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

  map<Int_t,PulserRawDrift>::iterator raw=rawDrift.begin();
  map<Int_t,PulserRefDrift>::iterator ref=refDrift.begin();

  //now loop over map
  while(raw!=rawDrift.end()){

    Float_t meanRaw=raw->second.GetMean();
    Float_t errorRaw=raw->second.GetError();
    Float_t numEntriesRaw=raw->second.GetNumEntries();
    UInt_t seidkeyRaw=raw->first;
    Int_t planeRaw=-1;
    Int_t stripRaw=-1;
    Int_t endRaw=-1;
    fLookup.UnencodePlnStripEndKey(seidkeyRaw,det,planeRaw,stripRaw,
                                   endRaw);

    Float_t meanRef=ref->second.GetMean();
    Float_t errorRef=ref->second.GetError();
    Float_t numEntriesRef=ref->second.GetNumEntries();
    UInt_t seidkeyRef=ref->first;
    Int_t planeRef=-1;
    Int_t stripRef=-1;
    Int_t endRef=-1;
    fLookup.UnencodePlnStripEndKey(seidkeyRef,det,planeRef,stripRef,
                                   endRef);
    
    //check sanity of procedure
    if (seidkeyRef!=seidkeyRaw){
      MSG("LIPlexMaps",Msg::kError)
        <<"Raw and Ref seidkeys are different"<<endl;
        //<<"Program will exit here..."<<endl;
      //exit(0);
      raw++;
      ref++;    
      continue;
    }

    //protect against fpe
    if (meanRef>0){
      hStripVsPlaneRawToRef[endRef-1]->Fill(planeRef,stripRef,
                                            meanRaw/meanRef);
    }

    //get lots of strings
    string sMeanRaw=Form("%.1f",meanRaw);
    string sErrorRaw=Form("%.2f",errorRaw);
    string sNumEntriesRaw=Form("%.0f",numEntriesRaw);
    string sSeIdRaw=Form("%.1f",seidkeyRaw);

    string sMeanRef=Form("%.1f",meanRef);
    string sErrorRef=Form("%.2f",errorRef);
    string sNumEntriesRef=Form("%.0f",numEntriesRef);
    string sSeIdRef=Form("%.1f",seidkeyRef);

    string sMeanDif=Form("%.1f",meanRef-meanRaw);
    string sErrorDif=Form("%.2f",errorRef-errorRaw);
    string sNumEntriesDif=Form("%.0f",numEntriesRef-numEntriesRaw);
    string sSeIdDiff=Form("%.1f",seidkeyRef-seidkeyRaw);

    MSG("LIPlexMaps",Msg::kInfo)
      <<endl
      <<"Ref (m,er,num,seid)=("<<sMeanRef<<";"<<sErrorRef
      <<";"<<sNumEntriesRef<<";"<<sSeIdRef<<")"
      <<endl
      <<"Raw (m,er,num,seid)=("<<sMeanRaw<<";"<<sErrorRaw
      <<";"<<sNumEntriesRaw<<";"<<sSeIdRaw<<")"
      <<endl
      <<"Diff (m,er,num,seid)=("<<sMeanDif<<";"<<sErrorDif
      <<";"<<sNumEntriesDif<<";"<<sSeIdDiff<<")"
      <<endl;

    raw++;
    ref++;    
  }

  //set stats info off
  gStyle->SetOptStat(0);

  TCanvas *cStripVsPlaneRawToRef=new TCanvas  
    ("cStripVsPlaneRawToRef","StripVsPlane: RawToRef",0,0,1000,800);  
  cStripVsPlaneRawToRef->SetFillColor(0);  
  cStripVsPlaneRawToRef->Divide(1,2);  
  cStripVsPlaneRawToRef->cd(1);  
  hStripVsPlaneRawToRef[0]->Draw("colz");  
  cStripVsPlaneRawToRef->cd(2);  
  hStripVsPlaneRawToRef[1]->Draw("colz");  

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the RatioRawToRefDrift() method... ** "
    <<endl; 
}


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

map<Int_t,Float_t> LIPlexMaps::GetRawPinMap(VldContext vldCtx) 
{
  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Running the GetRawPinMap method... **"<<endl;

  Detector::Detector_t det=Detector::kCalDet;
  StripEnd::EStripEnd stripEndType = StripEnd::kUnknown;

  PlexHandle *plexHandle=new PlexHandle(vldCtx);   

  DbiResultPtr<PulserRawDriftPin> driftRawPin;
  UInt_t numRowsPin=driftRawPin.NewQuery(vldCtx,0);

  if (numRowsPin!=static_cast<UInt_t>(NUMLEDS*NUMPULSERBOXES*2)){
    MSG("LIPlexMaps",Msg::kWarning)
      <<"PulserRawDriftPin only contains "<<numRowsPin<<" rows"<<endl;
  }
  map<Int_t,Float_t> pinAdc;

  Int_t mapEntCounter=0;

  //loop over the pin rows
  for(UInt_t i=0;i<numRowsPin;i++) {

    //get the raw pin
    const PulserRawDriftPin* rawPin=driftRawPin.GetRow(i);
      
    PlexLedId ledId=plexHandle->GetLedId(rawPin->GetPinDiodeId());

    pair<PlexPinDiodeId,PlexPinDiodeId> plexPins=plexHandle->
      GetPinDiodeIds(ledId); // hi, low

    //ignore the low gain for now
    if (rawPin->GetPinDiodeId()==plexPins.second) continue;

    MSG("LIPlexMaps",Msg::kDebug)
      <<"Got high gain pin:"<<endl;
    if (MsgService::Instance()->IsActive("LIPlexMaps",Msg::kDebug)){
      rawPin->GetPinDiodeId().Print();
    }

    for(Int_t pl=FIRSTPLANE;pl<=LASTPLANE;pl++){
      for(Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++){
        for(Int_t end=FIRSTEND;end<=SECONDEND;end++){
          
          if (end==StripEnd::kEast) stripEndType=StripEnd::kEast;
          else if (end==StripEnd::kWest) stripEndType=StripEnd::kWest;
          
          PlexStripEndId stripEndId(det,pl,st,stripEndType);
          
          PlexLedId currentSELedId=plexHandle->GetLedId(stripEndId);

          if (currentSELedId==ledId){
            pinAdc[stripEndId.BuildPlnStripEndKey()]=rawPin->GetMean();
            
            MSG("LIPlexMaps",Msg::kVerbose)
              <<"Filling map, mean="<<rawPin->GetMean()<<endl;
            mapEntCounter++;
          }
        }
      }
    }
  }

  if (mapEntCounter!=NUMPLANES*NUMSTRIPS*NUMENDS){
    MSG("LIPlexMaps",Msg::kWarning)
      <<"Only "<<mapEntCounter<<" entries added to pin map"<<endl;
  }

  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Finished the GetRawPinMap method... ** "<<endl; 
  return pinAdc;
}

//......................................................................
/*
map<Int_t,LIPulserPin> LIPlexMaps::GetPulserRawDrift
(DbiResultPtr<PulserRawDrift> dbiPulserRawDrift,VldContext vldCtx) 
{
  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Running the GetPulserRawDrift method... **"<<endl;

  UInt_t numRowsDrift=dbiPulserRawDrift.NewQuery(vldCtx,0);

  //DbiResultPtr<PulserRawDriftF> dbiPulserRawDriftF;
  //UInt_t numRowsDriftF=dbiPulserRawDriftF.NewQuery(vldCtx,0);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"PulserRawDrift contains "<<numRowsDrift<<" rows"<<endl;
    //<<", PulserRawDriftF contains "<<numRowsDriftF<<" rows"<<endl;
  
  map<Int_t,LIPulserPin> rawDrift;
  //map<Int_t,LIPulserPin> rawDriftF;

  //loop over the pulser drift rows
  for(UInt_t i=0;i<numRowsDrift;i++) {
    //get the raw drift 
    const PulserRawDrift* pulserRawDrift=dbiPulserRawDrift.GetRow(i);

    UInt_t seidkey=pulserRawDrift->GetStripEnd();

    //fill the map
    rawDrift[seidkey].mean=pulserRawDrift->GetMean();
    rawDrift[seidkey].error=pulserRawDrift->GetError();
    rawDrift[seidkey].numEnt=pulserRawDrift->GetNumEntries();

    MSG("LIPlexMaps",Msg::kInfo)
      <<"Filling raw drift map="<<rawDrift[seidkey].mean
      <<" (+/- "<<rawDrift[seidkey].error*100<<"%)"<<endl;
  }
  //finished loop over the rows

  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Finished the GetPulserRawDrift method... ** "<<endl; 
  return rawDrift;
}
*/
//......................................................................

map<PlexLedId,LIPulserPin> LIPlexMaps::GetRawPinLedMap
(VldContext vldCtx)
{
  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Running the GetRawPinLedMap method... **"<<endl;

  PlexHandle *plexHandle=new PlexHandle(vldCtx);   

  DbiResultPtr<PulserRawDriftPin> driftRawPin;
  UInt_t numRowsPin=driftRawPin.NewQuery(vldCtx,0);

  if (static_cast<Int_t>(numRowsPin)!=NUMLEDS*NUMPULSERBOXES*2){
    MSG("LIPlexMaps",Msg::kWarning)
      <<"PulserRawDriftPin only contains "<<numRowsPin<<" rows"
      <<", expected "<<NUMLEDS*NUMPULSERBOXES*2<<endl;
  }

  map<PlexLedId,Float_t> pinAdc;
  map<PlexLedId,LIPulserPin> pinAdcOb;

  Int_t mapEntCounter=0;

  //loop over the pin rows
  for(UInt_t i=0;i<numRowsPin;i++) {

    //get the raw pin
    const PulserRawDriftPin* rawPin=driftRawPin.GetRow(i);
      
    PlexLedId ledId=plexHandle->GetLedId(rawPin->GetPinDiodeId());

    pair<PlexPinDiodeId,PlexPinDiodeId> plexPins=plexHandle->
      GetPinDiodeIds(ledId); // hi, low

    //ignore the low gain for now
    //if (rawPin->GetPinDiodeId()==plexPins.second) continue;

    //ignore the high gain for now
    if (rawPin->GetPinDiodeId()==plexPins.first) continue;

    MSG("LIPlexMaps",Msg::kDebug)
      <<"Got high gain pin:"<<endl;
    if (MsgService::Instance()->IsActive("LIPlexMaps",Msg::kDebug)){
      rawPin->GetPinDiodeId().Print();
    }

    //add the pin to the map
    pinAdc[ledId]=rawPin->GetMean();

    MSG("LIPlexMaps",Msg::kDebug)
      <<"Added pin mean="<<rawPin->GetMean()<<endl;

    pinAdcOb[ledId].mean=rawPin->GetMean();
    pinAdcOb[ledId].error=rawPin->GetError();
    pinAdcOb[ledId].numEnt=rawPin->GetNumEntries();

    if (rawPin->GetMean()<=0){
      MSG("LIPlexMaps",Msg::kInfo)
        <<"Warning bad pin="<<rawPin->GetMean()<<" (PB:LED)=("
        <<ledId.GetPulserBox()<<":"<<ledId.GetLedInBox()<<")"<<endl;
    }

    //count the number of entries
    mapEntCounter++;
  }

  //check the number of leds
  if (mapEntCounter!=NUMLEDS){
    MSG("LIPlexMaps",Msg::kWarning)
      <<"Only "<<mapEntCounter<<" entries added to pin map"<<endl;
  }

  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Finished the GetRawPinLedMap method... ** "<<endl; 
  return pinAdcOb;
}

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

map<Int_t,LIPulserPin> LIPlexMaps::GetRefAdcPinRatio(VldContext vldCtx) 
{
  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Running the GetRefAdcPinRatio method... **"<<endl;

  map<Int_t,LIPulserPin> pinAdc;

  Detector::Detector_t det=vldCtx.GetDetector();
  StripEnd::EStripEnd stripEndType = StripEnd::kUnknown;

  PlexHandle *plexHandle=new PlexHandle(vldCtx);   

  DbiResultPtr<PulserRefDriftPin> driftRefPin;
  UInt_t numRowsPin=driftRefPin.NewQuery(vldCtx,0);

  DbiResultPtr<PulserRefDrift> dbiPulserRefDrift;
  UInt_t numRowsDrift=dbiPulserRefDrift.NewQuery(vldCtx,0);

  static string sVldRange=dbiPulserRefDrift.GetValidityRec()->
    GetVldRange().AsString();
  static Bool_t firstTime=true;

  if (sVldRange==dbiPulserRefDrift.GetValidityRec()->
      GetVldRange().AsString() && !firstTime){
    return pinAdc;
  }

  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<"Running the GetRefAdcPinRatio method..."<<endl;

  //set up control variables for next time
  firstTime=false;
  sVldRange=dbiPulserRefDrift.GetValidityRec()->
    GetVldRange().AsString();

  MSG("LIPlexMaps",Msg::kInfo)
    <<"PulserRefDrift contains "<<numRowsDrift<<" rows"<<endl
    <<"PulserRefDriftPin contains "<<numRowsPin<<" rows"<<endl;

  Int_t mapEntCounter=0;

  //loop over the pin rows
  for(UInt_t i=0;i<numRowsPin;i++) {

    //get the ref pin
    const PulserRefDriftPin* refPin=driftRefPin.GetRow(i);
      
    PlexLedId ledId=plexHandle->GetLedId(refPin->GetPinDiodeId());

    pair<PlexPinDiodeId,PlexPinDiodeId> plexPins=plexHandle->
      GetPinDiodeIds(ledId); // hi, low

    //ignore the low gain for now
    if (refPin->GetPinDiodeId()==plexPins.second) continue;

    MSG("LIPlexMaps",Msg::kDebug)
      <<"Got high gain pin:"<<endl;
    if (MsgService::Instance()->IsActive("LIPlexMaps",Msg::kDebug)){
      refPin->GetPinDiodeId().Print();
    }

    for(Int_t pl=FIRSTPLANE;pl<=LASTPLANE;pl++){
      for(Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++){
        for(Int_t end=FIRSTEND;end<=SECONDEND;end++){
          
          if (end==StripEnd::kEast) stripEndType=StripEnd::kEast;
          else if (end==StripEnd::kWest) stripEndType=StripEnd::kWest;
          
          PlexStripEndId stripEndId(det,pl,st,stripEndType);
          
          if (!this->IsScintStrip(stripEndId,plexHandle)) continue;

          PlexLedId currentSELedId=plexHandle->GetLedId(stripEndId);

          if (currentSELedId==ledId){
            pinAdc[stripEndId.BuildPlnStripEndKey()].mean=refPin->
              GetMean();
            pinAdc[stripEndId.BuildPlnStripEndKey()].error=refPin->
              GetError();
            pinAdc[stripEndId.BuildPlnStripEndKey()].numEnt=refPin->
              GetNumEntries();
            
            MSG("LIPlexMaps",Msg::kDebug)
              <<"Filling map; mean="<<refPin->GetMean()<<endl;
            mapEntCounter++;
          }
        }
      }
    }
  }
  MSG("LIPlexMaps",Msg::kInfo)
    <<"Total entries added to pin map = "<<mapEntCounter<<endl;

  //create the map
  map<Int_t,LIPulserPin> adcPinRatio;
  
  //initialise the map
  for(Int_t pl=FIRSTPLANE;pl<=LASTPLANE;pl++){
    for(Int_t st=FIRSTSTRIP;st<=LASTSTRIP;st++){
      for(Int_t end=FIRSTEND;end<=SECONDEND;end++){
        
        if (end==StripEnd::kEast) stripEndType=StripEnd::kEast;
        else if (end==StripEnd::kWest) stripEndType=StripEnd::kWest;
        
        PlexStripEndId stripEndId(det,pl,st,stripEndType);
        
        adcPinRatio[stripEndId.BuildPlnStripEndKey()].mean=-1;
        adcPinRatio[stripEndId.BuildPlnStripEndKey()].error=-1;
        adcPinRatio[stripEndId.BuildPlnStripEndKey()].numEnt=-1;
        
      }
    }
  }
  
  //loop over the pulser drift rows
  for(UInt_t i=0;i<numRowsDrift;i++) {
    //get the ref drift 
    const PulserRefDrift* pulserRefDrift=dbiPulserRefDrift.GetRow(i);

    UInt_t seidkey=pulserRefDrift->GetStripEnd();

    //fill the map
    adcPinRatio[seidkey].mean=pulserRefDrift->GetMean();
    adcPinRatio[seidkey].error=pulserRefDrift->GetError();
    adcPinRatio[seidkey].numEnt=pulserRefDrift->GetNumEntries();

    //calculate adc/pin (protect against fpe)
    if (pinAdc[seidkey].mean>0){
      adcPinRatio[seidkey].mean/=pinAdc[seidkey].mean;

      //covert the error to be a relative error
      adcPinRatio[seidkey].error/=pulserRefDrift->GetMean();

      MSG("LIPlexMaps",Msg::kDebug)
        <<"Filling ratio map="<<adcPinRatio[seidkey].mean
        <<" (+/- "<<adcPinRatio[seidkey].error*100<<"%)"<<endl;
    }
    else {
      MSG("LIPlexMaps",Msg::kWarning)
        <<"Reference pin has zero mean!"<<endl;
    }
  }
  //finished loop over the rows

  MSG("LIPlexMaps",Msg::kDebug)
    <<endl<<" ** Finished the GetRefAdcPinRatio method... ** "<<endl;
  return adcPinRatio;
}

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

Bool_t LIPlexMaps::IsScintStrip(PlexStripEndId& stripEndId,
                                PlexHandle* plexHandle)
{
  MSG("LIPlexMaps",Msg::kVerbose)
    <<" ** Running the IsScintStrip method... **"<<endl;

  //get a raw channel id
  RawChannelId tempRawChId=plexHandle->GetRawChannelId(stripEndId);
  
  //check if rcid is a scintstrip
  if (plexHandle->GetReadoutType(tempRawChId)!=
      ReadoutType::kScintStrip){
    
    MSG("LIPlexMaps",Msg::kVerbose)
      <<"Ignoring ReadoutType="<<ReadoutType::AsString
      (plexHandle->GetReadoutType(tempRawChId))
      <<endl;       
    return false;
  }

  MSG("LIPlexMaps",Msg::kVerbose)
    <<" ** Finished IsScintStrip method... ** "<<endl; 
  return true;
}

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

void LIPlexMaps::ReadDbPulserDriftPin() 
{
  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Running the ReadDbPulserDriftPin() method... **"<<endl;

  //Thanks to Ryan for the DB code of this method  
  
  VldTimeStamp tsNow;
  VldContext vldNow(Detector::kCalDet,SimFlag::kData,tsNow);
  PlexHandle *plexHandle=new PlexHandle(vldNow);   

  DbiResultPtr<PulserRawDriftPin> driftRawPin;
  DbiResultPtr<PulserRefDriftPin> driftRefPin;

  //UInt_t numRows=dbiPulserDriftPin.NewQuery(vldNow,0);
  UInt_t numRows=driftRawPin.NewQuery(vldNow,0);
  driftRefPin.NewQuery(vldNow,0);

  MSG("LIPlexMaps",Msg::kInfo)
    <<"New DB query produced "<<numRows<<" rows"<<endl;

  map<Int_t,PulserRawDriftPin> rawPin;
  map<Int_t,PulserRefDriftPin> refPin;

  //loop over the rows
  for(UInt_t i=0;i<numRows;i++) {
  //const PulserRawDriftPin* pulserDriftPin=dbiPulserDriftPin.GetRow(i);
  //const PulserRefDriftPin* pulserDriftPin=dbiPulserDriftPin.GetRow(i);
      
    Int_t chAddRaw=plexHandle->GetRawChannelId
      (driftRawPin.GetRow(i)->GetPinDiodeId()).GetChAdd();
    Int_t chAddRef=plexHandle->GetRawChannelId
      (driftRefPin.GetRow(i)->GetPinDiodeId()).GetChAdd();
    
    rawPin[chAddRaw]=*driftRawPin.GetRow(i);
    refPin[chAddRef]=*driftRefPin.GetRow(i);
  }
  //finished loop over the rows

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

  map<Int_t,PulserRawDriftPin>::iterator raw=rawPin.begin();
  map<Int_t,PulserRefDriftPin>::iterator ref=refPin.begin();

  while(raw!=rawPin.end()){

    Float_t meanRaw=raw->second.GetMean();
    Float_t errorRaw=raw->second.GetError();
    Float_t numEntriesRaw=raw->second.GetNumEntries();
    Int_t chAddRaw=plexHandle->GetRawChannelId
      (raw->second.GetPinDiodeId()).GetChAdd();

    Float_t meanRef=ref->second.GetMean();
    Float_t errorRef=ref->second.GetError();
    Float_t numEntriesRef=ref->second.GetNumEntries();
    Int_t chAddRef=plexHandle->GetRawChannelId
      (ref->second.GetPinDiodeId()).GetChAdd();

    string sMeanRaw=Form("%.1f",meanRaw);
    string sErrorRaw=Form("%.2f",errorRaw);
    string sNumEntriesRaw=Form("%.0f",numEntriesRaw);
    string sChAddRaw=Form("%d",chAddRaw);

    string sMeanRef=Form("%.1f",meanRef);
    string sErrorRef=Form("%.2f",errorRef);
    string sNumEntriesRef=Form("%.0f",numEntriesRef);
    string sChAddRef=Form("%d",chAddRef); 

    string sMeanDif=Form("%.1f",meanRef-meanRaw);
    string sErrorDif=Form("%.2f",errorRef-errorRaw);
    string sNumEntriesDif=Form("%.0f",numEntriesRef-numEntriesRaw);
    string sChAddDif=Form("%d",chAddRef-chAddRaw); 

    MSG("LIPlexMaps",Msg::kInfo)
      <<endl
      <<"Ref (m,er,num,ch)=("<<sMeanRef<<";"<<sErrorRef
      <<";"<<sNumEntriesRef<<";"<<sChAddRef<<")"
      <<endl
      <<"Raw (m,er,num,ch)=("<<sMeanRaw<<";"<<sErrorRaw
      <<";"<<sNumEntriesRaw<<";"<<sChAddRaw<<")"
      <<endl
      <<"Diff (m,er,num,ch)=("<<sMeanDif<<";"<<sErrorDif
      <<";"<<sNumEntriesDif<<";"<<sChAddDif<<")"
      <<endl;

    raw++;
    ref++;    
  }


  MSG("LIPlexMaps",Msg::kInfo)
    <<endl<<" ** Finished the ReadDbPulserDriftPin() method... ** "
    <<endl; 
}

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

// Returns a map of SEID/gain values
std::map<Int_t,Double_t> LIPlexMaps::GetGainMap(Detector::Detector_t det, VldTimeStamp ts)
{
  std::map<Int_t,Double_t> gainmap;

  // Set up the validity context
  VldContext vldCtx(det, SimFlag::kData, ts);
  // and the database
  DbiResultPtr<CalADCtoPEs> dbiCalADCtoPEs;

  // Work out the task....
  Int_t task = 0;
  if (det == Detector::kNear) task = 1;

  // Run the query
  UInt_t numRows = dbiCalADCtoPEs.NewQuery(vldCtx,task);

  // TH1D *detgains = new TH1D("detgains", "detgains", 200, 0, 200);
  // if (det == Detector::kNear) {
  //   detgains->SetNameTitle("neargains", "Near Detector Gains");
  // } else {
  //   detgains->SetNameTitle("fargains", "Far Detector Gains");
  // }
  // Now run over each row in the query, keeping a running average  
  for (UInt_t i = 0; i < numRows; ++i)
  {
    const CalADCtoPEs* calAdcToPe = dbiCalADCtoPEs.GetRow(i);
    Float_t gain = calAdcToPe->GetGain();
    UInt_t seid = calAdcToPe->GetSEIDkey();
    // detgains->Fill(gain);
    gainmap[seid] = gain;
  }
  
  return gainmap;
}

TH1D LIPlexMaps::GainDifference(Detector::Detector_t det, VldTimeStamp first, VldTimeStamp second)
{
  
  LIPlexMaps LIPlex;
  
  // Read in maps for both of these
  std::map<Int_t,Double_t> pt1 = LIPlex.GetGainMap(det, first);
  std::map<Int_t,Double_t> pt2 = LIPlex.GetGainMap(det, second);
  
  cout << "First point SEIDs:  " << pt1.size() << endl;
  cout << "Second point SEIDs: " << pt2.size() << endl;

  // Make histograms
  TH1D gaindiff("gaindiff", "Difference in gains", 120, -30, 30);
  // TH2D stripvsplane("stripvsplane", "Strip versus plane differences", 290, 0, 290, 100, 0, 100);

  // Loop through every SEID
  for (map<Int_t,Double_t>::const_iterator it = pt1.begin(); it != pt1.end(); ++it) {
    UInt_t seid = it->first;
    Double_t gain = it->second;

    // check the other entry has this key
    if (!pt2.count(seid)) {
      MSG("LIPlexMaps",Msg::kFatal) << "Second timestamp does not have stripend-id " << seid << endl;
      throw runtime_error("Timestamps do not have matching SEIDs");
    }
    // Calculate the strip, plane
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seid,det,plane,strip,end);
//    cout << "SEID: " << seid << " (Plane " << plane << ", strip " << strip << ") = " << gain << endl;
    
    Double_t diff = pt2[seid] - gain;

    // Fill the histograms
    gaindiff.Fill(diff);
    // stripvsplane.Fill(plane,strip, diff);

  }

  // // Now write these out
  // TFile tf(outfile.c_str(),"recreate");
  // gaindiff.Write();
  // stripvsplane.Write();
  // tf.Close();
  
  return gaindiff;
  
}

TH2D LIPlexMaps::GainDifferenceSvP(Detector::Detector_t det, VldTimeStamp first, VldTimeStamp second)
{
  LIPlexMaps LIPlex;
  
  // Read in maps for both of these
  std::map<Int_t,Double_t> pt1 = LIPlex.GetGainMap(det, first);
  std::map<Int_t,Double_t> pt2 = LIPlex.GetGainMap(det, second);
  
  cout << "First point SEIDs:  " << pt1.size() << endl;
  cout << "Second point SEIDs: " << pt2.size() << endl;
  
  Int_t maxp, maxs;
  if (det == Detector::kFar) {
    maxp = 500;
    maxs = 200;
  } else {
    maxp = 300;
    maxs = 100;
  }
  TH2D stripvsplane("stripvsplane", "Strip versus plane differences", maxp, 0, maxp, maxs, 0, maxs);
  
  // Loop through every SEID
  for (map<Int_t,Double_t>::const_iterator it = pt1.begin(); it != pt1.end(); ++it) {
    UInt_t seid = it->first;
    Double_t gain = it->second;

    // check the other entry has this key
    if (!pt2.count(seid)) {
      MSG("LIPlexMaps",Msg::kFatal) << "Second timestamp does not have stripend-id " << seid << endl;
      throw runtime_error("Timestamps do not have matching SEIDs");
    }
    // Calculate the strip, plane
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seid,det,plane,strip,end);
//    cout << "SEID: " << seid << " (Plane " << plane << ", strip " << strip << ") = " << gain << endl;

    Double_t diff = pt2[seid] - gain;

    // Fill the histograms
    // gaindiff.Fill(diff);
    stripvsplane.Fill(plane,strip, diff);
  }
  
  return stripvsplane;
}

void LIPlexMaps::DumpGains(Detector::Detector_t det, VldTimeStamp ts, std::string gaindump_filename)
{
  // Set up the validity context
  VldContext vldCtx(det, SimFlag::kData, ts);

  // and the database
  DbiResultPtr<CalADCtoPEs> dbiCalADCtoPEs;

  // Work out the task....
  Int_t task = 0;
  if (det == Detector::kNear) task = 1;


  // Run the query
  UInt_t numRows = dbiCalADCtoPEs.NewQuery(vldCtx,task);

  // Open the text file
  ofstream gaindump(gaindump_filename.c_str());
  if (gaindump.is_open()) {
    MSG("LIPlexMaps",Msg::kInfo) << "Dumping gain values to " << gaindump_filename << endl;
    // Write a header to the gaindump
    gaindump  << "#"
              << setw(3) << "Pl" << " "
              << setw(3) << "Str" << " "
              << setw(3) << "End" << " "
              << setw(4) << "Agg" << " "
              << setw(6) << "SEID" << " "
              << setw(9) << "Gain" << " "
              << setw(9) << "Error"
              << "\n";
    
  } else {
    MSG("LIPlexMaps",Msg::kFatal) << "Error writing to gain dump file " << gaindump_filename << endl;
  }
  
  // Now run over each row in the query
  for (UInt_t i = 0; i < numRows; ++i)
  {
    // Grab the query row and extract information
    const CalADCtoPEs* calAdcToPe = dbiCalADCtoPEs.GetRow(i);
    
    // Get the easier values
    Int_t aggno = calAdcToPe->GetAggregateNo();
    Float_t gain = calAdcToPe->GetGain();
    Float_t gainerr = calAdcToPe->GetGainErr();
    Int_t seid = calAdcToPe->GetSEIDkey();
    
    // Calculate the strip, plane
    Int_t plane=-1;
    Int_t strip=-1;
    Int_t end=-1;
    fLookup.UnencodePlnStripEndKey(seid,det,plane,strip,end);
    
    // Now, write them all to file
    gaindump  << setw(4) << plane << " "
              << setw(3) << strip << " "
              << setw(3) << end << " "
              << setw(4) << aggno << " "
              << setw(6) << seid << " "
              << setw(9) << gain << " "
              << setw(9) << gainerr
              << "\n";
  } 
}

---