LIPlexMaps Class Reference

#include <LIPlexMaps.h>

Inheritance diagram for LIPlexMaps:

List of all members.

Public Member Functions
	LIPlexMaps ()
	~LIPlexMaps ()
void	CompareStripToStrip (Int_t det, VldTimeStamp ts, Int_t taskA, Int_t taskB)
void	DriftWithTime (VldRange vldRng, Float_t pointSpacingMinutes=20)
std::map< Int_t, Float_t >	GetRawPinMap (VldContext vldCtx)
std::map< PlexLedId, LIPulserPin >	GetRawPinLedMap (VldContext vldCtx)
std::map< Int_t, LIPulserPin >	GetRefAdcPinRatio (VldContext vldCtx)
void	DumpCalStripToStrip (std::string sDataFileName, Detector::Detector_t det, SimFlag::ESimFlag simFlag, VldTimeStamp ts, Int_t task) const
void	DumpCalStripAtten (std::string sDataFileName, Detector::Detector_t det, SimFlag::ESimFlag simFlag, VldTimeStamp ts, Int_t task)
Bool_t	IsPermitted () const
void	MakeCalAdcToPe (std::string gainsFileName, 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=false)
void	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=false)
void	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 sLongComment, Int_t iFileFormat, Bool_t writeToDb=false)
void	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)
void	MakePinPlexTables ()
void	MakePlexStripEndToLed (Bool_t writeToDb=false)
void	NormaliseVector (std::vector< Double_t > &v, Int_t mode=1)
void	PlotPlexPinMap ()
void	PlotPlexStripMap (Int_t detectorType)
void	PrintPlexPinDiodeInfo (Int_t detectorType)
void	PrintDbPinDiodeInfo ()
void	RatioRawToRefDrift ()
void	ReadDbCalStripToStrip (Int_t det, VldTimeStamp ts, Int_t task)
void	ReadDbCalStripAtten (Int_t det, VldTimeStamp ts, Int_t task)
void	ReadDbGains (Int_t det, SimFlag::ESimFlag simFlag, VldTimeStamp ts, std::string runNumber, std::string sAgg, Int_t task=0)
void	ReadDbPulserDrift (Int_t det, VldTimeStamp ts)
void	ReadDbPulserDriftPin ()
void	ReadDbPulserRawGain ()
void	SetGraphAxisEtc (TGraph *g, Int_t startTimeSecs, Int_t endTimeSecs)
void	ADCRailEffect ()
void	Attenuation ()
void	BinomialGen (std::vector< Double_t > &v, Int_t N, Double_t p)
void	FactorialGen (std::vector< Double_t > &v)
void	LIErrors ()
void	NonLinearity ()
void	PeGen ()
Int_t	SampleDist (std::vector< Double_t > v, TRandom *tRand)
void	ScaleVector (std::vector< Double_t > &v, Double_t scaleFactor)
Private Member Functions
std::string	GetElecString (RawChannelId rChId)
Bool_t	IsScintStrip (PlexStripEndId &stripEndId, PlexHandle *plexHandle)
Private Attributes
std::string	fS
LILookup	fLookup

---

Constructor & Destructor Documentation

LIPlexMaps::LIPlexMaps (   )

Definition at line 107 of file LIPlexMaps.cxx. References MSG. { MSG("LIPlexMaps",Msg::kDebug)<<"LIPlexMaps Constructor"<<endl; //set the pretty palette gStyle->SetPalette(1,(Int_t*)0); }

LIPlexMaps::~LIPlexMaps (   )

Definition at line 118 of file LIPlexMaps.cxx. References MSG. { MSG("LIPlexMaps",Msg::kDebug)<<"LIPlexMaps Destructor"<<endl; }

---

Member Function Documentation

void LIPlexMaps::ADCRailEffect (   )

Definition at line 917 of file LIPlexMaps.cxx. References MSG. { 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::Attenuation (   )

Definition at line 354 of file LIPlexMaps.cxx. References MSG, and LILookup::TGraphVect(). { 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::BinomialGen (  std::vector< Double_t > &  v, Int_t  N, Double_t  p )

Definition at line 245 of file LIPlexMaps.cxx. References FactorialGen(), MSG, and pow(). { 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::CompareStripToStrip (  Int_t  det, VldTimeStamp  ts, Int_t  taskA, Int_t  taskB )

Definition at line 5866 of file LIPlexMaps.cxx. References VldTimeStamp::GetDate(), PlexStripEndId::GetEnd(), PlexPlaneId::GetPlane(), CalStripToStrip::GetResponse(), DbiResultPtr< T >::GetRow(), PlexStripEndId::GetStrip(), CalStripToStrip::GetStripEndId(), MAXMSG, MSG, DbiResultPtr< T >::NewQuery(), VldContext::Print(), and LILookup::SetDetector(). { 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::DriftWithTime (  VldRange  vldRng, Float_t  pointSpacingMinutes = 20 )

Definition at line 6967 of file LIPlexMaps.cxx. References UtilMCFlag::AsString(), Detector::AsString(), PlexStripEndId::BuildPlnStripEndKey(), fLookup, Form(), fS, VldRange::GetDetectorMask(), PulserRawDriftF::GetError(), PulserRawDrift::GetError(), PulserRawDriftF::GetMean(), PulserRawDrift::GetMean(), PulserRawDriftF::GetNumEntries(), PulserRawDrift::GetNumEntries(), GetRawPinLedMap(), GetRawPinMap(), GetRefAdcPinRatio(), DbiResultPtr< T >::GetRowByIndex(), VldTimeStamp::GetSec(), VldRange::GetSimMask(), PulserRawDrift::GetStripEnd(), VldRange::GetTimeEnd(), VldRange::GetTimeStart(), DbiResultPtr< T >::GetValidityRec(), DbiValidityRec::GetVldRange(), MsgService::Instance(), MsgService::IsActive(), IsScintStrip(), MSG, DbiResultPtr< T >::NewQuery(), NormaliseVector(), PlexHandle::Print(), VldTimeStamp::Print(), LILookup::SetDetector(), SetGraphAxisEtc(), LILookup::TGraphVect(), and LILookup::UnencodePlnStripEndKey(). { 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::DumpCalStripAtten (  std::string  sDataFileName, Detector::Detector_t  det, SimFlag::ESimFlag  simFlag, VldTimeStamp  ts, Int_t  task )

Definition at line 4442 of file LIPlexMaps.cxx. References PlexStripEndId::GetEncoded(), PlexStripEndId::GetEnd(), CalStripAtten::GetFrac1(), CalStripAtten::GetFrac1Err(), CalStripAtten::GetLambda1(), CalStripAtten::GetLambda1Err(), CalStripAtten::GetLambda2(), CalStripAtten::GetLambda2Err(), PlexPlaneId::GetPlane(), DbiResultPtr< T >::GetRow(), CalStripAtten::GetSEIDkey(), PlexStripEndId::GetStrip(), CalStripAtten::GetStripEndId(), MAXMSG, MSG, DbiResultPtr< T >::NewQuery(), s(), and LILookup::SetDetector(). { 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::DumpCalStripToStrip (  std::string  sDataFileName, Detector::Detector_t  det, SimFlag::ESimFlag  simFlag, VldTimeStamp  ts, Int_t  task )  const

Definition at line 4402 of file LIPlexMaps.cxx. References PlexStripEndId::GetEncoded(), CalStripToStrip::GetResponse(), CalStripToStrip::GetResponseErr(), DbiResultPtr< T >::GetRow(), CalStripToStrip::GetStripEndId(), MSG, and DbiResultPtr< T >::NewQuery(). { 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::FactorialGen (  std::vector< Double_t > &  v  )

Definition at line 295 of file LIPlexMaps.cxx. References MSG. Referenced by BinomialGen(). { 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; }

string LIPlexMaps::GetElecString (  RawChannelId  rChId  )  [private]

Definition at line 2723 of file LIPlexMaps.cxx. References ElecType::AsString(), Form(), RawChannelId::GetCrate(), RawChannelId::GetElecType(), RawChannelId::GetGeographicAddress(), RawChannelId::GetMasterChannel(), RawChannelId::GetMinderChannel(), RawChannelId::GetVaAdcSel(), RawChannelId::GetVaChannel(), RawChannelId::GetVaChip(), RawChannelId::GetVarcId(), RawChannelId::GetVmm(), and MSG. Referenced by PrintDbPinDiodeInfo(), and PrintPlexPinDiodeInfo(). { 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; }

map< PlexLedId, LIPulserPin > LIPlexMaps::GetRawPinLedMap (  VldContext  vldCtx  )

Definition at line 8219 of file LIPlexMaps.cxx. References PulserRawDriftPin::GetError(), PlexHandle::GetLedId(), PlexLedId::GetLedInBox(), PulserRawDriftPin::GetMean(), PulserRawDriftPin::GetNumEntries(), PulserRawDriftPin::GetPinDiodeId(), PlexLedId::GetPulserBox(), DbiResultPtr< T >::GetRow(), MsgService::Instance(), MsgService::IsActive(), MSG, DbiResultPtr< T >::NewQuery(), and PlexPinDiodeId::Print(). Referenced by DriftWithTime(). { 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, Float_t > LIPlexMaps::GetRawPinMap (  VldContext  vldCtx  )

Definition at line 8093 of file LIPlexMaps.cxx. References PlexStripEndId::BuildPlnStripEndKey(), PlexHandle::GetLedId(), PulserRawDriftPin::GetMean(), PulserRawDriftPin::GetPinDiodeId(), LILookup::GetPinDiodeIds(), DbiResultPtr< T >::GetRow(), MsgService::Instance(), MsgService::IsActive(), MSG, DbiResultPtr< T >::NewQuery(), and PlexPinDiodeId::Print(). Referenced by DriftWithTime(). { 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::GetRefAdcPinRatio (  VldContext  vldCtx  )

Definition at line 8298 of file LIPlexMaps.cxx. References PlexStripEndId::BuildPlnStripEndKey(), VldContext::GetDetector(), PulserRefDrift::GetError(), PlexHandle::GetLedId(), PulserRefDrift::GetMean(), PulserRefDriftPin::GetMean(), PulserRefDrift::GetNumEntries(), PulserRefDriftPin::GetPinDiodeId(), LILookup::GetPinDiodeIds(), DbiResultPtr< T >::GetRow(), PulserRefDrift::GetStripEnd(), DbiResultPtr< T >::GetValidityRec(), MsgService::Instance(), MsgService::IsActive(), IsScintStrip(), MSG, DbiResultPtr< T >::NewQuery(), and PlexPinDiodeId::Print(). Referenced by DriftWithTime(). { 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::IsPermitted (   )  const

Definition at line 125 of file LIPlexMaps.cxx. References MSG. Referenced by MakeCalAdcToPe(), MakeCalMIPCalibration(), MakeCalStripAtten(), MakeCalStripToStrip(), and MakePlexStripEndToLed(). { 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; }

Bool_t LIPlexMaps::IsScintStrip (  PlexStripEndId &  stripEndId, PlexHandle *  plexHandle )  [private]

Definition at line 8455 of file LIPlexMaps.cxx. References PlexHandle::GetRawChannelId(), PlexHandle::GetReadoutType(), and MSG. Referenced by DriftWithTime(), and GetRefAdcPinRatio(). { 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::LIErrors (   )

Definition at line 1628 of file LIPlexMaps.cxx. References LILookup::CalcNpe(), LILookup::CalcRms(), fLookup, MSG, and pow(). { 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::MakeCalAdcToPe (  std::string  gainsFileName, 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 = false )

Definition at line 3491 of file LIPlexMaps.cxx. References LIPmt::AddMultiPoint(), VldRange::AsString(), PlexPixelSpotId::AsString(), Detector::AsString(), PlexStripEndId::BuildPlnStripEndKey(), DbiWriter< T >::CanOutput(), DbiWriter< T >::Close(), LIPmt::FillGainsHisto(), fLookup, Form(), fS, LIPmt::GetAvPmtGain(), RawChannelId::GetCrate(), PlexStripEndId::GetEncoded(), LILookup::GetNumericMuxBox(), PlexMuxBoxId::GetNumericMuxBox(), GetPixel(), PlexPixelSpotId::GetPixel(), PlexHandle::GetPixelSpotId(), LIPmt::GetPmtNum(), PlexHandle::GetRawChannelId(), PlexPixelSpotId::GetSpot(), PlexPixelSpotId::GetUniquePmtEncodedValue(), LIPmt::Initialise(), MsgService::Instance(), DbiWriter< T >::IsOpen(), IsPermitted(), PlexStripEndId::IsValid(), MSG, PlexPixelSpotId::Print(), PlexStripEndId::Print(), LILookup::SetDetector(), and LILookup::SetPbPlanes(). { 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); } } } 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; //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 writer DbiWriter<CalADCtoPE> writer(vr,aggNo,task,creationDate,dbName, sLogComment); Int_t NUMAGG = NUMCRATES; if(task==1) { NUMAGG = 484; if(det==1) NUMAGG = 194; } for(Int_t agg=0;agg<NUMAGG;agg++){ if(aggStat[agg]<0) continue; //create the 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(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; if (pixelNum>0 && pixelGain>0) pixGood=true; if (nnNum>0 && nnGain>0) nnGood=true; if (pmtNum>0 && pmtGain>0) pmtGood=true; 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++; } //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()); 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]); } //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; //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 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; if (writeToDb){ 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; } } else { MSG("LIPlexMaps",Msg::kInfo) <<"Mode is set to NOT write to database"<<endl<<endl; } } } //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; 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; } } //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::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 )

Definition at line 4976 of file LIPlexMaps.cxx. References VldRange::AsString(), DbiWriter< T >::CanOutput(), DbiWriter< T >::Close(), DbiWriter< T >::IsOpen(), IsPermitted(), and MSG. { 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::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  sLongComment, Int_t  iFileFormat, Bool_t  writeToDb = false )

Definition at line 4816 of file LIPlexMaps.cxx. References PlexStripEndId::AsString(), VldRange::AsString(), DbiWriter< T >::CanOutput(), DbiWriter< T >::Close(), DbiWriter< T >::IsOpen(), IsPermitted(), MAXMSG, MSG, pow(), and LILookup::SetDetector(). { 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::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 = false )

Definition at line 4665 of file LIPlexMaps.cxx. References VldRange::AsString(), DbiWriter< T >::CanOutput(), DbiWriter< T >::Close(), PlexStripEndId::GetEncoded(), DbiWriter< T >::IsOpen(), IsPermitted(), MAXMSG, MSG, myCalStripToStrip::response, myCalStripToStrip::responseErr, myCalStripToStrip::seid_enc, and LILookup::SetDetector(). { 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::MakePinPlexTables (   )

Definition at line 3429 of file LIPlexMaps.cxx. References fLookup, PlexLedId::GetEncoded(), PlexLedId::GetLedInBox(), LILookup::GetPinDiodeIds(), PlexLedId::GetPulserBox(), and MSG. { 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::MakePlexStripEndToLed (  Bool_t  writeToDb = false  )

a hack for caldet because both side of plane zero Definition at line 5052 of file LIPlexMaps.cxx. References ReadoutType::AsString(), DbiWriter< T >::CanOutput(), DbiWriter< T >::Close(), fLookup, Form(), fS, PlexLedId::GetEncoded(), PlexHandle::GetRawChannelId(), PlexHandle::GetReadoutType(), DbiWriter< T >::IsOpen(), IsPermitted(), MSG, VldRange::Print(), VldTimeStamp::Print(), LILookup::SetPbPlanes(), and LILookup::Strip2Led(). { 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::NonLinearity (   )

Definition at line 1021 of file LIPlexMaps.cxx. References MSG, pow(), and LILookup::TGraphVect(). { 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::NormaliseVector (  std::vector< Double_t > &  v, Int_t  mode = 1 )

Definition at line 164 of file LIPlexMaps.cxx. References MSG. Referenced by DriftWithTime(). { 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::PeGen (   )

Definition at line 1183 of file LIPlexMaps.cxx. References LILookup::CalcGain(), LILookup::CalcNpe(), LILookup::CalcRms(), fLookup, MSG, pow(), SampleDist(), and ScaleVector(). { 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::PlotPlexPinMap (   )

Definition at line 1782 of file LIPlexMaps.cxx. References MSG. { 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::PlotPlexStripMap (  Int_t  detectorType  )

Definition at line 2755 of file LIPlexMaps.cxx. References VldContext::AsString(), draw(), PlexStripEndId::GetEnd(), PlexHandle::GetLedId(), PlexLedId::GetLedInBox(), PlexPixelSpotId::GetPixel(), PlexHandle::GetPixelSpotId(), PlexPlaneId::GetPlane(), PlexPlaneId::GetPlaneView(), PlexLedId::GetPulserBox(), PlexHandle::GetRawChannelId(), PlexPixelSpotId::GetSpot(), PlexStripEndId::GetStrip(), RawChannelId::GetVaAdcSel(), RawChannelId::GetVaChannel(), RawChannelId::GetVaChip(), RawChannelId::GetVarcId(), RawChannelId::GetVmm(), PlexPixelSpotId::IsValid(), PlexLedId::IsValid(), PlexStripEndId::IsValid(), PlexPlaneId::IsValid(), and MSG. { 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::kFatal) <<"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::PrintDbPinDiodeInfo (   )

Definition at line 2533 of file LIPlexMaps.cxx. References GetElecString(), PlexPinDiodeId::GetGain(), PlexPinDiodeId::GetInBox(), DbiResultPtr< T >::GetNumRows(), PlexRawChannelToPinDiode::GetPlexPinDiodeId(), PlexRawChannelToPinDiode::GetRawChannelId(), and DbiResultPtr< T >::GetRow(). { 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()<<